精通 Java 抽象类与接口设计模式：理解抽象类用于定义模板方法，接口用于定义行为契约，提升系统灵活性与扩展性。

好的，各位未来的架构师、代码艺术家们，欢迎来到今天的 "Java 抽象类与接口：灵活设计的双刃剑" 特别讲座！我是你们的老朋友，代码界的段子手，今天咱们就来聊聊 Java 里这两位既熟悉又容易让人迷糊的老朋友：抽象类和接口。

开场白：代码世界的“甲方爸爸”与“乙方小弟”

在软件开发这个充满 bug 和需求的江湖里，我们程序员常常扮演着 "乙方小弟" 的角色，被各种 "甲方爸爸" 提出的需求虐得死去活来。但是，咱们也得学会武装自己，用优雅的设计模式，让代码像变形金刚一样灵活应变，而不是像豆腐渣工程一样不堪一击。

而抽象类和接口，就是我们手中的两把利器，用得好，就能让我们的代码拥有更强的生命力，更好地应对那些 "甲方爸爸" 提出的各种奇葩需求。

第一幕：抽象类 —— “半成品”的诱惑

想象一下，你是一家汽车制造厂的老板，要生产各种各样的汽车：轿车、SUV、跑车…… 你肯定不会从零开始，重新设计每一款车的发动机、底盘、车轮吧？太费劲了！

聪明的做法是，先设计一个“汽车”的蓝图，定义一些所有汽车都必须具备的属性和行为，比如：

• 属性： 颜色、品牌、型号
• 行为： 启动、加速、刹车

但是，具体的启动方式、加速方式、刹车方式，每种车可能都不一样。轿车可能启动时需要钥匙，跑车可能需要一键启动，SUV可能需要远程启动……

这时候，抽象类就闪亮登场了！

抽象类的定义：

• 用 abstract 关键字修饰的类。
• 可以包含抽象方法（用 abstract 修饰的方法，没有方法体）和非抽象方法（有方法体）。
• 不能直接被实例化（new），只能被继承。

抽象类的作用：

• 定义一个模板，规定子类必须实现哪些方法（抽象方法），子类可以在此基础上进行扩展。
• 提供一些公共的实现（非抽象方法），供子类直接使用，减少重复代码。

举个栗子：

abstract class Car { // 抽象类 Car

    private String color;
    private String brand;
    private String model;

    public Car(String color, String brand, String model) {
        this.color = color;
        this.brand = brand;
        this.model = model;
    }

    // 抽象方法：启动
    public abstract void start();

    // 抽象方法：加速
    public abstract void accelerate();

    // 非抽象方法：刹车 (所有车都一样)
    public void brake() {
        System.out.println("踩下刹车，减速...");
    }

    public String getColor() {
        return color;
    }

    public String getBrand() {
        return brand;
    }

    public String getModel() {
        return model;
    }
}

class Sedan extends Car { // 轿车继承自 Car

    public Sedan(String color, String brand, String model) {
        super(color, brand, model);
    }

    @Override
    public void start() {
        System.out.println("插入钥匙，拧动，轿车启动！");
    }

    @Override
    public void accelerate() {
        System.out.println("轻踩油门，轿车加速！");
    }
}

class SportsCar extends Car { // 跑车继承自 Car

    public SportsCar(String color, String brand, String model) {
        super(color, brand, model);
    }

    @Override
    public void start() {
        System.out.println("按下启动按钮，跑车引擎轰鸣！");
    }

    @Override
    public void accelerate() {
        System.out.println("深踩油门，跑车瞬间加速！");
    }
}

public class AbstractClassDemo {
    public static void main(String[] args) {
        Sedan sedan = new Sedan("红色", "大众", "朗逸");
        SportsCar sportsCar = new SportsCar("蓝色", "法拉利", "488");

        sedan.start();
        sedan.accelerate();
        sedan.brake();

        sportsCar.start();
        sportsCar.accelerate();
        sportsCar.brake();
    }
}

代码解读：

• Car 是一个抽象类，定义了汽车的基本属性和行为。
• start() 和 accelerate() 是抽象方法，表示启动和加速的具体方式由子类来实现。
• brake() 是非抽象方法，提供了刹车的默认实现，子类可以直接使用。
• Sedan 和 SportsCar 是 Car 的子类，分别实现了 start() 和 accelerate() 方法，提供了轿车和跑车的具体启动和加速方式。

抽象类的优点：

• 代码复用： 抽象类可以提供一些公共的实现，减少子类的重复代码。
• 强制约束： 抽象类可以强制子类实现某些方法，保证代码的规范性。
• 模板方法模式： 抽象类可以定义一个算法的骨架，将一些步骤延迟到子类来实现，这就是模板方法模式。

抽象类的缺点：

• 单继承： Java 只支持单继承，一个类只能继承一个抽象类，这限制了代码的灵活性。

第二幕：接口 —— “行为契约”的魅力

现在，假设我们又接到一个 "甲方爸爸" 的需求：所有的汽车都要支持自动驾驶功能！但是，不同的汽车厂商可能采用不同的自动驾驶技术。

这时候，抽象类就有点力不从心了。因为自动驾驶不仅仅是汽车的行为，还可能涉及到传感器、算法、数据等等。而且，有些非汽车类的东西，比如无人机，也可能需要支持自动驾驶功能。

这时候，接口就派上用场了！

接口的定义：

• 用 interface 关键字修饰。
• 只能包含抽象方法（在 Java 8 之前）和常量。
• 可以被多个类实现（implements）。

接口的作用：

• 定义一组行为规范，任何实现了该接口的类，都必须实现接口中定义的所有方法。
• 实现多重继承的效果，一个类可以实现多个接口。
• 实现解耦，降低代码的耦合度。

举个栗子：

interface AutoPilot { // 接口 AutoPilot

    // 自动驾驶
    void autoDrive();

    // 自动泊车
    void autoPark();
}

class Tesla implements Car, AutoPilot { // Tesla 实现了 Car 和 AutoPilot 接口

    private String color;
    private String brand;
    private String model;

    public Tesla(String color, String brand, String model) {
        this.color = color;
        this.brand = brand;
        this.model = model;
    }

    @Override
    public void start() {
        System.out.println("特斯拉自动启动！");
    }

    @Override
    public void accelerate() {
        System.out.println("特斯拉自动加速！");
    }

    @Override
    public void brake() {
        System.out.println("特斯拉自动刹车！");
    }

    @Override
    public void autoDrive() {
        System.out.println("特斯拉进入自动驾驶模式！");
    }

    @Override
    public void autoPark() {
        System.out.println("特斯拉自动泊车！");
    }

    public String getColor() {
        return color;
    }

    public String getBrand() {
        return brand;
    }

    public String getModel() {
        return model;
    }
}

class Drone implements AutoPilot { // 无人机实现了 AutoPilot 接口

    @Override
    public void autoDrive() {
        System.out.println("无人机进入自动飞行模式！");
    }

    @Override
    public void autoPark() {
        System.out.println("无人机自动降落！");
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Tesla tesla = new Tesla("白色", "特斯拉", "Model 3");
        Drone drone = new Drone();

        tesla.start();
        tesla.autoDrive();
        tesla.autoPark();

        drone.autoDrive();
        drone.autoPark();
    }
}

代码解读：

• AutoPilot 是一个接口，定义了自动驾驶的行为规范。
• Tesla 类同时实现了 Car 接口和 AutoPilot 接口，表示 Tesla 既是一辆汽车，又支持自动驾驶功能。
• Drone 类实现了 AutoPilot 接口，表示无人机也支持自动驾驶功能。

接口的优点：

• 多重继承： 一个类可以实现多个接口，实现多重继承的效果。
• 解耦： 接口可以将实现和接口分离，降低代码的耦合度。
• 灵活性： 接口可以定义一组行为规范，任何实现了该接口的类，都必须实现接口中定义的所有方法，这保证了代码的规范性和灵活性。

接口的缺点：

• 抽象方法： 在 Java 8 之前，接口只能包含抽象方法，这限制了接口的功能。 (Java 8 之后可以包含 default 方法和 static 方法)

第三幕：抽象类 vs 接口 —— “鱼与熊掌”的选择

现在，我们来总结一下抽象类和接口的异同点，以及在什么情况下应该选择哪一个：

特性	抽象类	接口
关键字	abstract	interface
继承/实现	单继承	多实现
成员变量	可以有成员变量	只能有常量（static final）
方法	可以有抽象方法和非抽象方法	只能有抽象方法 (Java 8 之前)
构造方法	可以有构造方法	没有构造方法
用途	定义模板，提供公共实现，强制约束子类	定义行为规范，实现多重继承，解耦
关系	"is-a" 关系 (是一种)	"has-a" 关系 (拥有一种能力)

选择指南：

• 如果你想定义一个类的模板，并且希望子类继承一些公共的实现，那么就选择抽象类。 比如：各种动物都属于 "动物" 这个抽象概念，它们都有一些共同的属性和行为，比如：吃东西、睡觉。
• 如果你想定义一组行为规范，并且希望不同的类都能够实现这些行为，那么就选择接口。 比如：各种交通工具都可以 "行驶"，但它们行驶的方式可能不一样。

更形象的比喻：

• 抽象类： 就像 "肯德基" 的菜单，它规定了你必须卖哪些东西，比如：炸鸡、汉堡，但是具体的口味你可以自己调整。
• 接口： 就像 "USB 接口"，它规定了你必须支持哪些功能，比如：数据传输、供电，但是具体的实现方式你可以自己决定。

第四幕：Java 8 的新特性 —— 接口的逆袭

在 Java 8 之前，接口只能包含抽象方法，这使得接口的功能比较单一。但是，Java 8 引入了两个新特性，让接口的功能得到了极大的增强：

• 默认方法 (Default Methods)： 可以在接口中定义带有方法体的默认方法，子类可以直接使用，也可以选择重写。
• 静态方法 (Static Methods)： 可以在接口中定义静态方法，可以通过接口名直接调用。

举个栗子：

interface MyInterface {

    // 抽象方法
    void doSomething();

    // 默认方法
    default void doSomethingElse() {
        System.out.println("MyInterface 的默认实现 doSomethingElse!");
    }

    // 静态方法
    static void doSomethingStatic() {
        System.out.println("MyInterface 的静态方法 doSomethingStatic!");
    }
}

class MyClass implements MyInterface {

    @Override
    public void doSomething() {
        System.out.println("MyClass 实现了 doSomething!");
    }
}

public class DefaultMethodDemo {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.doSomething();
        myClass.doSomethingElse(); // 调用接口的默认方法
        MyInterface.doSomethingStatic(); // 调用接口的静态方法
    }
}

Java 8 之后，接口和抽象类的界限变得更加模糊。 接口现在可以提供一些默认实现，而抽象类仍然可以定义模板。

结论：

抽象类和接口都是 Java 中非常重要的概念，它们可以帮助我们设计出更加灵活、可扩展的代码。选择哪一个，取决于具体的应用场景和需求。

• 如果你需要定义一个类的模板，并且希望子类继承一些公共的实现，那么就选择抽象类。
• 如果你需要定义一组行为规范，并且希望不同的类都能够实现这些行为，那么就选择接口。

记住，代码设计没有绝对的对错，只有更适合的选择。多思考，多实践，你才能真正掌握抽象类和接口的精髓，成为一名真正的代码艺术家！

最后的彩蛋：

以后再遇到 "甲方爸爸" 提出的奇葩需求，不要慌，拿出抽象类和接口这两把利器，优雅地解决问题，让他们对你刮目相看！ 🚀 😎 🏆

希望今天的讲座对大家有所帮助！我们下期再见！ 👋