在前面的章节中,我们已经定义了 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;
}
}
这样就可以正常编译了!
因此我们得出结论:如果父类没有默认的构造方法,子类就必须显式调用 super()
并给出参数以便让编译器定位到父类的一个合适的构造方法。
这里还顺带引出了另一个问题:即 子类不会继承任何父类的构造方法 。子类默认的构造方法是编译器自动生成的,不是继承的。