继承和多态

继承

面相对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类 特性的

基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由

简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

例如：猫和狗都是动物，将共性抽取出来，采用继承思想达到共用。

上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即

语法

通过extends关键字

修饰符 class 子类 extends 父类{
    //...
}

注意：

1. 子类会将 父类中的 成员变量 或者 成员方法 继承到子类中

2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承

父类成员访问

在继承体系中，子类将父类中的方法和字段继承下来

子类中访问父类成员变量

子类和父类中不存在同名变量

public class Base {
    int a;
    int b;
} 
p
ublic class Derived extends Base{
    int c;
    public void method(){
        a = 10; // 访问从父类中继承下来的a
        b = 20; // 访问从父类中继承下来的b
        c = 30; // 访问子类自己的c
    }
}

子类和父类成员变量同名

public class Base{
    int a;
    int b;
    int c;
}

public class Derived extends Base{
    int a;        //与父类成员a同名，且类型相同
    char b;        //与父类成员b同名，但类型不同
    
    public void method(){
        a=100;    //访问子类
        b=101;    //访问子类的b
        c=102;    //访问父类
    }
}

注意

在子类方法中 或者 通过子类对象访问成员时：

• 如果访问的成员变量子类中有，优先访问自己的成员变量。
• 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错
• 如果访问的成员变量与父类成员变量同名，优先访问自己的（子类的），即：子类将父类同名成员隐藏了

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找

子类中访问父类的成员方法

方法名不同

同变量相同

public class Base{
    public void methodA(){
        System.out.println("父类");    
    }
}
public class Derived extends Base{
    public void methodB(){
        System.out.println("子类");    
    }
    public void method(){
        methodA();    //父类
        methodB();    //子类    
    }
}

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错

方法名相同

public class Base{
    public void methodA(){
        System.out.println("父类");    
    }
}
public class Derived extends Base{
    public void methodA(int a){
        System.out.println("子类");    
    }
    public void method(){
        methodA(20);    //子类
        methodA();    //父类    
    }
}

【说明】

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则 访问，否则编译报错。
• 通过派生类对象访问父类与子类同名方法时，
  • 如果父类和子类同名方法的参数列表不同(重载)，根据调用 方法适传递的参数选择合适的方法访问，如果没有则报错；
  • 如果父类和子类同名方法的原型一致(重写-后 面讲)，则只能访问到子类的，父类的无法通过派生类对象直接访问到。

问题：如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢

super关键字

如果要在子类中访问父类同名成员时，通过super关键字

super关键字主要作用：在子类方法中访问父类的成员

public class Base {
    int a;
    int b;
    public void methodA(){
        System.out.println("Base中的methodA()");
    } 
    p
ublic void methodB(){
        System.out.println("Base中的methodB()");
    }
} 

public class Derived extends Base{
    int a; // 与父类中成员变量同名且类型相同
    char b; // 与父类中成员变量同名但类型不同
    // 与父类中methodA()构成重载
    public void methodA(int a) {
        System.out.println("Derived中的method()方法");
    } 
    /
/ 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    } 
    public void methodC(){
        // 对于同名的成员变量，直接访问时，访问的都是子类的
        a = 100; // 等价于： this.a = 100;
        b = 101; // 等价于： this.b = 101;
        // 注意：this是当前对象的引用
        // 访问父类的成员变量时，需要借助super关键字
        // super是获取到子类对象中从基类继承下来的部分
        super.a = 200;
        super.b = 201;
        // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
        methodA(); // 没有传参，访问父类中的methodA()
        methodA(20); // 传递int参数，访问子类中的methodA(int)
        // 如果在子类中要访问重写的基类方法，则需要借助super关键字
        methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
        super.methodB(); // 访问基类的methodB()
    }
}

注意事项

• 只能在非静态方法中使用
• 在子类方法中，访问父类的成员变量和方法

子类构造方法

先有父再有子：子类对象构造时，先调用基类构造方法，再执行子类构造方法

public class Base(){
    public Base(){
        System.out.println("Base()");    
    }
}
public class Derived extends Base{
    public Derived(){
        // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
        // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
        // 并且只能出现一次
        System.out.println("Derived()");
    }
} 
public class Test {
    public static void main(String[] args) {
        Derived d = new Derived();
    }
} 

结果打印：
Base()
Derived()

原因：子类对象继承自父类对象，在构造子类对象时，先要将父类继承的成员初始化完整，再初始化子列自己新增的成员

注意事项

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造 方法

2. 如果父类构造方法是带有参数的，此时编译器不会再给子类生成默认的构造方法，此时需要用户为子类显式定 义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。

4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

super和this

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句

相同点

• 都是Java关键字
• 只能在类的非静态方法中，用来访问非静态成员方法和字段
• 在构造方法中调用时，必须时构造方法中的第一条语句，并且不能同时存在

不同点

• this时当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中父类继承下来部分 成员的引用

• 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
• this是非静态成员方法的一个隐藏参数，super不是隐藏的参数
• 成员方法中直接访问本类成员时，编译之后会将this还原，即本类非静态成员都是通过this来访问的；
• 在子类中 如果通过super访问父类成员，编译之后在字节码层面super实际是不存在的(通过字节码文件可以验证)

• 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方 法中出现
• 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

再谈初始化

实例代码块和静态代码块，在继承关系中的执行顺序

非继承关系中

详见 类和对象

• 静态代码块先执行，且只执行一次，在类加载阶段执行
• 当对象创建时，才执行实例代码块，执行后执行构造方法

继承关系中

class Person{
    public String name;
    public int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("Person：构造方法执行");            
    }
    {
        System.out.println("Person：实例代码块执行");    
    }
    static{
        System.out.println("Person：静态代码块执行");    
    }
}

public class Student{
    public Student(String name,int age){
        super(name,age);
        System.out.println("Student：构造方法执行");            
    }
    {
        System.out.println("Student：实例代码块执行");    
    }
    static {
        System.out.println("Student：静态代码块执行");    
    }
}

public class Main(){
    public static void main(String[] args){
        Student student1 = new Student("张三",19);
        System.out.println("===========================");
        Student student2 = new Student("gaobo",20);
    }
}

执行结果

Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

结论

• 父类静态代码块优先于子类静态代码块，且最早执行
• 父类实例代码块和父类构造方法紧接着执行
• 子类代码块和子类构造方阿飞紧接着执行
• 第二次实例化子列对象时，父类和子类的静态代码块都将不会执行

protected关键字

在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问。

注意：父类中private成员变量随时在子类中不能直接访问，但是也继承到子类中了

使用选择

尽量做到"封装"，即：隐藏内部实现细节，只暴露 必要的信息 给类的调用者

因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用public.

希望同学们能写代码的时候认真思考, 该类提供的字段方法到底给 "谁" 使用(是类内部 自己用, 还是类的调用者使用, 还是子类使用)

继承方式

注意：Java中不支持多继承。

一般我们不希望出现超过三层的继承关系.

如果想从语法上进行限制继承, 就可以使用 final 关键字

final关键字

final关键可以用来修饰变量、成员方法以及类

修饰变量或字段，表示常量(即不能修改)

final int a = 10;
a = 20; // 编译出错

修饰类：表示此类不能被继承

final public class Animal {
    ...
} 
public class Bird extends Animal {
    ...
} 
/
/ 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承

修饰方法：表示该方法不能被重写(后序介绍)

继承与组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸 如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段

继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物

组合表示对象之间是has-a的关系，比如：汽车

汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的

// 轮胎类
class Tire{
    // ...
} 

/
/ 发动机类
class Engine{
    // ...
} 

/
/ 车载系统类
class VehicleSystem{
    // ...
} 

c
lass Car{
    private Tire tire; // 可以复用轮胎中的属性和方法
    private Engine engine; // 可以复用发动机中的属性和方法
    private VehicleSystem vs; // 可以复用车载系统中的属性和方法
    // ...
} 

/
/ 奔驰是汽车
class Benz extend Car{
    // 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合。

多态

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

多态实现条件

• 必须在继承体系下
• 子类必须要对父类中的方法重写
• 通过父类的引用调用重写的方法

多态体现：当代码可运行时，当传递不同对象时，会调用对应类中的方法

animals这个引用调用eat方法可能会有多种不同的表现（和animals这个引用的实例相关），这种行为叫做多态.

重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进 行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写规则

• 子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符 返回值类型 方法名（参数列表）要完全一致
• JDK7以后，被重写的方法返回值类型可以不同，但必须具有父子关系（协变类型）
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法 就不能声明为 protected
• 父类被static、private修饰的方法、构造方法都不能被重写。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将
• 方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成 重写.

【重写和重载的方法】

区别点	重载（override）	重写（override）
参数列表	修改	不修改
返回类型	可以修改	一定不能修改
访问限定符	可以修改	一定不能做更严格的限制（可以降低限制）
异常	可以修改	可以减少或删除，一定不能抛出新的或更广的异常

方法重载是一个类的多态性，方法重写是子类与父类的多态性

重写的设计原则

对于已经投入使用的类，尽量不要进行修改，最好的方式：重新定义一个新的类，来重复利用其中共性的内容，并添加或改动新的内容

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表

函数重载。(重载)

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调

用那个类的方法。（重写）

向上转型和向下转型

向上转型

实际就是创建一个子类对象，将其当成父类对象使用

语法格式：父类类型 对象名 = new 子类类型

Animal animal = new cat("元宝"，3);

Animal是父类类型，但可以引用一个子类对象，因为：子类对象是一个父类对象，即可以将一个子类对象当成父类对象来应用。因此：向上转型是安全的，因为是从小范围向大范围的转换

使用场景

• 直接赋值
• 方法传参
• 方法返回

public class TestAnimal {
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eatFood(Animal a){
        a.eat();
    } 
    /
/ 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗" == var){
            return new Dog("狗狗",1);
        }else if("猫" == var){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    } 
    p
ublic static void main(String[] args) {
        Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象
        Dog dog = new Dog("小七", 1);
        eatFood(cat);
        eatFood(dog);
        Animal animal = buyAnimal("狗");
        animal.eat();
        animal = buyAnimal("猫");
        animal.eat();
    }
}

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
        // 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();
        // 编译失败，编译时编译器将animal当成Animal对象处理
        // 而Animal类中没有bark方法，因此编译失败
        // animal.bark();
        // 向上转型
        // 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
        // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
        cat = (Cat)animal;
        cat.mew();
        // animal本来指向的就是狗，因此将animal还原为狗也是安全的
        dog = (Dog)animal;
        dog.bark();
    }
}

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
        // 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();
        if(animal instanceof Cat){
            cat = (Cat)animal;
            cat.mew();
        } 
        i
f(animal instanceof Dog){
            dog = (Dog)animal;
            dog.bark();
        }
    }
}

多态的优缺点

好处

1.能够降低代码的“圈复杂度”，避免使用大量的 if - else

什么叫 "圈复杂度" ?

圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果 有很多的条件分支或者循环语句, 就认为理解起来更复杂.

因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 "圈复杂度". 如 果一个方法的圈复杂度太高, 就需要考虑重构.

不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10

if - else 打印多个形状

public static void drawShapes() {
    Rect rect = new Rect();
    Cycle cycle = new Cycle();
    Flower flower = new Flower();
    String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
    for (String shape : shapes) {
        if (shape.equals("cycle")) {
            cycle.draw();
        } else if (shape.equals("rect")) {
            rect.draw();
        } else if (shape.equals("flower")) {
            flower.draw();
        }
    }
}

多态使用

public static void drawShapes() {
    // 我们创建了一个 Shape 对象的数组.
    Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
    new Rect(), new Flower()};
    for (Shape shape : shapes) {
        shape.draw();
    }
}

2.可扩展里更强

如果要新增一种新的形状，使用多态的方式代码改动成本也比较低

class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("△");
    }
}

对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低.

而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.

多态缺陷：代码的运行效率降低

避免在构造方法中调用重写的方法

创建两个类，B是父类，D是子类，D中重写func（）方法，并且在B的构造方法中调用func（）

class B {
    public B() {
        // do nothing
        func();
    } 
    p
ublic void func() {
        System.out.println("B.func()");
    }
} 
c
lass D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
} 
p
ublic class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}

/
/ 执行结果
D.func() 0

• 构造 D 对象的同时, 会调用 B 的构造方法.
• B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
• 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0.

最难不过坚持！