继承是面向对象编程(OOP)的关键特性之一,它允许我们从现有类创建一个新类。
创建的新类称为子类(child or derived class),而从中派生子类的现有类称为超类(parent or base class)。
extends
关键字用于在 Java 中执行继承。例如,
class Animal {
// methods and fields
}
// use of extends keyword
// to perform inheritance
class Dog extends Animal {
// methods and fields of Animal
// methods and fields of Dog
}
在上面的示例中,Dog 类是通过继承 Animal 类的方法和字段来创建的。
这里,Dog 是子类,Animal 是超类。
示例 1:Java 继承
class Animal {
// field and method of the parent class
String name;
public void eat() {
System.out.println("I can eat");
}
}
// inherit from Animal
class Dog extends Animal {
// new method in subclass
public void display() {
System.out.println("My name is " + name);
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// access field of superclass
labrador.name = "Rohu";
labrador.display();
// call method of superclass
// using object of subclass
labrador.eat();
}
}
输出
My name is Rohu I can eat
在上面的示例中,我们从超类 Animal 派生了一个子类 Dog。请注意这些语句,
labrador.name = "Rohu";
labrador.eat();
这里,labrador 是 Dog 的一个对象。然而,name 和 eat()
是 Animal 类的成员。
由于 Dog 继承了 Animal 的字段和方法,我们可以使用 Dog 的对象访问该字段和方法。

is-a 关系
在 Java 中,继承是一种“is-a”关系。也就是说,我们仅在两个类之间存在“is-a”关系时才使用继承。例如,
- **汽车**是**交通工具**
- 橙子是一种水果
- 外科医生是一名医生
- 狗是一种动物
这里,汽车可以继承自车辆,橙子可以继承自水果,等等。
Java 继承中的方法重写
在示例 1 中,我们看到子类对象可以访问超类的方法。
然而,如果同一个方法同时存在于超类和子类中,会发生什么?
在这种情况下,子类中的方法会覆盖(重写)超类中的方法。这个概念在 Java 中称为方法重写。
示例 2:Java 继承中的方法重写
class Animal {
// method in the superclass
public void eat() {
System.out.println("I can eat");
}
}
// Dog inherits Animal
class Dog extends Animal {
// overriding the eat() method
@Override
public void eat() {
System.out.println("I eat dog food");
}
// new method in subclass
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// call the eat() method
labrador.eat();
labrador.bark();
}
}
输出
I eat dog food I can bark
在上面的示例中,eat()
方法同时存在于超类 Animal 和子类 Dog 中。
这里,我们创建了一个 Dog 的对象 labrador。
现在,当我们使用 labrador 对象调用 eat()
时,调用的是 Dog 中的方法。这是因为派生类中的方法会覆盖基类中的方法。
这称为方法重写。要了解更多信息,请访问 Java 方法重写。
注意:我们使用了 @Override
注解来告诉编译器我们正在重写一个方法。但是,该注解不是强制性的。要了解更多信息,请访问 Java 注解。
Java 继承中的 super 关键字
之前我们看到,子类中的相同方法会覆盖超类中的方法。
在这种情况下,super
关键字用于从子类方法调用父类方法。
示例 3:继承中的 super 关键字
class Animal {
// method in the superclass
public void eat() {
System.out.println("I can eat");
}
}
// Dog inherits Animal
class Dog extends Animal {
// overriding the eat() method
@Override
public void eat() {
// call method of superclass
super.eat();
System.out.println("I eat dog food");
}
// new method in subclass
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// call the eat() method
labrador.eat();
labrador.bark();
}
}
输出
I can eat I eat dog food I can bark
在上面的示例中,eat()
方法同时存在于基类 Animal 和派生类 Dog 中。请注意该语句,
super.eat();
这里,super
关键字用于调用超类中存在的 eat()
方法。
我们还可以使用 super
关键字从子类的构造函数调用超类的构造函数。要了解更多信息,请访问 Java super 关键字。
继承中的 protected 成员
在 Java 中,如果一个类包含 protected
字段和方法,那么这些字段和方法可以从该类的子类访问。
示例 4:继承中的 protected 成员
class Animal {
protected String name;
protected void display() {
System.out.println("I am an animal.");
}
}
class Dog extends Animal {
public void getInfo() {
System.out.println("My name is " + name);
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// access protected field and method
// using the object of subclass
labrador.name = "Rocky";
labrador.display();
labrador.getInfo();
}
}
输出
I am an animal. My name is Rocky
在上面的示例中,我们创建了一个名为 Animal 的类。该类包含一个 protected 字段:name 和一个方法:display()
。
我们继承了 Dog 类继承 Animal。请注意该语句,
labrador.name = "Rocky";
labrador.display();
这里,我们能够使用子类 labrador 对象访问超类的 protected 字段和方法。
为什么使用继承?
- Java 中继承最重要的用途是代码重用。父类中存在的代码可以被子类直接使用。
- 方法重写也称为运行时多态。因此,我们可以借助继承在 Java 中实现多态。
继承的类型
有五种类型的继承。
1. 单继承
在单继承中,单个子类扩展自单个超类。例如,

2. 多层继承
在多层继承中,子类扩展自超类,然后该子类本身又充当另一个类的超类。例如,

3. 层次继承
在层次继承中,多个子类扩展自单个超类。例如,

4. 多重继承
在多重继承中,单个子类扩展自多个超类。例如,

注意:Java 不支持多重继承。但是,我们可以通过接口实现多重继承。要了解更多信息,请访问 Java 实现多重继承。
5. 混合继承
混合继承是两种或多种继承类型的组合。例如,

这里,我们结合了层次继承和多重继承来形成混合继承。