继承 「Java」

目录

1.继承的定义

2.继承的特点

当父类子类没有同名变量时

当子类父类有同名变量时

3.super调用父类构造方法

4.super和this

相同点

 不同点

 父类大于子类，静态大于实例，且静态只执行一次

5.继承与组合 

---

今天这篇文章给大家介绍一下继承在Java中的运用👀👀

1.继承的定义

继承就是将父类的特性继承给子类，表明子类是一种特殊的父类，并且具有父类所不具有的 一些属性或方法。定义一个继承的语法：修饰符 class 子类类名 extends 父类名{//类定义部分}，这就是一个继承的一个语法模式，记住关键字extends。

2.继承的特点

当父类子类没有同名变量时

class Daddy{//父类
    public int money = 1000000000;
    public int house = 5;
}
class Baby extends Daddy{//子类
    public int car = 1;
    public int girlfriend = 2;

    public void test(){
        System.out.println(car);
        System.out.println(girlfriend);
        System.out.println(money);
        System.out.println(house);
    }
}

public class Test2 {
    public static void main(String[] args) {
        Baby baby = new Baby();
        baby.test();
    }
}

我们访问子类变量时，也可以同时访问到子类变量从父类处继承来的变量，也即子类是一种带有自己变量的父类。

当子类父类有同名变量时

class Daddy{//父类
    public int money = 1000000000;
    public int house = 5;
    public int girlfriend = 10;
}
class Baby extends Daddy{//子类
    public int car = 1;
    public int girlfriend = 2;

    public void test(){
        System.out.println(car);
        System.out.println(girlfriend);
        System.out.println(money);
        System.out.println(house);
    }
}

public class Test2 {
    public static void main(String[] args) {
        Baby baby = new Baby();
        baby.test();
    }
}

在这段代码中，子类有girlfriend，父类也有girlfriend。子类继承的时候不会继承到父类的girlfriend。所以访问的时候，子类还是只有一个girlfriend。

 也就是说，当子类与父类有同名变量时，若访问子类变量，显示的是子类的变量。

那有的人会说，我就想通过子类访问父类的成员变量，那么只能使用super.成员变量来访问

 这时候访问到的就是父类的成员变量，那么你就可以知道父类有几个女朋友啦。

调用方法也是同理

static的方法中，不能有super，它们是水火不容的

3.super调用父类构造方法

当我们的子类继承了父类后，一旦想要构造子类的构造方法，就一定要在子类的构造方法中显示父类的构造方法，来初始化子类从父类继承过来的父类的构造方法，那么怎么用super调用父类的构造方法呢？

class Daddy{//父类
    public int money = 1000000000;
    public int house = 5;
    public int girlfriend = 10;

    public Daddy(int money,int house) {
        this.money = money;
        this.house = house;
    }
}
class Baby extends Daddy{//子类

    public int car = 1;
    public int girlfriend = 2;

    public Baby(int money,int house,int car){
        super(money, house);
        this.car = car;
    }

}

super代表调用父辈的方法，他必须放在子类构造方法的第一行才可以不报错。子类构造方法一定要确保先调用了父辈的构造方法，将父类继承下来的成员构造完整，然后再调用子类自己的构造方法。

super.data;访问父类的成员变量

super.func;访问父辈的成员方法

super();访问父辈的构造方法

4.super和this

相同点

 1.都是Java的关键字

 2.只能在类的非静态方法中使用，用来访问非静态的成员方法和字段

 3.在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

 不同点

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用

2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

3. this是非静态成员方法的一个隐藏参数，super不是隐藏的参数

4. 在构造方法中:this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造 方法中出现

5. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

 父类大于子类，静态大于实例，且静态只执行一次

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("静态代码块执行");
     }  
}
public class TestDemo {
     public static void main(String[] args) {
         Person person1 = new Person("bit",10);          
         System.out.println("============================");
         Person person2 = new Person("Clavin",20);
     } 
}

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age; System.out.println("Person:构造方法执行");
    }
    {
        System.out.println("Person:实例代码块执行");
    }
    static {
        System.out.println("Person:静态代码块执行");
    }
}
class Student extends Person{
    public Student(String name,int age) {
        super(name,age); System.out.println("Student:构造方法执行");
    }
    {
        System.out.println("Student:实例代码块执行");
    }
    static {
        System.out.println("Student:静态代码块执行");
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("张三", 19);
        System.out.println("===========================");
        Student student2 = new Student("Calvin", 20);
    }
}

 由此可知

1. 静态代码块先执行，并且只执行一次，在类加载阶段执行
2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

1、父类静态代码块优先于子类静态代码块执行，且是最早执行 

2、父类实例代码块和父类构造方法紧接着执行 

3、子类的实例代码块和子类构造方法紧接着再执行 

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

5.继承与组合 

如果一个类可以包含另外几个类，那么我们也可以将它们包含在一个组合中

class Student {

}
class Teacher {

}
class school {
    private Student[] student;
    private Teacher[] teachers;
}

往后的学习中，优先使用组合。