【Java】—— 继承和多态

一、继承

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

1、继承的概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性
的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

2、继承的语法

需借助extends关键字来实现继承：

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

像“狗”继承“动物”就像是如下：

public class Dog extends Animal {
	//...
}

需要注意的是：

1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

一点注记：
子类和父类一般都是 is a 的关系，像：狗 is 动物…

3、子类中访问父类成员变量

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

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

例子：
下面代码会输出什么呢？a是子类的a还是父类的a呢?

class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base {
    public int c = 3;
    public int a = 4;

    public void method() {
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

public class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

答案是：子类的a

根据上述例子与理论我们总结道：
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

4、子类中访问父类成员方法

（1）成员方法名字不同

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

（2）成员方法名字相同

例如：

public class Base {
  public void methodA(){
    System.out.println("Base中的methodA()");
  }
  public void methodB(){
    System.out.println("Base中的methodB()");
  }
}
public class Derived extends Base{
  public void methodA(int a) {
    System.out.println("Derived中的method(int)方法");
 }
  public void methodB(){
    System.out.println("Derived中的methodB()方法");
 }
  public void methodC(){
    methodA();    // 没有传参，访问父类中的methodA()
    methodA(20);   // 传递int参数，访问子类中的methodA(int)
    methodB();    // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
 }
}

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
• 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错。（不同的话会进行方法重载）

那么如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？
⬇️⬇️⬇️

5、super关键字

super关键字的主要作用：在子类方法中访问父类成员
还是之前的代码例子，不过用了super关键字

class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base {
    public int c = 3;
    public int a = 4;

    public void method() {
        System.out.println(this.a);
        System.out.println(this.b);
        System.out.println(this.c);
        System.out.println(super.a);
    }
}

public class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

那么其运行结果为：

成功的用super访问到了父类中的a·
this可以访问子类和父类的，当子类成员和父类成员中名字相同时，则this访问得到的子类中的成员，而super只能访问父类中的成员
注意：
访问在子类中访问父类中的成员方法一样可以用super关键字

6、子类构造方法

先有父，再有子：子类对象构造时，需要先调用父类构造方法，然后执行子类的构造方法。
如果只在父类中写构造方法而子类中却无引用父类的构造方法，则会报错：

在子类中敲入构造方法后则报错消除：

注意：

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(…)只能在子类构造方法中出现一次，并且不能和this同时出现

那么同为关键字，super和this有什么区别呢？
⬇️⬇️⬇️

7、this和super的区别

相同点

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

不同点
4. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
5. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
6. 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
7. 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

8、初始化顺序

注意：

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

9、继承与组合

组合并没有涉及到特殊的语法，仅仅是将一个类的实例作为另外一个类的字段。

像汽车与他的各个零件系统之间就可以用组合的方式：
⬇️⬇️⬇️

// 轮胎类
class Tire{
  // ...
}
// 发动机类
class Engine{
  // ...
}
// 车载系统类
class VehicleSystem{
  // ...
}
class Car{
  private Tire tire;      // 可以复用轮胎中的属性和方法
  private Engine engine;    // 可以复用发动机中的属性和方法
  private VehicleSystem vs;  // 可以复用车载系统中的属性和方法
 
  // ...
}
// 奔驰是汽车
class Benz extend Car{
  // 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

二、多态

1、多态的概念

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

2、多态的实现条件

多态的实现必须满足如下几个条件：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

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

那什么是重写呢？
⬇️⬇️⬇️

3、重写

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

【方法重写的规则】

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

【重写和重载的区别】

区别点	重写(override)	重载(override)
参数列表	一定不能修改	必须修改
返回类型	一定不能修改（除非构成父子类关系）	可以修改
访问限定符	一定不能做更严格的限制（可以降低限制）	可以修改

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

4、向上转移和向下转型

（1）向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
例如：

Animal animal = new Cat("元宝",2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

【使用场景】

1. 直接赋值
2. 方法传参
3. 方法返回

缺点：不能调用子类特有方法

（2）向下转型

向下转型：将父类引用再还原为子类对象。
例如：

public class Test2 {
    public static void main(String[] args) {
        Animal animal = new Dog("小狗");
        Dog dog = (Dog) animal;
        dog.eat();
    }
}

把animal（大）给予dog（小）就是向下转型。

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

public class Test2 {
    public static void main(String[] args) {
        Animal animal1 = new Dog("小狗");
        Bird bird = (Bird) animal1;
        bird.fly();
    }
}

就会出现异常：

用 instanceof 来解决：

public class Test2 {
    public static void main(String[] args) {
        Animal animal1 = new Dog("小狗");
        if (animal1 instanceof Bird) {
            Bird bird = (Bird) animal1;
            bird.fly();
        } else {
            System.out.println("不能飞！");
        }
    }
}

不会出现异常了！

本章就到这儿啦！😜