Java 继承

继承是面向对象编程(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();

这里,labradorDog 的一个对象。然而,nameeat()Animal 类的成员。

由于 Dog 继承了 Animal 的字段和方法,我们可以使用 Dog 的对象访问该字段和方法。

Subclass Dog can access the field and method of the superclass Animal.
Java 继承实现

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. 单继承

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

Class A inherits from class B.
Java 单继承

2. 多层继承

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

Class B inherits from class A and class C inherits from class B.
Java 多层继承

3. 层次继承

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

Both classes B and C inherit from the single class A.
Java 层次继承

4. 多重继承

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

Class C inherits from both classes A and B.
Java 多重继承

注意:Java 不支持多重继承。但是,我们可以通过接口实现多重继承。要了解更多信息,请访问 Java 实现多重继承


5. 混合继承

混合继承是两种或多种继承类型的组合。例如,

Class B and C inherit from a single class A and class D inherits from both the class B and C.
Java 混合继承

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

你觉得这篇文章有帮助吗?

我们的高级学习平台,凭借十多年的经验和数千条反馈创建。

以前所未有的方式学习和提高您的编程技能。

试用 Programiz PRO
  • 交互式课程
  • 证书
  • AI 帮助
  • 2000+ 挑战