抽象类（Abstract Class）与接口（Interface）的详细对比与选择原则

抽象类与接口：一场“鱼与熊掌”的抉择

各位看官，大家好！我是你们的老朋友——码农老王。今天咱们来聊一个在编程世界里经常被拿出来“鞭尸”的话题：抽象类和接口。这俩兄弟，哦不，这俩概念，长得像，用起来也像，经常让新手（甚至老鸟）傻傻分不清楚，搞得代码像一锅乱炖。

别担心，今天老王就用最通俗易懂的语言，把它们俩扒个精光，让大家以后再也不用为选哪个而挠头了。准备好瓜子花生，咱们开始咯！

第一回合：身世背景大揭秘

要理解抽象类和接口，首先得搞清楚它们的身世。就像了解一个人一样，知根知底才能更好地相处嘛。

抽象类（Abstract Class）：

你可以把抽象类想象成一个“半成品”。它是类，没错，拥有类的所有特性，比如成员变量、方法等等。但是，它又有点“残缺”，因为它不能被直接实例化（就是不能 new 一个对象出来）。它的使命是作为其他类的“蓝图”，让其他类继承它，并实现它未完成的部分。

抽象类里可以包含抽象方法（用 abstract 关键字修饰）和非抽象方法。抽象方法就像“占位符”，告诉子类：“嘿，哥们，这个方法你必须给我实现！” 而非抽象方法则可以提供一些通用的实现，让子类直接使用，省得重复造轮子。
接口（Interface）：

接口就更“纯粹”了。它完全是一个“规范”，一个“协议”。接口里只能包含抽象方法（在 Java 8 之前），或者静态常量。注意，这里说的抽象方法是指没有方法体的方法声明，只有方法签名。接口定义的是“做什么”，而不是“怎么做”。

接口不能被实例化，它的作用是让类去实现它（用 implements 关键字）。一个类可以实现多个接口，这意味着一个类可以拥有多个“行为规范”。

第二回合：特性大比拼

了解了身世，接下来咱们看看它们各自的特性，就像了解一个人的性格一样，才能知道怎么和他们相处。

特性	抽象类（Abstract Class）	接口（Interface）
实例化	不能直接实例化	不能直接实例化
继承	可以被继承（使用 `extends` 关键字），单继承	可以被实现（使用 `implements` 关键字），可以多实现
成员变量	可以有成员变量（包括实例变量和静态变量）	只能有静态常量（`static final`）
方法	可以有抽象方法和非抽象方法	只能有抽象方法（Java 8 之前），Java 8 之后可以有默认方法和静态方法
构造方法	可以有构造方法	没有构造方法
访问修饰符	可以使用各种访问修饰符（`public`、`protected`、`private`）	接口中的方法默认是 `public`，不能使用其他修饰符
设计目的	定义“是什么”（is-a）的关系，提供部分实现	定义“能做什么”（has-a）的关系，定义行为规范
代码复用	可以通过非抽象方法实现代码复用	通过默认方法（Java 8 之后）实现代码复用

第三回合：代码实战演练

光说不练假把式，咱们来点真格的，用代码来演示一下抽象类和接口的用法。

抽象类示例：

假设我们要设计一个动物类，动物都有吃东西的行为，但不同动物吃的东西不一样。我们可以使用抽象类来定义动物的通用行为，并让子类去实现具体的吃东西方式。

// 抽象类：动物
abstract class Animal {
    // 成员变量：名字
    private String name;

    // 构造方法
    public Animal(String name) {
        this.name = name;
    }

    // 抽象方法：吃东西
    public abstract void eat();

    // 非抽象方法：睡觉
    public void sleep() {
        System.out.println(name + "正在睡觉...");
    }

    // 获取名字
    public String getName() {
        return name;
    }
}

// 子类：猫
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "正在吃猫粮...");
    }
}

// 子类：狗
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "正在啃骨头...");
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        Cat cat = new Cat("Tom");
        Dog dog = new Dog("旺财");

        cat.eat(); // 输出：Tom正在吃猫粮...
        dog.eat(); // 输出：旺财正在啃骨头...

        cat.sleep(); // 输出：Tom正在睡觉...
        dog.sleep(); // 输出：旺财正在睡觉...
    }
}

在这个例子中，Animal 是一个抽象类，它定义了 eat() 抽象方法和 sleep() 非抽象方法。 Cat 和 Dog 类继承了 Animal 类，并实现了 eat() 方法，提供了具体的吃东西方式。

接口示例：

假设我们要设计一些可以飞行的物体，比如鸟、飞机、超人等等。我们可以使用接口来定义飞行的行为规范。

// 接口：飞行
interface Flyable {
    // 抽象方法：飞行
    void fly();

    // 默认方法：降落 (Java 8+)
    default void land() {
        System.out.println("正在降落...");
    }
}

// 类：鸟
class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿在天空中自由飞翔...");
    }
}

// 类：飞机
class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("飞机在跑道上加速起飞...");
    }
}

// 类：超人
class Superman implements Flyable {
    @Override
    public void fly() {
        System.out.println("超人伸出双手，飞向远方...");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Bird bird = new Bird();
        Airplane airplane = new Airplane();
        Superman superman = new Superman();

        bird.fly(); // 输出：鸟儿在天空中自由飞翔...
        airplane.fly(); // 输出：飞机在跑道上加速起飞...
        superman.fly(); // 输出：超人伸出双手，飞向远方...

        bird.land(); // 输出：正在降落... (使用了默认方法)
    }
}

在这个例子中，Flyable 是一个接口，它定义了 fly() 抽象方法和 land() 默认方法。 Bird、Airplane 和 Superman 类都实现了 Flyable 接口，并提供了各自的飞行方式。

第四回合：选择困难症终结者

了解了抽象类和接口的特性和用法，接下来就是最关键的问题：什么时候用抽象类？什么时候用接口？这就像选择午饭吃啥一样，选对了心情舒畅，选错了食不下咽。

老王总结了几条选择原则，希望能帮助大家摆脱选择困难症：

关注关系：
- 如果你的类之间存在“is-a”（是什么）的关系，比如“猫是一种动物”，“汽车是一种交通工具”，那么就应该使用抽象类。抽象类可以提供一些通用的实现，让子类继承并扩展。
- 如果你的类之间存在“has-a”（能做什么）的关系，比如“鸟能飞”，“飞机能飞”，“超人能飞”，那么就应该使用接口。接口定义的是行为规范，让类去实现这些规范。
代码复用：
- 如果你的多个类需要共享一些代码，那么可以使用抽象类。抽象类可以提供一些非抽象方法，让子类直接使用，避免重复编写代码。
- 如果你的多个类只需要实现一些特定的行为，而不需要共享代码，那么可以使用接口。接口只定义行为规范，不提供任何实现。
多重继承：
- Java 不支持类的多重继承，但一个类可以实现多个接口。如果你的类需要拥有多个“行为规范”，那么只能使用接口。
演化：
- 如果你的 API 需要不断演化，那么使用接口可能更灵活。因为接口可以添加默认方法（Java 8 之后），而不会破坏已有的实现类。

第五回合：进阶技巧与注意事项

除了以上几点，还有一些进阶技巧和注意事项，可以帮助大家更好地使用抽象类和接口：

Java 8 的接口默认方法：

Java 8 引入了接口的默认方法，这意味着接口也可以提供一些方法的默认实现。这使得接口在演化过程中更加灵活，可以在不破坏已有实现类的情况下添加新的方法。

interface MyInterface {
    void doSomething();

    default void doSomethingElse() {
        System.out.println("Doing something else...");
    }
}

class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

public class DefaultMethodExample {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.doSomething(); // 输出：Doing something...
        myClass.doSomethingElse(); // 输出：Doing something else...
    }
}

Java 8 的接口静态方法：

Java 8 还引入了接口的静态方法，这意味着接口也可以拥有静态方法，可以直接通过接口名调用。

interface MyInterface {
    static void doSomethingStatic() {
        System.out.println("Doing something static...");
    }
}

public class StaticMethodExample {
    public static void main(String[] args) {
        MyInterface.doSomethingStatic(); // 输出：Doing something static...
    }
}

何时使用抽象类，何时使用接口，没有绝对的答案：

选择抽象类还是接口，并没有绝对的答案，需要根据具体的场景和需求来决定。有时候，两者都可以使用，这时候就需要根据代码的可维护性、可扩展性、可读性等因素来权衡。

总结：

抽象类和接口都是面向对象编程的重要概念，它们各有优缺点，适用于不同的场景。理解它们的特性和用法，并根据实际情况选择合适的工具，才能写出高质量的代码。

希望今天的分享对大家有所帮助！如果你觉得老王讲得还不错，记得点个赞哦！如果你有任何疑问或者想法，欢迎在评论区留言，咱们一起交流学习！

下次再见！

抽象类与接口：一场“鱼与熊掌”的抉择

发表回复 取消回复

发表回复取消回复