你一定要学会的Java语法 -- 【继承】

class Animal{
    public String name;
    public int age;
    public String color;
    public void eat(){
        System.out.println(this.name+" 正在吃饭....");
    }
    public void sleep(){
        System.out.println(this.name+" 正在睡觉....");
    }
}
class Dog extends Animal{
    public void bark(){
        System.out.println(this.name+" 正在汪汪叫....");
    }
}
class Cat extends Animal{
    public void mew(){
        System.out.println(this.name+" 正在喵喵叫....");
    }
}
public class test {
    public static void main(String[] args) {
        Dog dog = new Dog();  
// dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        dog.name = "旺财";
        dog.eat();
        dog.sleep();
        dog.bark();
        System.out.println("=======");
        Cat cat = new Cat();
        cat.name = "花花";
        cat.eat();
        cat.sleep();
        cat.mew();
    }
}

运行结果：

通过运行结果我们发现，我们根本就没有在Dog这个类里面定义name，age，但是可以访问，原因就是这些都是从Animal这个类当中继承下来的。

注意：

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

上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可

【结论】 ：子类继承了父类之后，子类就可以使用父类的成员变量和成员方法。通过代码和图片能看出继承最大的作用就是：实现代码复用

4.父类成员访问

大家都知道，在继承体系中子类将父类的方法字段继承下来，子类能直接访问父类，那子类和父类的名字一样呢？

子类和父类成员变量同名

java 复制代码

class Base{
    public int a = 1;
    public int b = 2;
}
class Derived extends Base{
    public int a = 10;
    public int b = 20;
    public void print(){
        System.out.println(a);
        System.out.println(b);
    }
}
public class Main {
    public static void main(String[] args) {
         Derived derived = new Derived();
         derived.print();
    }
}

运行结果：

子类和父类成员方法同名

java 复制代码

class methodA{
    public void print(){
        System.out.println("父类的print方法");
    }
}
class methodB extends methodA{
    public void print(){
        System.out.println("子类的print方法");
    }
}
public class test1 {
    public static void main(String[] args) {
         methodB methodB = new methodB();
         methodB.print();
    }
}

运行结果：

【总结】：成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类找，父类也没有就报错。

那问题是，如果我们想访问父类的成员呢？

5.super关键字

在有些场景下，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成

员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

java 复制代码

class Base{
    public int a = 1;
    public int b = 2;
}
class Derived extends Base{
    public int a = 10;
    public int b = 20;
    public void print(){
        System.out.println(super.a);
        System.out.println(super.b);
    }
}
public class Main {
    public static void main(String[] args) {
         Derived derived = new Derived();
         derived.print();
    }
}

运行结果：

在子类中，如果想要明确访问父类中的成员是，借助super关键字即可。

【注意事项】

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

6.子类构造方法

子类对象构造时，需要先调用父类的构造方法，然后执行子类的构造方法（可以理解成先有父后有子）。

运行结果：

一个小栗子

java 复制代码

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

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Dog extends Animal{
    public String color;

    public Dog(String name, int age, String color) {
        //调用父类的，带有两个参数的构造方法，来初始化父类当中的成员
        super(name,age); 
        //在子类成员初始化完成之前要帮父类完成初始化
        this.color = color;
    }

    public void bark(){
        System.out.println(this.name+" 正在汪汪叫....");
    }
}
public class test2 {
    public static void main(String[] args) {
        Dog dog = new Dog("阿黄",2,"白色");
    }
}

注意事项：

1.若父类定义无参或者默认的构造方法，在子类构造方法的第一行默认有隐含的super。
2.在子类构造方法中，**super（）**调用父类构造时，必须在子类构造函数的第一条语句。
3.super（）只能在子类构造方法中出现一次，并且不能和**this（）**同时出现。

7.super和this

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

【相同点】

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

【不同点】

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

8.深入了解初始化

我们知道在没有继承关系时执行顺序是：静态代码块 > 实例代码块 > 构造代码块

那在继承关系上的执行顺序呢？

java 复制代码

class Person{
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类的构造方法");
    }
    {
        System.out.println("父类的实例");
    }
    static {
        System.out.println("父类的静态方法");
    }
}
class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
        System.out.println("子类的构造方法");
    }
    {
        System.out.println("子类的实例");
    }
    static {
        System.out.println("子类的静态方法");
    }
}
public class test3 {
    public static void main(String[] args) {
        Student student1 = new Student("张三",18);
        System.out.println("==========");
        Student student2 = new Student("李四",19);
    }
}