继承 封装 多态

1.封装

封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。

public class User {

    private Integer id;

    private String name;
    
    // 获取id
    public Integer getId() {
        return id;
    }
    
    // 设置id
    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

2.继承

继承就是子类继承父类的特征和行为，使得子类对象具有父类的域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

注意：

①子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。

②子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

③子类可以用自己的方式实现父类的方法

class Animal{

    public int i;
    private int j;
    public void f1(){
        System.out.println("Animal类的f1()");
    }
    private void f2(){
        System.out.println("Animal类的f2()");
    }
}
class Cat extends  Animal{
    // 重写父类的方法
    public void f1(){
        System.out.println("Cat类的f1()");
    }
}

2.1 重写

重写：子类对父类的允许访问的实现过程进行重新编写

重写要遵循”两同两小一大“的规则："两同"指方法名相同、形参列表相同，”两小“指子类方法的返回值<=父类方法的返回值、子类方法声明抛出的异常<=父类方法声明抛出的异常，”一大“指子类的方法访问权限>=父类方法的访问权限

2.2 构造器的调用顺序

class Meal{
    Meal(){
        System.out.println("Meal()");
    }
}
class Bread{
    Bread(){
        System.out.println("Bread()");
    }
}
class Cheese{
    Cheese(){
        System.out.println("Cheese()");
    }
}
class Lettuce{
    Lettuce(){
        System.out.println("Lettuce()");
    }
}
// Meal的子类
class Lunch extends Meal{
    Lunch(){
        System.out.println("Lunch()");
    }
}
// Lunch的子类
class PortableLunch extends Lunch{
    PortableLunch(){
        System.out.println("PortableLunch()");
    }
}
public class Sandwich extends PortableLunch {

    private Bread bread = new Bread();
    private Cheese cheese = new Cheese();
    private Lettuce lettuce = new Lettuce();

    public Sandwich(){
        System.out.println("Sandwich()");
    }

    public static void main(String[] args) {
        new Sandwich();
    }
}

输出：

综上可知，构造器的调用顺序：

①调用父类构造器

②按照声明顺序调用成员的初始化方法

③调用子类构造器

3.多态

多态表示一个对象具有多种的状态。具体表现为父类的引用指向子类的实例。

class Animal{

    public void f1(){
        System.out.println("Animal类的f1()");
    }
}
class Cat extends  Animal{
    // 重写父类的方法
    public void f1(){
        System.out.println("Cat类的f1()");
    }
}

class Dog extends Animal{
    public void f1(){
        System.out.println("Dog类的f1()");
    }
}
public class ExtendsTest {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.f1();
    }
}

注意：

①对象类型和引用类型之间具有继承（类）/实现（接口）的关系

②引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定

③多态不能调用“只在子类存在但在父类不存在”的方法

④如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法