Java的面向对象 -- 继承_2.定义person 类及其子类teacher 。 abstract class person { -CSDN博客

本文链接：https://blog.csdn.net/cd_sywe/article/details/103005144

在前面的章节中，我们已经定义了 Person类 ：

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

现在，假设需要定义一个 Student类 ，字段如下：

class Student {
    private String name;
    private int age;
    private int score;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
    public int getScore() { … }
    public void setScore(int score) { … }
}

仔细观察，发现 Student类 包含了 Person类 已有的字段和方法，只是多出了一个 score字段 和相应的 getScore()、setScore() 方法。

能不能在 Student类 中不要写重复的代码？

这个时候，继承 就派上用场了。

继承 是面向对象编程中非常强大的一种机制，它首先可以复用代码。当我们让 Student 从 Person 继承时，Student 就获得了 Person 的所有功能，我们只需要为 Student 编写新增的功能。

Java使用 extends 关键字来实现继承：

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}

可见，通过继承， Student 只需要编写额外的功能，不再需要重复代码。

在OOP的术语中，我们把 Person 称为 超类（super class），父类（parent class），基类（base class），把 Student 称为 子类（subclass），扩展类（extended class）。

继承树

注意到我们在定义 Person 的时候，没有写 extends 。在Java中，没有明确写 extends 的类，编译器会自动加上 extends Object 。所以，任何类，除了 Object ，都会继承自某个类。下图是 Person、Student 的继承树：
在这里插入图片描述
Java只允许一个 class 继承自一个类，因此，一个类有且仅有一个父类。只有 Object 特殊，它没有父类。

类似的，如果我们定义一个继承自 Person 的 Teacher ，它们的继承树关系如下：
在这里插入图片描述

protected修饰符

继承有个特点，就是子类无法访问父类的 private字段 或者 private方法 。例如，Student类 就无法访问 Person类 的 name 和 age 字段：

class Person {
    private String name;
    private int age;
}

class Student extends Person {
    public String hello() {
        return "Hello, " + name; 	// 编译错误：无法访问name字段
    }
}

这使得继承的作用被削弱了。为了让子类可以访问父类的字段，我们需要把 private 改为 protected 。用 protected 修饰的字段可以被子类访问：

class Person {
    protected String name;
    protected int age;
}

class Student extends Person {
    public String hello() {
        return "Hello, " + name; // OK!
    }
}

因此，protected 关键字可以把字段和方法的访问权限控制在继承树内部，一个 protected 字段和方法可以被其子类，以及子类的子类所访问，后面我们还会详细讲解。

super关键字

super 关键字表示父类（超类）。子类引用父类的字段时，可以用 super.fieldName 。例如：

class Student extends Person {
    public String hello() {
        return "Hello, " + super.name;
    }
}

实际上，这里使用 super.name ，或者 this.name ，或者 name ，效果都是一样的。编译器会自动定位到父类的 name 字段。

但是，在某些时候，就必须使用 super 。我们来看一个例子：

public class Main {
    public static void main(String[] args) {
        Student s = new Student("Xiao Ming", 12, 89);
    }
}

class Person {
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        this.score = score;
    }
}

运行上面的代码，会得到一个编译错误，大意是在 Student 的构造方法中，无法调用 Person 的构造方法。

这是因为在Java中，任何 class 的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句 super(); ，所以，Student 类的构造方法实际上是这样：

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(); 			// 自动调用父类的构造方法
        this.score = score;
    }
}

但是，Person 类并没有无参数的构造方法，因此，编译失败。

解决方法是调用 Person 类存在的某个构造方法。例如：

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(name, age); 		// 调用父类的构造方法Person(String, int)
        this.score = score;
    }
}