初识Java--继承

前言

面向对象的三大特征：封装性、继承性、多态性。
前面学习了其中的封装性，这次是继承性。继承是多态的前提，如果没有继承，就没有多态。继承主要解决的问题就是：共性抽取。

继承关系当中的特点：

1. 子类（派生类）可以拥有父类（基类或超类）的“内容”。
2. 子类还可以拥有自己专有的内容。

一、继承性

定义父类的格式：（一个普通的类定义）

public class 父类名称{
    // ...
}

定义子类的格式：

public class 子类名称 extends 父类名称 {
    // ...
}

在继承关系中，“子类就是一个父类”。即子类可以被当做父类看待。

在父子类的继承关系中，创建子类对象，访问成员变量

在父子类继承关系中，如果成员变量重名，创建子类对象时，访问方式有两种。

1. 直接通过子类对象访问成员变量； 等号左边是谁，就优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量；该方法属于谁，就优先用谁，没有则向上找。

如果变量名重名：
局部变量：直接写成员变量名
本类的成员变量：this.成员变量名
父类的成员变量：super.成员变量名

创建、使用父子类：

// 父类
public class Fu {
    int numFu = 10;
    int num = 100; // 父类的成员变量
    public void methodFu() {
        System.out.println(num);
    }
}

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

// 使用父子类
	public static void main(String[] args) {
        Fu fu = new Fu();
        System.out.println(fu.numFu); // 10
        Zi zi = new Zi();
        System.out.println(zi.numFu); // 10
        System.out.println(zi.numZi); // 20
        System.out.println(zi.num); // 200
        // 这个方法是子类的，优先使用子类，没有再向上找
        zi.methodZi(); // 200
        // 这个方法是在父类当中定义的
        zi.methodFu(); // 100
        // 这个方法是子类的
        zi.extendZi();
    }

覆盖重写

在父子类的继承关系中，创建子类对象，访问成员方法的规则是：创建对象是谁，就优先用谁，没有向上找。

重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表一样

重写（Override）：方法的名称一样，参数类别【也一样】。覆盖、重写。
重载（Overload）：方法的名称一样，参数类别【不一样】。

方法覆盖重写特点：创建的是子类对象，优先用子类方法。

方法覆盖重写的注意事项：

1. 必须保证父子之间方法的名称相同，参数列表也相同。
   @Override：写在方法前面，用来检测是否有效的正确覆盖重写。
   注解不写，只要满足情况，也是正确的方法覆盖重写
2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
   java.lang.Object 类是所有类的公共最高父类，java.lang.String 就是 Object 的子类
3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
   public > protected > (default) > private
   备注： (default) 不是关键字 default ，而是什么都不写，留空。

举例：

// 创建父类
public class Fu {
    public void methodFu() {
        System.out.println("父类方法执行！");
    }
    public void method() {
        System.out.println("父类重名执行");
    }
}

// 创建子类
public class Zi extends Fu {
    public void methodZi() {
        System.out.println("子类方法执行！");
    }
    @Override
    public void method() {
        System.out.println("子类重名方法执行"); // 对父类method方法进行了覆盖、重写
    }
}

// 实现
	public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodZi(); // 子类方法执行！
        zi.methodFu(); // 父类方法执行！
        zi.method(); // 子类重名方法执行
    }

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，不会向下找子类。

继承关系中，构造方法的访问特点

1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行子类构造。
2. 可以通过super关键字来子类构造调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。

super关键字的三种用法：

1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。

this关键字的三种用法：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
   在第三种用法当中：
   A.this(…)调用也必须是构造方法的第一个语句，唯一一个；
   B.super和this两种构造调用，不能同时使用。

super关键字用来访问父类内容，而this关键字用来访问本类内容。

二、抽象类、抽象方法

如果父类当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法。

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

如何使用抽象类和抽象方法：

1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
   覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4. 创建子类对象进行使用。
5. 一个抽象类不一定含有抽象方法。
6. 要保证抽象方法所在的类是抽象类。

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。

举例：

// 抽象父类
public abstract class Animal {
    // 抽象方法
    public abstract void eat(); // 抽象方法eat()
    // 普通的成员方法
    public void normalMethod() {
    }
}

// 子类1
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼"); // 对父类当中的eat()抽象方法进行覆盖重写
    }
}

// 子类2（抽象子类）（子类3的父类）
public abstract class Dog extends AnimalFu {
    @Override
    public void eat() {
        System.out.println("狗吃肉"); // 对父类当中的eat()抽象方法进行覆盖重写
    }

	// 抽象方法
    public abstract void sleep(); 
}

// 子类3
public class DogSon extends Dog{
    @Override
    public void sleep() {
        System.out.println("狗睡觉"); // 对父类（子类2）当中的sleep()抽象方法覆盖重写
    }
}

// 实现类
	public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat(); // 猫吃鱼
        // Dog d = new Dog() ; // 已经作为DogSon的父类，错误
        DogSon ds = new DogSon();
        ds.sleep(); // 狗睡觉
        ds.eat(); // 狗吃肉
    }