Java 中的继承

2025年3月30日 | 阅读 9 分钟

Java 中的继承是一种机制，其中一个对象获取父对象的全部属性和行为。它是 OOPs（面向对象编程系统）的重要组成部分。

Java 继承的理念是，我们可以创建基于现有类的新类。当我们继承现有类的方法时，我们可以重用父类的方法和字段。但是，我们也可以在当前类中添加新方法和字段。

什么是继承？

Java 中的继承使一个类能够继承另一个类（称为超类或父类）的属性和操作。从超类派生的类称为子类或子组。通过继承，子类可以访问其超类的成员（字段和方法），强制执行重用规则，并鼓励层次结构。

继承代表 IS-A 关系，也称为父子关系。

为什么要使用继承？

为了方法重写（以便实现运行时多态）。
为了代码重用。

继承中使用的术语

类：类是具有共同属性的对象集合。它是创建对象的模板或蓝图。
子类/派生类：子类是继承其他类的类。它也称为派生类、扩展类或子类。
超类/父类：超类是子类从中继承特性的类。它也称为基类或父类。
重用性：顾名思义，重用性是一种机制，它可以在创建新类时促进重用现有类的字段和方法。您可以使用先前类中已定义的相同字段和方法。

Java 继承的语法

class Subclass-name extends Superclass-name
{
   //methods and fields
}

extends 关键字表示我们正在创建一个从现有类派生的新类。 "extends" 的意思是增加功能。

在 Java 的术语中，被继承的类称为父类或超类，新类称为子类或派生类。

Java 继承示例

如上图所示，Programmer 是子类，Employee 是超类。这两个类之间的关系是 **Programmer IS-A Employee**。这意味着 Programmer 是一种 Employee。

示例

class Employee{
 float salary=40000;
}
class Programmer extends Employee{
 int bonus=10000;
}
public class Main{
 public static void main(String args[]){
   Programmer p=new Programmer();
   System.out.println("Programmer salary is:"+p.salary);
   System.out.println("Bonus of Programmer is:"+p.bonus);
}
}

编译并运行

输出

 Programmer salary is:40000.0
 Bonus of programmer is:10000

在上面的示例中，Programmer 对象可以访问其自身类以及 Employee 类的字段，即代码重用。

Types of Inheritance in Java

基于类的继承，Java 中有三种类型：单继承、多级继承和层次继承。

在 Java 编程中，多重继承和混合继承仅通过接口支持。我们将在稍后学习接口。

阅读更多：Java 中的接口

注意：Java 中不支持通过类进行多重继承。

单继承

当一个类继承另一个类时，称为单继承。在下面的示例中，Dog 类继承了 Animal 类，因此存在单继承。

阅读更多：Java 中的单继承

示例

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
public class Main{
public static void main(String args[]){
Dog d=new Dog();
d.bark();
d.eat();
}}

编译并运行

输出

barking...
eating...

多层继承

当存在继承链时，称为多级继承。正如您在下面的示例中看到的，BabyDog 类继承了 Dog 类，Dog 类又继承了 Animal 类，因此存在多级继承。

阅读更多：Java 中的多级继承

示例

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class BabyDog extends Dog{
void weep(){System.out.println("weeping...");}
}
public class Main{
public static void main(String args[]){
BabyDog d=new BabyDog();
d.weep();
d.bark();
d.eat();
}}

编译并运行

输出

weeping...
barking...
eating...

层次继承

当两个或多个类继承一个类时，称为层次继承。在下面的示例中，Dog 和 Cat 类继承了 Animal 类，因此存在层次继承。

阅读更多：Java 中的层次继承

示例

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class Cat extends Animal{
void meow(){System.out.println("meowing...");}
}
public class Main{
public static void main(String args[]){
Cat c=new Cat();
c.meow();
c.eat();
//c.bark();//C.T.Error
}}

编译并运行

输出

meowing...
eating...

多重继承

多重继承一个类从多个类继承特性的能力称为多重继承。当一个类需要来自多个来源的特性时，这种概念可能非常有用。

然而，多重继承可能导致诸如菱形问题之类的冲突，当两个超类共享相同的方法或字段并导致冲突时，就会发生菱形问题。Java 使用接口来实现多重继承，以避免这些冲突。

阅读更多 Java 中的多重继承

示例

interface Character {  
    void attack();  
}  
interface Weapon {  
    void use();  
}  
class Warrior implements Character, Weapon {  
    public void attack() {  
        System.out.println("Warrior attacks with a sword.");  
    }  
    public void use() {  
        System.out.println("Warrior uses a sword.");  
    }  
}  
class Mage implements Character, Weapon {  
    public void attack() {  
        System.out.println("Mage attacks with a wand.");  
    }  
    public void use() {  
        System.out.println("Mage uses a wand.");  
    }  
}  
public class Main {  
    public static void main(String[] args) {  
        Warrior warrior = new Warrior();  
        Mage mage = new Mage();  
        warrior.attack(); // Output: Warrior attacks with a sword.  
        warrior.use(); // Output: Warrior uses a sword.  
        mage.attack(); // Output: Mage attacks with a wand.  
        mage.use(); // Output: Mage uses a wand.  
    }  
}  

编译并运行

输出

Warrior attacks with a sword.
Warrior uses a sword.
Mage attacks with a wand.
Mage uses a wand.

Java 中的混合继承

混合继承是两种或多种继承类型的组合。使用混合继承的主要目的是将代码模块化为定义良好的类。它还提供了代码重用性。

混合继承可以通过以下组合来实现

单继承和多重继承（不支持，但可以通过接口实现）
多级继承和层次继承
层次继承和单继承
多重继承和多级继承

阅读更多 Java 中的混合继承

示例

class C  
{  
public void disp()  
{  
System.out.println("C");  
}  
}  
class A extends C  
{  
public void disp()  
{  
System.out.println("A");  
}  
}  
class B extends C  
{  
public void disp()  
{  
System.out.println("B");  
}     
}  
public class D extends A  
{  
public void disp()  
{  
System.out.println("D");  
}  
public static void main(String args[])  
{  
D obj = new D();  
obj.disp();  
}  
}  

输出

问）为什么 Java 不支持多重继承？

为了降低复杂性并简化语言，Java 不支持多重继承。

假设有三个类 A、B 和 C。C 类继承了 A 和 B 类。如果 A 和 B 类有相同的方法，并且我们从子类对象调用它，那么调用 A 或 B 类的方法将存在歧义。这被称为菱形问题。

阅读更多 Java 中的菱形问题

由于编译时错误优于运行时错误，如果您继承 2 个类，Java 会引发编译时错误。因此，无论您是否有相同的方法还是不同方法，都会出现编译时错误。

class A {  
void msg(){System.out.println("Hello");}  
}  
class B {  
void msg(){System.out.println("Welcome");}  
}  
public class Main extends A,B { 
 public static void main(String args[]){  
   Main obj = new Main();
   obj.msg();//Now which msg() method would be invoked?  
}  
}  

输出

 Compile Time Error

如何在 Java 中实现多重继承？

Java 仅通过接口支持多重继承，其中一个类可以实现多个接口。Java 中的多重继承不可能通过类实现，但可以通过接口实现。

阅读更多多重继承。

注意：我们将在稍后学习接口。

继承的优点

继承提供了几个优点，包括

代码重用性：子类可以重用超类中继承的成员，减少冗余代码并促进软件开发的模块化方法。

层次化组织：继承有助于创建结构良好的类层次结构，提高代码的可读性和可维护性。

多态性：子类可以重写超类方法，允许多态行为，即方法可以根据运行时对象的类型表现出不同的行为。

易于维护：对超类所做的更改会自动传播到其子类，确保一致性并简化维护工作。

使用继承的最佳实践

虽然继承是一个强大的工具，但滥用它可能导致代码复杂化和紧耦合。以下是一些需要考虑的最佳实践：

优先组合而非继承：尽可能优先使用组合，即类由其他类组成，而非继承。这种方法通常会产生更灵活、更易于维护的代码。

遵循 "is-a" 关系：确保继承关系遵循 "is-a" 原则，即子类代表其超类的更专业化版本。

明智地使用抽象类和接口：抽象类和接口为子类提供了蓝图。当您想提供默认实现或在相关子类之间共享代码时，请使用抽象类。使用接口定义类可以实现的契约，从而通过接口实现多重继承。

避免深继承层次结构：深继承层次结构可能导致代码难以理解和维护。尽可能使用浅层次结构。

优先使用组合进行代码重用：不要仅依靠继承来进行代码重用，可以考虑将组合与继承结合使用，以获得更好的灵活性和模块化。

结论

Java 中的继承是创建规则集和在面向对象程序中重用规则的强大工具。通过理解其语法、类型、效用和最佳实践，开发人员可以有效地使用继承来创建可维护、可扩展且可扩展的 Java 应用程序。

Java 继承选择题

1. 以下代码的输出将是什么？

 
 class A {
    int i = 10;
    public void display() {
        System.out.println("Class A: " + i);
    }
}
class B extends A {
    int i = 20;
    public void display() {
        super.display();
        System.out.println("Class B: " + i);
    }
}
public class Test {
    public static void main(String[] args) {
        B obj = new B();
        obj.display();
    }
} 

类 A：10 类 B：20
类 A：20 类 B：20
类 A：10 类 B：10
编译错误

答案：a)

解释： super.display() 调用类 A 中的 display 方法，该方法打印类 A 中的 i。然后类 B 中的 display 方法打印其自身的 i。

2. 关于 Java 中的多重继承，以下哪个陈述是正确的？

Java 通过类支持多重继承。
Java 通过接口支持多重继承。
Java 通过类和接口都支持多重继承。
Java 不支持多重继承。

答案：b)

解释： Java 不通过类支持多重继承以避免歧义，但通过接口支持。

3. 关于 Java 中的方法隐藏，以下哪个是正确的？

静态方法可以被重写。
静态方法可以隐藏实例方法。
静态方法可以隐藏其他静态方法。
实例方法可以隐藏静态方法。

答案：c)

解释： 静态方法不能被重写，但可以隐藏超类中的其他静态方法。

4. 涉及方法重写和隐藏的以下代码段的输出是什么？

 
class A {
    public static void display() {
        System.out.println("Static method in A");
    }
    public void show() {
        System.out.println("Instance method in A");
    }
}
class B extends A {
    public static void display() {
        System.out.println("Static method in B");
    }
    @Override
    public void show() {
        System.out.println("Instance method in B");
    }
}
public class Test {
    public static void main(String[] args) {
        A a = new B();
        a.display();
        a.show();
    }
}   

A 中的静态方法，A 中的实例方法
A 中的静态方法，A 中的实例方法
A 中的静态方法，B 中的实例方法
B 中的静态方法，B 中的实例方法

答案：c)

解释： 静态方法不被重写但被隐藏，因此 a.display() 调用 A 的静态方法。show 方法被重写，因此 a.show() 调用 B 的实例方法。

5. Java 中的抽象类和接口之间的主要区别是什么？

抽象类可以有构造函数，而接口不能。
接口可以有默认方法，而抽象类不能。
抽象类可以有实例变量，而接口不能。
接口可以有静态方法，而抽象类不能。

答案：c)

解释： Java 中的抽象类可以有实例变量、构造函数以及抽象方法和具体方法。而接口只能声明常量和抽象方法。它们不能有实例变量、构造函数或具体方法。

下一个主题Java 中的聚合 (HAS-A)

← 上一个下一个 →

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java 教程

控制语句

Java Object 类

Java 继承

Java 多态

Java 抽象

Java 封装

Java 数组

Java OOPs 杂项

Java 字符串

Java 正则表达式

异常处理

Java 内部类

Java 多线程

Java 同步

Java I/O

Java 文件处理

Java 序列化

Java 网络

Java 反射

Java 集合

Java 5 特性

Java 8 特性

Java JDBC

RMI

国际化

Java 项目

Java 中的继承

什么是继承？

为什么要使用继承？

继承中使用的术语

Java 继承的语法

Java 继承示例

示例

Types of Inheritance in Java

注意：Java 中不支持通过类进行多重继承。

单继承

示例

多层继承

示例

层次继承

示例

多重继承

示例

Java 中的混合继承

示例

问）为什么 Java 不支持多重继承？

如何在 Java 中实现多重继承？

注意：我们将在稍后学习接口。

继承的优点

使用继承的最佳实践

结论

Java 继承选择题

相关帖子

Java 中的聚合

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题