java面向对象编程——继承与多态-CFANZ编程社区

一、继承

继承是面向对象的一种强大的机制，可以实现代码的复用，通过extends关键字实现

class Person{
    
}
class Student extends Person{
    
}

ps:子类会自动获得父类的所以字段，不能在子类中再去定义和父类字段相同的字段

扩展：在OOP的术语中，把Person称为超类（super class），父类（parent class），基类（base class），把Student称为子类（subclass），扩展类（extended class）

1、继承树

没有写extends关键字，默认继承Object类
java只允许一个类继承自一个类，也就是每个类只有一个父类，Object比较特殊，它没有父类

protected

子类无法访问父类中的private字段和private方法，修改父类中的字段为protected属性，可以让子类成功访问

原因：protected让字段和方法的访问控制在继承树的内部

super 父类

子类访问父类中的name字段 super.name 、 this.name和name效果一样
子类不会继承父类的构造方法，子类默认的构造方法都是编译器自动生成的，如果父类没有默认的构造方法，需要调用super()让编译器自动匹配父类中的构造方法

阻止继承

如果没有用final关键字，任何类都可以继承
sealed关键字修饰，限定能够继承的类， permits明确哪些类能继承
```
public sealed class Person permits Xiaoming, Lihua{
    ……
}
```

向上转型和向下转型

向上转型(upcasting)就是把子类类型安全地转为父类类型

例如继承树为 Student -> Person -> Object,可以把Student类转化成Person类，甚至Object类
向下转型(downcasting)把父类类型转为子类类型

这样做可能出错，因为父类的方法比子类少，可能转化不成功,通过isinstance()先判断再转换

2、继承与组合

继承是is的关系，组合是has的关系

class Book{
    ...
}
class Person{
    ...
}
class Student extends Person{
    private Book book;
}

二、多态

override(覆写)，覆写体现的是子类和父类之间的多态性，运行时的多态
overload(重载)，重载体现的是类中方法的多态性，编译时的多态

ps:方法名相同，方法参数相同，但方法返回值不同，也是不同的方法

1、多态的形式

/*
父类  对象名称 = new 子类名称

接口 对象名称 = new 实现类构造器
*/

方法调用：编译看左，运行看右
变量调用：编译看左，运行看右

2、覆写Obejct方法

toString()方法，将实例输出为字符串类型
equals()方法，判断两个实例是否相等
hashcode()方法，计算hash值

super可以实现在子类覆写的方法中调用父类被覆写的方法

3、final的作用

final修饰的类不允许被继承
final修饰的方法不允许被重写
final修饰的字段在创建对象时初始化完，之后不允许被修改

4、学后一题

建立一个汽车Auto类包括轮胎个数汽车颜色车身重量、速度等成员变量。并通过不同的构造方法创建实例。至少要求汽车能够加速减速停车。再定义一个小汽车类Car 继承Auto 并添加空调、CD等成员变量覆盖加速减速的方法。

Auto.java

package Object;

/**
 * @className:Auto;
 * @time:2022-04-18-11:09;
 * @author:Lee Ye;
 * @description:这是一个java示例;
 */
public class Auto {
    public int tire;
    public String color;
    public int weight;
    public int speed;
    public Auto(){

    }
    public Auto(int tire, String color, int weight, int speed){
        this.tire = tire;
        this.color = color;
        this.weight = weight;
        this.speed = speed;
    }
    public void speedup(int i){

        System.out.printf("the speed in auoto is %d", i);
        this.speed += i;
    }
    public void speeddown(int i){
        this.speed -= i;
    }

}

Car.java

package Object;

/**
 * @className:Car;
 * @time:2022-04-18-11:23;
 * @author:Lee Ye;
 * @description:这是一个java示例;
 */
public class Car extends Auto {
    private String condition;
    private String CD;
    public Car(int tire, String color, int weight, int speed, String condition, String CD){
        super(tire, color, weight,  speed);
        this.condition = condition;
        this.CD = CD;

    }
    public void speedup(int i){
        System.out.printf("the i in class Car is %d\n", i);
        this.speed *= i;
        System.out.printf("the current speed in class Car is %d\n", this.speed);
    }
    public void speeddown(int i){
        this.speed -= 2 * i;
    }

}

Test_Auto.java

package Object;
import Object.Car;
import Object.Auto;

/**
 * @className:Test_Auto;
 * @time:2022-04-18-11:31;
 * @author:Lee Ye;
 * @description:这是一个java示例;
 */
public class Test_Auto {
    public static void main(String[] args) {
        Auto benchi = new Car(4, "Black", 200, 70, "geli", "2s");
        System.out.printf("Start speed is  %d\n", benchi.speed);
        benchi.speedup(10);
        System.out.printf("stop speed is %d\n", benchi.speed);

    }
}