跳到主要内容

Java继承

介绍​

继承是面向对象编程（OOP）中的一个核心概念，它允许一个类（子类）基于另一个类（父类）来构建。通过继承，子类可以复用父类的属性和方法，同时还可以扩展或修改这些功能。继承的主要目的是实现代码复用和层次化设计。

在Java中，继承是通过关键字 extends 来实现的。子类继承父类的所有非私有成员（属性和方法），并且可以添加新的成员或重写父类的方法。

基本语法​

在Java中，继承的基本语法如下：

class ParentClass {
    // 父类的属性和方法
}

class ChildClass extends ParentClass {
    // 子类的属性和方法
}

示例​

让我们通过一个简单的例子来理解继承的概念：

// 父类
class Animal {
    String name;

    void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.eat();  // 继承自父类的方法
        myDog.bark(); // 子类特有的方法
    }
}

输出：

Buddy is eating.
Buddy is barking.

在这个例子中，Dog 类继承了 Animal 类的 name 属性和 eat() 方法。同时，Dog 类还定义了自己的 bark() 方法。

继承的类型​

Java支持以下几种类型的继承：

  1. 单继承：一个子类只能继承一个父类。Java不支持多继承，但可以通过接口实现类似的功能。
  2. 多级继承：一个子类可以继承另一个子类，形成继承链。
  3. 层次继承：多个子类可以继承同一个父类。

多级继承示例​

class Animal {
    void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking.");
    }
}

class Puppy extends Dog {
    void weep() {
        System.out.println("Puppy is weeping.");
    }
}

public class Main {
    public static void main(String[] args) {
        Puppy myPuppy = new Puppy();
        myPuppy.eat();  // 继承自Animal类
        myPuppy.bark(); // 继承自Dog类
        myPuppy.weep(); // Puppy类特有的方法
    }
}

输出：

Animal is eating.
Dog is barking.
Puppy is weeping.

方法重写​

子类可以重写（Override）父类的方法，以提供不同的实现。方法重写要求子类的方法签名（方法名、参数列表）与父类的方法完全一致。

方法重写示例​

class Animal {
    void makeSound() {
        System.out.println("Animal is making a sound.");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound(); // 调用的是Dog类重写的方法
    }
}

输出：

Dog is barking.
备注

方法重写与方法重载（Overload）不同。方法重载是指在同一个类中定义多个同名方法，但参数列表不同。

super 关键字​

super 关键字用于在子类中引用父类的成员（属性和方法）。它可以用于调用父类的构造方法、访问父类的属性或调用父类的方法。

使用 super 调用父类构造方法​

class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    void eat() {
        System.out.println(name + " is eating.");
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // 调用父类的构造方法
    }

    void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        myDog.eat();
        myDog.bark();
    }
}

输出：

Buddy is eating.
Buddy is barking.

实际应用场景​

继承在实际开发中有广泛的应用。例如，在图形用户界面（GUI）开发中，所有的UI组件（如按钮、文本框等）都可以继承自一个通用的 Component 类。这样，每个组件都可以复用 Component 类的通用功能，同时还可以扩展自己的特定功能。

示例：GUI组件继承​

class Component {
    int x, y;

    void draw() {
        System.out.println("Drawing component at (" + x + ", " + y + ")");
    }
}

class Button extends Component {
    String label;

    Button(int x, int y, String label) {
        this.x = x;
        this.y = y;
        this.label = label;
    }

    void draw() {
        super.draw(); // 调用父类的draw方法
        System.out.println("Drawing button with label: " + label);
    }
}

public class Main {
    public static void main(String[] args) {
        Button myButton = new Button(10, 20, "Submit");
        myButton.draw();
    }
}

输出：

Drawing component at (10, 20)
Drawing button with label: Submit

总结​

继承是Java面向对象编程中的一个重要概念，它允许子类复用父类的代码，并且可以通过方法重写和扩展来实现更复杂的功能。通过继承，我们可以构建层次化的类结构，使代码更加模块化和易于维护。

提示

在实际开发中，合理使用继承可以大大提高代码的复用性和可维护性。但也要注意避免过度使用继承，以免导致类层次结构过于复杂。

附加资源与练习​

  • 练习1：创建一个 Vehicle 类，包含 speed 属性和 move() 方法。然后创建一个 Car 类继承 Vehicle 类，并添加 brand 属性和 honk() 方法。
  • 练习2：尝试在多级继承中重写父类的方法，并观察输出结果。

通过以上练习，你可以更好地理解和掌握Java中的继承机制。