Java基础---继承

一、什么是继承

1.1、为什么要继承

在java的类的创建的时候，我们不可避免的要创建许多的对象，而某些对象之间又会存在某些联系，
在这个时候，我们就可以把这些共性的特点抽取出来，单独设置为一个类，以此来实现代码的复用。

图中可以看出，玫瑰花和西红柿都有名字和颜色，还都可以进行生长，这个时候我们就可以把这些相同的地方抽取出来形成一个类。

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

1.2、继承的概念

继承就是在保留原有机制的基础上，实现扩展，形成新的派生类，是实现代码复用的重要手段，体现了由简单到复杂的过程，继承主要解决的问题就是：共性的抽取，代码的复用。

由上图可以发现，玫瑰花和西红柿都是植物，都有自己的名字和颜色，还有相同的方法。所以我们可以单独创建一个植物类来存储这些特点。

上图即为继承的过程，其中Plant类被称为父类、超类、基类，Rose和Tomato类被称为子类或派生类。

1.3、继承的语法

在Java中要表示类之间的继承关系，需extends关键字，如下：

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

对上面例子的继承：

class Plant {
    public String name;
    public String color;

    public Plant(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void togrow() {
        System.out.println("种" + this.name);
    }
}

class Rose extends Plant{
    public Rose(String name, String color) {
        super(name,color);
    }
    
    public void tolove() {
        System.out.println("给你爱的人");
    }
}
class Tomato extends Plant{
    public Tomato(String name, String color) {
        super(name,color);
    }
    
    public void toeat() {
        System.out.println("给你爱的人吃");
    }
}

注意：
1.子类会将父类的成员变量和成员方法继承过来
2.子类继承父类后，要添加自己的成员方法或成员变量，否则就没必要继承了

二、父类的访问

在继承体系中，子类将父类中的成员变量和方法继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

2.1、子类中访问父类的成员变量

2.2.1、子类和父类不存在同名变量

class Father {
    public int a = 10;
    public int b = 20;
}

class Son extends Father {
    public int c = 30;
    public void main(String[] args) {
        a = 1;//访问父类的a
        b = 2;//访问父类的b
        c = 3;//访问子类自己的c
    }
}

2.2.2、子类和父类成员变量同名

class Father {
    public int a = 10;
    public int b = 20;
    public int c = 30;
}

class Son extends Father {
    public int a;//同名，类型相同
    public char b;//同名，类型不同
    public void show() {
        a = 1;//访问父类继承的a？还是子类的a？
        b = 2;//访问父类继承的b？还是子类的b？
        c = 3;//子类没有c，访问的是父类继承的c
        //d = 4;//编译失败，父类和子类中都没有d
    }
}

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

1.如果访问的成员变量子类中没有，而父类有，访问的是父类中继承下来的
2.如果访问的成员变量子类中有，优先访问自己的
3.如果访问的成员变量在父类和子类中都没有，编译报错
4.如果访问的成员变量与父类的同名，优先访问子类自己的。

2.2、子类中访问父类的成员方法

class Father {
    public void showA() {
        System.out.println("访问的是父类的showA");
    }
    public void showB() {
        System.out.println("访问的是父类的showB");
    }
}

class Son extends Father {
    public void showA(int n) {
        System.out.println("访问的是子类的showA");
    }
    public void showB() {
        System.out.println("访问的是子类的showB");
    }

    public void test() {
        showA();//没有参数，访问的是父类showA
        showA(1);//有参数，访问的是子类showA
        showB();//直接访问的是子类的showB
    }

}

总结：
1.通过子类对象访问不同名的成员方法时，如果子类中有就访问自己的，否则在父类中找，找到就访问，否则编译报错## 标题
2.通过子类对象访问同名的成员方法时，如果父类和子类的方法构成了重载，就按照传递的参数进行访问

如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？
这个时候就需要我们的super关键字了

三、关键字

3.1、super关键字

由于设计或场景需要，子类和父类可能存在同名变量，这个时候，如果我们需要在子类中访问父类的成员变量，我们应该怎么做呢。
直接访问是无法做到的，Java提供了super关键字，该关键字的作用就是在子类中访问父类的成员。

class Super {
    public int a = 1;
    public int b = 2;

    public Super(int a, int b) {
        this.a = a;
        this.b = b;
    }
    public void func() {
        System.out.println("调用的是父类中的func");
    }
}

class Base extends Super {
    public int a = 10;//同名同类型
    public char b = 'b';//同名不同类型

    public Base(int a, int b, int a1, char b1) {
        super(a, b);
        this.a = a1;
        this.b = b1;
    }
    public void func() {
        System.out.println("调用的是子类中的func");
    }
    public void test() {

        //对于同名变量，直接访问都是访问子类的变量
        System.out.println(a);//结果会是10,不能直接访问到父类的a
        System.out.println(super.a);//结果会是1

        //对于重写的方法，也要通过super关键字
        func();//子类的
        super.func();//父类的
    }
}
public class Test1 {
    public static void main(String[] args) {
        Base bs = new Base(1,2,10,'B');
        bs.test();
    }
}

//运行结果：
10
1
调用的是子类中的func
调用的是父类中的func

注意：
1.super只能非静态方法中使用
2.在子类方法中访问父类的成员变量和方法

3.2、super和this

super和this都可以在成员方法中用来访问成员变量和调用其他成员方法，都可以作为构造语句的第一条语句，那他们之间有什么区别呢？

相同点：
1.都是Java的关键字
2.在构造方法中都要放在第一条语句
3.都只能在非静态的成员方法中使用，用来访问非静态的成员变量和字段

不同点：
1.this是当前对象的引用，当前对象指代调用该实例方法的对象，super是子类从父类继承下来的部分成员的引用
2.在非静态方法中，this用来访问本类的成员方法和变量，super用来访问从父类继承下来的方法和变量
3.在构造方法中，this(…)用来调用本类的构造方法，super(…)用来调用父类的构造方法，两者不能同时在构造方法中出现
4.在子类的构造方法中，一定会存在super(…)的调用，就算不写，编译器也会默认生成，但是this(…)不写则没有

3.3、final关键字

final关键字可以用来修饰变量，成员方法以及类

1.修饰变量或字段表示常量，既不能被修改
2.修饰成员方法，表示该成员方法不能被重写
3.修饰类，表示该类不能被继承

四、再谈初始化

4.1、子类父类构造方法的关系

在给子类进行初始化前，必须先给父类进行初始化
如上文代码块中的：

public Base(int a, int b, int a1, char b1) {
        super(a, b);//给父类进行初始化
        this.a = a1;
        this.b = b1;
    }

4.2、执行顺序

public class Test2 {
    public static void main(String[] args) {
        Students p2 = new Students("李四",7);
    }
}

class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类的构造方法被执行了");
    }

    public static void fj() {
        System.out.println("父类的静态方法被执行了");
    }

    static {
        System.out.println("父类的静态代码块被执行了");
    }

    {
        System.out.println("父类的实例代码块被执行了");
    }
}

class Students extends Person{
    public Students(String name, int age) {
        super(name, age);
        System.out.println("子类的构造方法被执行了");
    }

    public static void zj() {
        System.out.println("子类的静态方法被执行了");
    }

    static {
        System.out.println("子类的静态代码块被执行了");
    }

    {
        System.out.println("子类的实例代码块被执行了");
    }
}

//执行结果：
父类的静态代码块被执行了
子类的静态代码块被执行了
父类的实例代码块被执行了
父类的构造方法被执行了
子类的实例代码块被执行了
子类的构造方法被执行了

通过以上的执行结果，可以有以下结论：
1.静态代码块先执行，父类的静态代码块优先于子类
2.父类的实例代码块和构造方法紧接着执行
3.子类的实例代码块和构造方法紧接着这些

注意：
1.子类和父类的静态代码块只执行一次，第二次创建对象时不在执行
2.当有对象创建时，会执行实例代码块，再然后才是构造方法