Java 基础之面向对象【继承】

ゝ一纸荒年。 2023-09-29 18:28 35阅读 0赞

## 1. 继承 ##

*  继承的作用是代码复用（子类复用父类方法、字段等），**获得父类所有功能**
 *  `Java` 中用 `extends` 关键字来实现继承
 *  **每个类有且仅有一个父类，Object 除外**
 *  严禁定义与父类重名的字段
 *  若没有明确写继承某个类，就是继承 `Object` 类（编译器自动添加）
 *  被继承的类称为超类（`super class`），父类（`parent class`），基类（`base class`），继承的类称为 子类（`subclass`），扩展类（`extended class`）
 *  **子类无法访问父类被 private 修饰的字段或方法，除非使用 protected 修饰**

**使用方式**

// 定义父类的格式：（一个普通的类定义）
    public class 父类名称 {
        
        // ...
    }
    
    // 定义子类的格式：
    public class 子类名称 extends 父类名称 {
        
        // ...
    }

### 1.1 继承中成员变量和成员方法的访问 ###

**成员变量**

若子类成员变量与父类成员变量重名，则创建子类对象访问成员变量有两种方式：

*  直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上（父类）找
 *  间接通过成员方法访问成员变量：该访问属于谁，则优先使用谁，没有则向上（父类）找

1、`Fu.java`

public class Fu {
        
        int num = 26;
    
        int numFu = 260;
    
        public void methodFu(){
        
            System.out.println(num);
        }
    }

2、`Zi.java`

public class Zi extends Fu {
        
        int num = 36;
        int numZi = 360;
    
        public void methodZi() {
        
            System.out.println(numZi);
        }
    }

3、`DemoMain.java`

public class DemoMain {
        
        public static void main(String[] args) {
        
            Zi zi = new Zi();
    
            System.out.println(zi.numZi);
    
            // 等号左边是谁就优先用谁（这里是 zi），所有是 Zi 的 num
            System.out.println(zi.num);
            zi.methodZi();
            zi.methodFu();
            System.out.println(zi.numFu);   // Zi 没有就向上找父类
        }
    }

### 1.2 方法覆盖重写 Override ###

在继承关系中，子类的成员方法和父类的成员**方法名称一样，参数列表也一样**就称为方法的覆盖（覆写）

*  重写（`Override`）：方法的名称一样，参数列表【也一样】，覆盖、覆写
 *  重载（`Overload`）：方法的名称一样，参数列表【不一样】

覆写的特点是创建的子类对象优先使用子类方法：

public class OverrideMain {
        
        public static void main(String[] args) {
        
            Zi zi = new Zi();
            zi.method();
        }
    }
    
    class Fu {
        
        public void method() {
        
            System.out.println("父类方法执行");
        }
    }
    
    class Zi extends Fu {
        
        @Override
        public void method() {
        
            System.out.println("子类方法执行");
        }
    }

> 注意：

*  必须保证子类覆盖父类的方式，名称和参数列表要与父类一致，`@Override` 用于检测是否正确覆写
 *  子类的返回值必须小于等于父类的返回值范围
 *  子类方法的权限必须大于等于父类方法的权限修饰符：`public > protected > (default 留空) > private`，比如父类方法的权限修饰符为 `public`，子类必须也是 `public`，不能小于 `public`

### 1.3 super 关键字 ###

`super` 的含义与 `this` 类似，**常用于调用父类的构造方法**；任何`class`的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句`super();`

public class SuperDemo {
        
        public static void main(String[] args) {
        
            Zi zi = new Zi();
            zi.show();
        }
    }
    
    class Fu {
        
        public Fu() {
        
            System.out.println("父类无参构造！");
        }
    
        public Fu(int num) {
        
            System.out.println("父类有参构造！");
        }
    
        public void call() {
        
            System.out.println("打电话");
        }
    
        public void send() {
        
            System.out.println("发短信");
        }
    
        public void show() {
        
            System.out.println("显示号码");
        }
    }
    
    class Zi extends Fu {
        
        public Zi() {
        
            super();    // 调用父类无参构造，即使不显示加 super()，编译器也会默认添加一个 super()
    //        super(26);    // 不能连续调用两次父类构造
            System.out.println("子类无参构造");
        }
    
        @Override
        public void show() {
        
            super.show();   // 调用父类的方法，复用父类功能
            // 子类新增功能
            System.out.println("显示姓名");
            System.out.println("显示头像");
    
    //        super();      // 父类的构造方法只能在子类的构造方法中调用，不能在其他方法中调用
        }
    }

**继承关系中，父子类构造方法的访问特点**

*  子类构造方法当中有一个默认隐含的 `super()` 调用，所以一定是先调用的父类构造，后执行的子类构造
 *  子类构造可以通过`super`关键字来调用父类重载构造
 *  `super` 的父类构造调用，**必须是子类构造方法的第一个语句**，不能一个子类构造调用多次`super`构造
 *  子类必须调用父类构造，不显示写，编译器会默认 **赠送 super()**，若显示地写了则使用写的，且 `super` 有且只能有一个

--------------------

**this 和 super 使用区别**

当中子类中局部变量和本来成员变量以及父类成员变量重名时，可以使用 `this、super` 来进行区分：

public class Zi extends Fu {
        
    
        int num = 20;
    
        public void method() {
        
            int num = 30;
            System.out.println(num); // 局部变量
            System.out.println(this.num); // 本类的成员变量
            System.out.println(super.num); // 父类的成员变量
        }
    
    }

> 注意：子类*不会继承*任何父类的构造方法

### 1.4 protected 关键字 ###

父类中被 `private` 修饰的字段或方法，其子类是不能访问的，除非使用 `protected` 关键字修饰，**它可以将调用范围控制在继承树内**：

class Person2 {
        
        protected String name = "rose";
    
    //    private String name = "rose";
    }
    
    class Student2 extends Person2 {
        
        private double score = 99;
    
        public double getScore() {
        
            System.out.println(this.name);
            return this.score;
        }
    }

### 1.5 阻止继承 sealed ###

主要用于一些框架，防止继承被滥用，只有在继承列表中的类，才能继承该类（`Java15` 新特性）：

// 只有 A、B、C 三个类才能继承
    public sealed class A, B, C, D {
        
        ...
    }
    
    // 继承
    public final class B extends A {
        ...}
    
    // java15 开启，需要配置相应参数 --enable-preview和--source 15

### 1.6 向上/下转型 ###

要转型，首先要有继承，分为以下两种类型：

*  向上转型：子类对象转为父类，父类可以是接口。公式：`Father f = new Son()`，`Father`是父类或接口，`son`是子类，属于自动转换
 *  向下转型：父类对象转为子类。公式：`Son s = (Son)f`，可能会失败，可使用 `instanceof`操作符，可以先判断一个实例究竟是不是某种类型，属于强制转换

public class TransUpDown {
        
        public static void main(String[] args) {
        
            Human h = new Male();   // 向上转型
            h.sleep();
            Male m = new Male();
            m.sleep();
        }
    }
    
    class Human {
        
        public void sleep() {
        
            System.out.println("人类正在睡觉...");
        }
    }
    
    class Male extends Human {
        
    
        public void sleep() {
        
            System.out.println("男人正在睡觉...");
        }
    
        public void speak() {
        
            sleep();
            System.out.println("男人正在说话...");
        }
    }
    
    class Femal extends Human {
        
        public void sleep() {
        
            System.out.println("女人正在睡觉...");
        }
    
        public void speak() {
        
            sleep();
            System.out.println("女人正在说话...");
        }
    }

向下转型，先判断再转型，避免错误：

Human h1 = new Human();
    System.out.println(h1 instanceof Human);    // true
    System.out.println(h1 instanceof Male); // false
    
    Male m1 = new Male();
    System.out.println(m1 instanceof Human);    // true
    System.out.println(m1 instanceof Male); // true
    
    Male m2 = null;
    System.out.println(m2 instanceof Male); // false
    
    // 先判断再转型
    Human h2 = new Male();
    if (h2 instanceof Male) {
        
        Male m3 = (Male) h2;
    }

--------------------

**更多示例**

当需要通过父类的对象调用某个方法时，向上转型可以确定参数的统一，方便程序设计：

// 向上转型
    public class TransUpDown {
        
        public static void func(A a) {
        
            a.print();
        }
    
        public static void main(String[] args) {
        
    //        A a = new B();  //通过子类去实例化父类
    //        a.print();  // B is print...  父类A的print方法已经被子类B的print方法覆盖了
    
            A a = new B();
            C c = new C();
            func(a);
            func(c);
    
        }
    }
    
    class A {
        
        public void print() {
        
            System.out.println("A is print...");
        }
    }
    
    class B extends A {
        
        public void print() {
        
            System.out.println("B is print...");
        }
    }
    
    class C extends A {
        
        public void print() {
        
            System.out.println("C is print...");
        }
    }

> 注意：向上转型时，父类只能调用父类方法或者子类覆写后的方法，而子类中的单独方法则是无法调用的，向下转型实际用的比较少！

### 1.7 继承和组合的区别 ###

*  继承：两个类之间与 `is` 关系，即子类继承父类，父类的所有属性和方法都可以被子类访问和调用
 *  组合：两个类互为 `has` 关系，是指将已存在的类型作为一个新建类的成员变量类型，又叫“对象持有”

要实现的目标：鸟（`Bird`）和狼（`Wolf`）都是动物（`Animal`），动物都有心跳（`beat()`），会呼吸（`breath()`），但是鸟会`fly`（`fly()`），狼会奔跑（`run()`），用 `Java` 程序实现：

1、继承实现：

public class ExtendAndHas {
        
        public static void main(String[] args) {
        
            Bird b1 = new Bird();
            b1.fly();
            Wolf w1 = new Wolf();
            w1.run();
        }
    }
    
    class Animal {
        
        public void beat() {
        
            System.out.println("心脏跳动中...");
        }
    
        public void breath() {
        
            beat();
            System.out.println("正在呼吸...");
        }
    }
    
    class Bird extends Animal {
        
        public void fly() {
        
            beat();
            breath();
            System.out.println("我是鸟儿，正在飞翔...");
        }
    }
    
    class Wolf extends Animal {
        
        public void run() {
        
            beat();
            breath();
            System.out.println("我是狼，正在奔跑...");
        }
    }

2、组合实现：

public class ExtendAndHas {
        
        public static void main(String[] args) {
        
            Animal a1 = new Animal();
            Bird b1 = new Bird(a1);
            b1.fly();
            Wolf w1 = new Wolf(a1);
            w1.run();
        }
    }
    
    class Animal {
        
        public void beat() {
        
            System.out.println("心脏跳动中...");
        }
    
        public void breath() {
        
            beat();
            System.out.println("正在呼吸...");
        }
    }
    
    class Bird {
        
        // 定义一个 Animal 成员变量，供组合使用
        private Animal a;
    
        // 构造函数初始化成员变量
        public Bird(Animal a) {
        
            this.a = a;
        }
    
        //通过调用成员变量的固有方法（a.breath()）使新类具有相同的功能（breath()）
        public void breath() {
        
            a.breath();
        }
    
        //为新类增加新的方法
        public void fly() {
        
            System.out.println("我是鸟，我会飞...");
        }
    }
    
    class Wolf {
        
        private Animal a;
    
        public Wolf(Animal a) {
        
            this.a = a;
        }
    
        public void beat() {
        
            a.beat();
        }
    
        public void run() {
        
            System.out.println("我是狼，我会奔跑...");
        }
    }

> 多用组合少用继承，因为组合更安全，更简单，更灵活，更高效