Java 单继承|极客教程

Java 单继承

在面向对象编程中，继承是一种重要的概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。Java 是一种面向对象的编程语言，采用了单继承的机制，即一个类只能继承一个直接父类。这么设计的目的是为了简化语言的复杂性，避免出现多重继承带来的问题。

单继承的优点

1. 简化继承结构

单继承可以避免类之间过于复杂的继承结构，每个类只有一个直接父类，使得类之间的关系更加清晰明了。这也符合面向对象编程中的“单一职责原则”，即一个类只应该有一个变化的原因。

2. 避免冲突

如果允许多重继承，当多个父类中有同名的属性或方法时，子类继承后会出现冲突，需要进行复杂的解决方案。单继承可以避免这种情况的发生，保持程序的一致性和稳定性。

3. 提高代码的可读性和维护性

单继承使得代码的继承关系更加清晰和简单，方便他人阅读和理解代码。在维护时也更容易定位问题和进行修改。

单继承的实现

在 Java 中，使用 extends 关键字来实现单继承。一个子类只能继承一个父类，并且 Java 中所有的类都继承自 Object 类。

// 定义一个父类
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 定义一个子类，继承自 Animal 类
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

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

上面的示例中，Dog 类继承自 Animal 类，可以调用 Animal 类中的 eat 方法。在 Main 类中创建了一个 Dog 对象，并调用了 eat 和 bark 方法。

运行结果为：

Animal is eating
Dog is barking

多层继承

虽然 Java 中只允许单继承，但是可以通过多层继承的方式实现多个类之间的关联。即一个类可以继承另一个类的子类。

// 定义一个父类
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 定义一个子类，继承自 Animal 类
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

// 定义一个子类，继承自 Dog 类
class Labrador extends Dog {
    void play() {
        System.out.println("Labrador is playing fetch");
    }
}

public class Main {
    public static void main(String[] args) {
        Labrador labrador = new Labrador();
        labrador.eat();
        labrador.bark();
        labrador.play();
    }
}

在上面的示例中，Labrador 类继承自 Dog 类，而 Dog 类又继承自 Animal 类。Labrador 类就可以继承 Dog 和 Animal 类中的方法。

运行结果为：

Animal is eating
Dog is barking
Labrador is playing fetch

抽象类

在实际开发中，有时候我们希望某些类只作为父类使用，不希望被实例化，这时可以使用抽象类。抽象类使用 abstract 关键字进行定义，其中可以包含抽象方法，抽象方法没有方法体，需要子类进行实现。

// 定义一个抽象类
abstract class Shape {
    abstract void draw();
}

// 定义一个子类，继承自抽象类
class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw();
    }
}

在上面的示例中，Shape 类是一个抽象类，其中包含一个抽象方法 draw。Circle 类继承自 Shape 类，并实现了 draw 方法。

运行结果为：

Drawing a circle

使用抽象类可以约束子类必顡实现某些方法，提高了程序的健壮性和可维护性。

接口

除了使用抽象类，Java 中还可以使用接口来实现类之间的关联。接口是一种抽象数据类型，其中只包含常量和抽象方法的定义，不包含方法的实现。一个类可以实现多个接口，实现接口中定义的方法。

// 定义一个接口
interface Flyable {
    void fly();
}

// 定义一个接口
interface Swimmable {
    void swim();
}

// 定义一个类，实现多个接口
class Duck implements Flyable, Swimmable {
    public void fly() {
        System.out.println("Duck is flying");
    }

    public void swim() {
        System.out.println("Duck is swimming");
    }
}

public class Main {
    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

在上面的示例中，Flyable 和 Swimmable 是两个接口，Duck 类实现了这两个接口，并实现了 fly 和 swim 方法。

运行结果为：