继承和final关键字

前言：?

? ? ? ?这一篇，我们就来学习面向对象的第二大特征-继承（一定要有类的基础，详情请看Java中的类和方法（方法重载）-CSDN博客）。

什么是继承？

? ? ? ?当我们创建两个类时，发现这两个类都有公共特征时，就可以利用继承，减少相同的代码量。

? ? ? ?我们定义两个类，一个狗类一个猫类，他们都有相同的几个属性：姓名、年龄。一个相同的方法：吃饭。

class Dog{
    public String name;
    public int age;

    public void eat(){
        System.out.println(this.name + "正在吃饭");
    }

    public void bark(){
        System.out.println(this.name + "正在汪汪叫");
    }
}

class Cat{
    public String name;
    public int age;

    public void eat(){
        System.out.println(this.name + "正在吃饭");
    }

    public void bark(){
        System.out.println(this.name + "正在喵喵叫");
    }
}

public class New {
}

继承关键字和使用：?

? ? ? ?继承的关键字是extend，那么接下来我们就将这些共同的属性和方法进行抽取，并让其他的小类继承这个大类：

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(this.name + "正在吃饭");
    }
}

class Dog extends Animal{
    public void bark(){
        System.out.println(this.name + "正在汪汪叫");
    }
}

class Cat extends Animal{
    public void bark(){
        System.out.println(this.name + "正在喵喵叫");
    }
}

public class New {
}

private修饰的父类：?

? ? ? ?子类会将父类的成员变量或者方法继承到子类去。被private修饰，也是可以被继承的，只是访问还是需要get和set方法，是否还记得那张图？

? ? ? ?因为是子类，不支持直接访问，所以还是要进行进行间接访问。

父类和子类用相同成员变量和方法：?

? ? ? ?我们来看以下代码：

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

class Der extends Base{
    public int c;
    public void method(){
        a = 1;
        b = 2;
        c = 3;
    }
}

public class Test {
    Der d = new Der();
}

? ? ? ?此时父类和子类成员变量名不同。我们来看相同的情况。?

class Base{
    public int a = 20;
    public int b = 90;
}

class Der extends Base{
    public int a = 1;

    public void method(){
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

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

? ? ? ?也就是说，当父类和子类有相同变量成员时，优先看子类有有没有，没有再去父类中去找。所以成员变量和方法的访问遵循就近原则，自己有就限访问自己的，如果没有就去向父类中找。?

? ? ? ?此时调用方法也是一样的。

class Base{
    public void method() {
        System.out.println("Base::method()");
    }
}

class Der extends Base{
    public void method() {
        System.out.println("Der::method()");
    }
    public void method2() {
        System.out.println("Der::method()");
    }

    public void test() {
        method();
        method2();
    }
}

public class Test {
    public static void main(String[] args) {
        Der d = new Der();
        d.test();
    }
}

? ? ? ?当子类和父类中都有相同的成员和方法时，我们如果去使用方法就会使用子类中的方法，那么此时我们如何去使用父类中的成员或者方法呢？?此时就需要用到super关键字了。

super关键字：?

super调用父类成员：

? ? ? ?当子类和父类中存在相同的成员变量和方法时，为了更好的区分，我们要使用super关键字。

class Base{
    int a = 99;
    public void method() {
        System.out.println("Base::method()");
    }
}
class Der extends Base{
    int a = 1;
    public void method() {
        System.out.println("Der::method()");
    }
    public void method2() {
        System.out.println("Der::method()");
    }
    public void test() {
        System.out.println(super.a);//使用super关键字访问父类成员
        super.method();//使用super关键字调用父类方法
        method2();
    }
}

public class Test {
    public static void main(String[] args) {
        Der d = new Der();
        d.test();
    }
}

? ? ? ?由此可见，super关键字是对标this的，我们来对比一下：

class Base{
    int a = 99;
}
class Der extends Base{
    int a = 1;
    public void test() {
        System.out.println(super.a);//使用super关键字访问父类成员
        System.out.println(this.a);
        System.out.println(a);
    }
}

public class Test {
    public static void main(String[] args) {
        Der d = new Der();
        d.test();
    }
}

super调用父类方法：

? ? ? ?和this的用法类似，可以使用super.方法。

class Base{
    public int a = 99;
    public void fun1(){
        System.out.println("hehe");
    }
}
class Der extends Base{
    public void fun2() {
        super.fun1();
    }
}
public class Test {
    public static void main(String[] args) {
        Der d = new Der();
        d.a = 99;
        d.fun2();
    }
}

成员初始化：

? ? ? ?有没有想过一个问题，就是如何将子类构造初始化？那么父类又是如何构造的？此时就需要知道super调用构造方法了。

super调用构造方法：

? ? ? ?因为写入了有参构造器，没有提供参数，所以报错。使用无参构造器则不报错。

? ? ? ?我们来观察子类继承了父类，父类成员如何初始化。子类在构造完成之前，一定要先帮助父类进行初始化。

? ? ? ?所以此时借助super来调用父类构造器。比如此时我们父类是有参构造器：

class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(this.name + "正在吃饭");
    }
}

class Dog extends Animal{
    public Dog() {
        super("远远",10);
    }

    public void bark(){
        System.out.println(this.name + "正在汪汪叫");
    }
}

? ? ? ?在此之前，我们没有写任何构造方法却编译通过了呢？还是一样的，它默认给了一个无参构造器（因为父类中也没有写构造器，父类中默认提供一个无参构造器，子类中默认体格一个无参构造器）。

//Dog类中的默认无参构造器
public Dog() {
    super();
    //只能有一个且必须在第一行
    //调用父类构造方法 帮助初始化 子类从 父类继承过来的成员 并不生成 父类对象
}

所以super有以下用法：

• super.成员变量
• super.成员方法
• super()调用构造方法

this和super对标，也和以上一样。

? ? ? ?this针对当前对象；super针对当前对象的父类。

和this的共性：

? ? ? ?都只能在非静态方法中使用，在构造器中调用时，必须是构造方法中的第一条语句，且不能同时存在。

再谈初始化（结合代码块）：

? ? ? ?还是否记得我们上一章节讲解的代码块的内容？那么接下来，我们就结合代码块来讲解在继承关系中是如何执行的。

class Animal{
    static {
        System.out.println("Animal::static");
    }
    public Animal() {
        System.out.println("Animal::构造");
    }

    {
        System.out.println("Animal::实例");
    }
}

class Dog extends Animal{
    static {
        System.out.println("Dog::static");
    }
    {
        System.out.println("Dog::实例");
    }
    
    public Dog() {
        super();
        System.out.println("Dog::构造");
    }
}

public class New {
    public static void main(String[] args) {
        Dog d = new Dog();
    }
}

? ? ? ?注意静态代码块最先执行且只执行一次。

protected性质和用法：

? ? ? ?看过我之前文章的小伙伴都知道了private和default（包权限修饰符）的用法和性质，通过以上的知识也就知道了父类和子类的关系。那么接下来我们就来具体讲解protected的性质和用法。

? ? ? ?我们先创建两个包，一个包是父类，另一个包继承父类（就是子类）。将父类的变量用protected修饰，此时直接访问报错。

? ? ? ?此时要用super访问。?

? ? ? ?依旧报错，此时是因为super和this不能再静态方法中使用，所以我们可以定义一个非静态方法。?

? ? ? ? 所以对于protected修饰的成员或者变量，不同包的子类可以访问。所以protected一般出现在继承当中，继承的父类一定是用public修饰的。

? ? ? ? 定义类时，只能用public，其余不行，否则报错。

final关键字：?

? ? ? ?我们先来看下面这张图：

? ? ? ?当继承到一定程度时，我们不想再继承时，就要使用final关键字了。?

? ? ? ?此时发现用final修饰的类不能在被继承，否则报错。所以final修饰的类也称密封类，表示当前类不能在被继承了。?

? ? ? ?因为java中没有const关键字，但是不代表没有常量，所以final也是常量修饰关键字。

? ? ? ?一般我们不希望出现多于3层的继承关系，所以要使用final关键字。

? ? ? ?final修饰方法：表示这个方法是密封方法，不能被重写。