一、前言

本文将介绍面向对象三大特征之一的继承

二、概述

就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

继承可以让类和类之间产生父子关系。要注意的是两个类之间一定要有共同内容或者共性内容，且是父类的一种（如老师和学生都归属于人这个大类）

三、格式

public class 子类 extends 父类{...}

public class Cat extends Animal{
	...
}
1
2
3

四、方法的重写

1.概述

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。当父类的方法不能满足子类现在的需求时，需要进行方法的重写

2.本质

3.书写格式

• @Override：放在重写后的方法上面，以校验子类重写时语法正确性

public class Animal  {
    public void run(){
        System.out.println("动物跑的很快！");
    }
    public void cry(){
        System.out.println("动物都可以叫");
    }
}
1
2
3
4
5
6
7
8

public class Cat extends Animal {
     // 声明不变，重新实现
    // 方法名称与父类全部一样，只是方法体中的功能重写写了！
    @Override
    public void behaviour(){
        System.out.println("会发出呜呜声");
    }
}
1
2
3
4
5
6
7
8

4.注意事项

1. 方法重写是发生在子父类之间的关系
2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限
3. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样
4. 子类重写父类方法时，返回值类型必须小于等于父类
5. 只有被添加到虚方法表中的方法才能被重写

五、构造方法

1.调用父类构造方法

super()：写在第一行，有参构造时一定要手动添加

2.代码演示

class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("父类无参");
    }

    // getter/setter省略
}

class Student extends Person {
    private double score;

    public Student() {
        //super(); // 调用父类无参,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }
    
     public Student(double score) {
        //super();  // 调用父类无参,默认就存在，可以不写，必须再第一行
        this.score = score;    
        System.out.println("子类有参");
     }

}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println("----------");
        Student s2 = new Student(99.9);
    }
}
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

父类无参
子类无参
················
父类无参
子类有参

六、继承中的特点

1.继承后子类特点

• 子类可以使用父类的属性和行为
• 子类可以在父类基础上增加新功能，使得子类更强大

2.继承中成员变量的访问特点

• 就近原则
• 逐级往上：先从局部变量中找，如果找不到就到本类成员位置上寻找，如果还没有就在父类成员位置中寻找

用IDEA来测试一下

public class test1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.ziShow();
    }
}

class Fu{
    String name = "Fu";
}

class Zi extends Fu{
    String name = "Zi";
    public void ziShow(){
        String name = "ziShow";
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

原理如下

3.继承中成员方法的访问特点

• this 调用：就近原则
• super调用：找父类

用IDEA实现一下

public class Test {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.lunch();
    }
}

class Person{
    public void eat(){
        System.out.println("吃饭");
    }
}

class Teacher extends Person{

    public void lunch() {
        this.eat();
        super.eat();
    }

    public void eat(){
        System.out.println("吃面条");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

其原理如下

4.继承中构造方法的特点

• 子类无法继承父类的构造方法，但是可以通过super()调用
• 子类中所以构造方法默认先访问父类中无参构造，再执行自己
• 若想父类是有参构造，要手动书写super()

七、结语

继承中的知识点较多，并且还有方法的重写相关知识点，若有写的不足之处，请多多指正，接下来会讲述继承内关键字