Java语法--继承

为什么需要继承？

java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。

 对与猫和狗在构建类时会这样构建↓

建议创建一个包，包中一个class文件写一个类，这里方便展示就不一个class文件写多个类了。

class Cat{
    public String name;
    public int age;
    public double weight;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
    public void mimi(){
        System.out.println(this.name + "正在喵喵叫");
    }
}
class Dog{
    public String name;
    public int age;
    public double weight;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
    public void bark(){
        System.out.println(this.name + "正在汪汪叫");
    }
}

通过观察上述代码会发现，猫和狗的类中存在大量重复

那能否将这些共性抽取呢？

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

 什么是继承呢？

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

 对与上述的Dog和Cat类我们可以创建一个Animal类，Animal类中可以写Dog与Cat类的共性比如：名字，年龄，体重和吃这个方法。  Cat和Dog类就能继承Animal，继承之后，Cat与Dog类也被称之为子类，Animal类也被称之为父类。

继承的格式class 子类名 extents 父类名

class Animal{
    public String name;
    public int age;
    public double weight;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Cat extends Animal{
    public void mimi(){
        System.out.println(this.name + "正在喵喵叫");
    }
}
class Dog extends Animal{
    public void bark(){
        System.out.println(this.name + "正在汪汪叫");
    }
}

注意：
1. 父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

父类成员的访问：

子类和父类不存在同名成员变量

class Animal{
    public String name;
    public int age;
    public double weight;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Cat extends Animal{
    public int a = 0;
    public void func(){
        name = "咪咪";//访问父类继承下来的name
        age = 2;//访问父类继承下来的age
        weight = 15;//访问父类继承下来的weight
        a = 1;//访问子类自己的变量a
   
    }
    
}

子类和父类成员变量同名

class Animal{
    public String name = "二哈";
    public int age = 2;
    public double weight;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Dog extends Animal{
    String name = "金毛";
    int age = 2;
    public void func(){
        System.out.println(name);
        System.out.println(age);
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.func();
    }
}

 ​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

在子类和父类变量同名时，会优先访问子类的成员变量

总结：

如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

访问子类和父类的方法时也是同理

成员方法名字不同

class Animal{
    public String name;
    public int age;
    public double weight;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Cat extends Animal{
    public void mimi(){
        System.out.println(this.name + "正在喵喵叫");
    }
    public void func(){
        eat();//访问父类方法
        mimi();//访问子类方法
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.func();
    }
}

成员方法相同时

class Animal{
    public String name = "咪咪";
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Cat extends Animal{
    //方法重写
    public void eat(){
        System.out.println(this.name + "正在吃猫粮");
    }
    public void func(){
        eat();
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.func();
    }
}

 访问的子类的成员变量

这里还有一个知识点--方法重写与方法重载不同下篇多态的时候会说到

这时候会有一个疑问--父类和子类成员重名的时候会优先访问子类的成员，那父类的成员要如何访问呢？这里就要用到super

super关键字:

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

class Animal{
    public String name = "二哈";
}
class Dog extends Animal{
    String name = "金毛";
    public void func(){
        System.out.println(super.name);
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.func();
    }
}

这个时候调用func输出的结果为二哈

class Animal{
    public String name = "二哈";
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println(this.name + "正在吃猫粮");
    }
    public void func(){
        super.eat();
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.func();
    }
}

通过super关键字调用了父类的方法

在构造方法中的super()

super()类似于this()，this()是调用

如果父类和子类中都没有自己创建构造方法的化，编译器会自动在父类和子类中提供无参的构造方法.

自己创建构造方法的情况下如果父类中创建构造方法，子类中也必须要有此时就可以在子类中用super()传参来初始化成员变量

class Animal{
    public String name;
    public int age;
    public double weight;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
    //父类构造方法
    public Animal(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }
}
class Cat extends Animal{
    //子类构造方法
    public Cat(String name, int age, double weight) {
        super(name,age,weight);
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", weight=" + weight +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("咪咪",2,12);
        System.out.println(cat.toString());
    }
}

 在子类构造方法中，并没有写任何关于父类构造的代码，但是在构造子类对象时，先执行父类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整

 注意：
1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构
造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

IEAL编译器如何快速生成构造方法

 如何快速生成toString展示方法

接下来说一下super和this的相同点和不同点：

相同点：
1. 都是Java中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点：

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成
员的引用
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造
方法中出现
4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有 

 子类和父类静态代码块-实例代码块-构造方法的初始化的顺序

class Animal{
    static {
        System.out.println("调用了父类的静态代码块");
    }
    {
        System.out.println("调用了父类的实例代码块");
    }
    public Animal() {
        System.out.println("调用了父类的构造方法");
    }
}
class Cat extends Animal{
    static{
        System.out.println("调用了子类的静态代码块");
    }
    {
        System.out.println("调用了子类的实例代码块");
    }
    public Cat() {
        super();
        System.out.println("调用了子类的构造方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
    }
}

先执行静态代码块再执行父类的实例代码块和构造方法最后执行子类的实例代码块和构造方法（静态代码块只能执行一次，因为静态代码块是实在类加载的时候就被执行了，并不是在加载的时候）

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println("===============");
        Cat cat2 = new Cat();
    }
}

实例化第二个cat对象时，静态代码块不会被执行，因为类只能被加载一次

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println("===============");
        Cat cat2 = new Cat();
    }
}

在java语法中是可以无限继承的，但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.
如果想从语法上进行限制继承, 就可以使用 final 关键字

final关键字：

final修饰类不能被继承

可以看到会标红报错

final修饰变量也意味着将变量变成了常量类似于C语言中的const

final int a = 10;
a = 20; // 编译出错