封装、继承、多态

封装

封装把⼀个对象的属性私有化，同时提供⼀些可以被外界访问的属性的⽅法，如果属性不想被外界访问，我们⼤可不必提供⽅法给外界访问。但是如果⼀个类没有提供给外界访问的⽅法，那么这个类也没有什么意义了。封装的好处在于：隐藏类的实现细节;让使用者只能通过程序员规定的方法来访问数据;可以方便的加入存取控制语句,限制不合理操作。

属性私有化

public class Father {
    private String name;
    private int age;
    }

提供Getter和Setter方法对属性进行访问

public class Father {
    private String name;
    private int age;

    public Father() {
    }

    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

继承

继承是使⽤已存在的类的定义作为基础建⽴新类的技术，新类的定义可以增加新的数据或新的功能，也可以⽤⽗类的功能，但不能选择性地继承⽗类。通过使⽤继承我们能够⾮常⽅便地复⽤以前的代码。
关于继承如下 3 点请记住：

⼦类拥有⽗类对象所有的属性和⽅法（包括私有属性和私有⽅法），但是⽗类中的私有属性和⽅法⼦类是⽆法访问，只是拥有。

public class Father {
    private String name;
    private int age;

    public Father() {
    }

    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //子类拥有 但是不能访问
    private void dirve(){
    System.out.println("开车");
    }

⼦类可以拥有⾃⼰属性和⽅法，即⼦类可以对⽗类进⾏扩展。

public class Son extends Father{
	//子类独有的属性
	private String ToyCar
    public Son() {
    }

    public Son(String name, int age) {
        super(name, age);
    }
    //子类独有的方法
    public void call(){
        System.out.println("叫爸爸");
    }
}

⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法。

public class Son extends Father{
    public Son() {
    }

    public Son(String name, int age) {
        super(name, age);
    }
    public void call(){
        System.out.println("叫爸爸");
    }
    //重写父类方法 用自己的方式实现父类方法
     @Override
    public void say() {
        System.out.println("我是儿子");
    }
}

多态

多态就是指程序中定义的引⽤变量所指向的具体类型和通过该引⽤变量发出的⽅法调⽤在编程时并不确定，⽽是在程序运⾏期间才确定，即⼀个引⽤变量到底会指向哪个类的实例对象，该引⽤变量发出的⽅法调⽤到底是哪个类中实现的⽅法，必须在由程序运⾏期间才能决定。
在 Java 中有两种形式可以实现多态：继承（多个⼦类对同一方法的重写）和接口（实现接口并覆盖接口中同⼀⽅法）

继承实现

在这里 Fater son1 = new Son();
son1究竟是当作父类用，还是当作子类用呢？
其实是当成父类对象使用
原因是：编译时 son1被认为是Father类型；但是在运行时，是Student类型。但是内存中其实是子类对象。
内存分析如下：

接口实现

以顾客买车为例先创建接口并且定义买车方法

public interface Car {
    public void buyCar();
}

使用宝马和奔驰作为接口的实现类

public class BMW implements Car{
    @Override
    public void buyCar() {
        System.out.println("买宝马");
    }
}

public class Benz implements Car{
    @Override
    public void buyCar() {
        System.out.println("买奔驰");
    }
}

在定义一个顾客类用来调用买车方法

public class Custom {
    public void buyCar(Car car){
        car.buyCar();
    }
}

最后测试

public class CarTest {
    public static void main(String[] args) {
        Car bmw = new BMW();
        Car benz = new Benz();
        Custom custom = new Custom();
        custom.buyCar(bmw);//买宝马
        custom.buyCar(benz);//买奔驰
    }
}

debug一下我们可以知道，父类的引用类型指向了子类的地址，因此当custom的buyCar()传入参数时调用的是子类的buyCar。

封装、继承、多态

Java相关栏目本月热门文章