1. 继承的直观理解

⭐️继承可以这样理解：

• 首先将一些变量和方法打包在一个类中当作一个工具。
• 其他类可以通关继承来获得这个工具的所有成员变量和属性。
  （其中当作工具的类被称为父类，而这里的“其他类”是子类）

现将先将属性 age和name 与方法getAge() 和 getName包装成一个父类（Animal）如下：

而现在就可以这样写Monkey和Fish两个类：

最终可以达到以下的效果：

2. 继承的实现——extends关键字

在Java中要实现类的继承关系需要用到extends关键字

🍑基本格式：

public class Son extends Father{
    
}
1
2
3

其中的Son类是子类，Father类是父类.
以上面的Fish类和Animal类的继承关系实现如下：

public class Animal {
	//父类
    private int age;
    int name;

    public int getAge() {
        return age;
    }

    public int getName() {
        return name;
    }
}

public class Fish extends Animal{
    //子类 
    private String gander;

    public String getGander() {
        return gander;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Java继承只能继承一个父类，但看可以继承父类继承的父类变相的达到多继承的效果。

3. 访问父类成员

3.1 访问成员变量

子类可以访问继承自父类的成员变量和方法,下面展开介绍：

• 访问父类非private修饰的成员变量
  子类是可以直接访问。如：super.name
• 访问父类private修饰的成员变量
  子类可以使用从父类继承的对应get方法来访问。

🍌例子：

public class Dog extends Animal{

    public dog(int age, String name) {
        super(age, name);
    }
    {
        System.out.println(name);
        //访问父类非private修饰的变量
        System.out.println(this.getAge());
        //访问父类中杯private修饰的变量
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

注：在Animal类（代码在第一个例子中）中name是default修饰的，age是private修饰的。

• 当子类的成员变量和父类相同时优先访问子类的成员变量

public class Fish extends Animal{
    private String gander;

    String name="子类中的名字";

    public String getGander() {

        return gander;
    }

    public static void main(String[] args) {
        Fish f=new Fish();
        System.out.println(f.name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果：

• 调用父类的方法
  子类可以直接调用继承自父类方法。
• 当子类重写父类的方法后会优先调用子类重写的方法

🍊例子：

public class Fish extends Animal{
    private String gander;

    String name="子类中的名字";

    
    public String getGander() {
        return gander;
    }
    @Override
    public String getName(){
        return "子类重写的方法";
    }

    public static void main(String[] args) {
        Fish f=new Fish();
        System.out.println(f.getName());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

结果展示：

• 通过super关键字在子类重写父类方法后调用父类方法

public class Fish extends Animal{
    private String gander;

    String name="子类中的名字";
    {
        super.name="用super关键字修改后的名字";
        System.out.println(super.name);
    }

    public String getGander() {
        return gander;
    }
    @Override
    public String getName(){
        return "子类重写的方法";
    }

    public static void main(String[] args) {
        Fish f=new Fish();

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果展示：

⭐️总结:
调用时会优先调用子类的方法和属性，如果在子类中没有找到则会从父类中进行查找，若父类也没有则会报错，当然也空一通过super关键字直接访问父类的成员。

4. 子类构造方法

子类的构造方法会调用父类的构造方法，借组super关键字可以访问父类的构造方法。
⭐️super要放到第一行。

• 如果父类存在不含参数的构造方法时子类的构造方法第一行会默认有一行代码super()。

public class Animal {
//父类
    private int age=0;
    String name="父类名字";
    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}
public class Fish extends Animal{
    private String gender;
    String name="子类中的名字";

    public String getGender() {
        return gender;
    }
    @Override
    public String getName(){
        return "子类重写的方法";
    }
    //构造方法
    public Fish(String gender){
    // super();
        this.gender=gender;
    }

    public static void main(String[] args) {
        Fish f=new Fish("雄");
        System.out.println(f.getGender());
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

• 父类的构造方法有参数
  子类的构造方法第一行需要加入super（）方法，里面填上父类的构造方法需要的参数。
  例子
  Animal类构造方法：

 public Animal(int age,String name){
        this.age=age;
        this.name=name;
    }
1
2
3
4

Fish类构造方法：

 public Animal(int age,String name){
        this.age=age;
        this.name=name;
    }
1
2
3
4