接口与抽象类：你搞懂“能做什么”和“是什么”了吗？

在阅读开源项目代码时，经常遇到 interface（接口）和 abstract class（抽象类），这确实是面向对象编程（OOP）中比较容易混淆但也非常核心的概念。你感觉它们是为了让代码更灵活，这个直觉非常正确！它们是实现“高内聚、低耦合”和“面向接口编程”的关键。下面我们来深入探讨一下。

一、 接口（Interface）和抽象类（Abstract Class）是什么？

要理解它们，我们先从最基础的普通类说起。

1. 普通类（Concrete Class）

普通类是我们最常见的类，它可以有字段（成员变量）、方法，所有方法都有具体的实现。普通类可以直接被实例化（new 一个对象）。

2. 抽象类（Abstract Class）

抽象类是普通类的延伸，它：

• 不能直接实例化：你不能 new 一个抽象类的对象。
• 可以包含抽象方法：抽象方法只有方法签名（定义，如 public abstract void doSomething();），没有具体实现。子类必须实现所有抽象方法，除非子类也是抽象类。
• 可以包含非抽象方法（具体实现）和字段：这是它与接口最大的不同。抽象类可以提供一些公共的、默认的行为。
• 通过 abstract 关键字声明。

抽象类的核心思想是“部分实现”。它定义了类的一个通用模板，但把一些特定或变化的行为留给子类去实现。它代表的是“是什么”（Is-A）的关系，通常用于统一一族密切相关类的行为和结构。

3. 接口（Interface）

接口是一种完全抽象的类型，它：

• 不能直接实例化：同抽象类。
• 只包含方法签名：在Java 8之前，接口中的方法默认是 public abstract 的，不包含任何实现。Java 8及之后，可以有 default 方法和 static 方法的实现，甚至Java 9开始可以有 private 方法。但其核心仍是定义行为规范。
• 不包含字段：理论上可以定义常量（public static final），但这并非其主要用途。
• 通过 interface 关键字声明。

接口的核心思想是“定义行为规范”，它代表的是“能做什么”（Can-Do）的关系，通常用于定义一套标准化的能力或协议。

二、 它们与普通类、继承和多态的关系

你提到的普通类、继承和多态，是理解接口和抽象类的基石。

1. 与普通类（Concrete Class）的关系

• 普通类是具象的，有完整的实现，可以直接使用。
• 抽象类和接口是抽象的，不能直接使用，需要通过子类（或实现类）来具象化。它们是普通类实现更灵活设计的基础。

2. 与继承（Inheritance）的关系

• 普通类和抽象类都支持继承。一个子类只能继承一个父类（单继承），无论是普通类还是抽象类。继承表达的是“Is-A”关系，子类会获得父类的所有属性和方法。抽象类通过继承机制强制子类实现其抽象方法。
• 接口不支持继承其他类，但可以“实现”（implements）一个或多个接口。这允许一个类具备多种不同的行为特征（多实现），是Java等单继承语言实现“多态”的重要手段。

3. 与多态（Polymorphism）的关系

接口和抽象类都是实现多态的关键机制。

• 多态是指允许不同类的对象对同一消息做出响应（即调用同一个方法名，但根据对象的实际类型执行不同的行为）。
• 抽象类实现多态：通过让不同子类重写抽象方法或继承的具体方法，当父类引用指向不同子类实例时，调用相同的方法会产生不同的结果。

  abstract class Animal {
      public abstract void makeSound();
  }
  class Dog extends Animal {
      public void makeSound() { System.out.println("汪汪！"); }
  }
  class Cat extends Animal {
      public void makeSound() { System.out.println("喵喵！"); }
  }
  // 多态应用
  Animal myPet = new Dog();
  myPet.makeSound(); // 输出 汪汪！
  myPet = new Cat();
  myPet.makeSound(); // 输出 喵喵！
  

• 接口实现多态：通过让不同的类实现同一个接口，并对接口中定义的方法进行具体实现。当接口引用指向不同实现类的实例时，调用接口方法会执行不同的行为。

  interface Flyable {
      void fly();
  }
  class Bird implements Flyable {
      public void fly() { System.out.println("鸟儿在空中飞翔。"); }
  }
  class Airplane implements Flyable {
      public void fly() { System.out.println("飞机在云端穿梭。"); }
  }
  // 多态应用
  Flyable object = new Bird();
  object.fly(); // 输出 鸟儿在空中飞翔。
  object = new Airplane();
  object.fly(); // 输出 飞机在云端穿梭。
  

多态性使得代码更加灵活、可扩展，因为它允许你编写操作基类（或接口）的代码，而这些代码能够处理任何派生类（或实现类）的对象。

三、 何时使用接口，何时使用抽象类？

这是最核心的问题，也是设计代码时经常需要权衡的地方。

总结一下选择标准：

1. 如果你想定义一种类型，且这种类型的大部分行为都有通用实现，只有少数行为需要子类定制，并且这些子类之间存在紧密的“Is-A”关系，那么选择抽象类。
   • 例如，所有动物都有名字和年龄（具体实现），但它们发出声音的方式不同（抽象方法）。Animal 可以是抽象类。
2. 如果你想定义一种能力或契约，任何实现该能力的类都可以遵循这个契约，而这些类之间可能没有任何其他共同点（不属于同一个继承体系），那么选择接口。
   • 例如，飞机能飞，鸟儿能飞，超人也能飞。它们都是“可飞翔”的，但彼此之间并无血缘关系，它们只是恰好都具备“飞”的能力。Flyable 可以是接口。
3. 如果需要利用Java的单继承限制，同时又想为类添加多种行为，那么必须使用接口的多实现。
   • 一个 Amphibian（两栖动物）类，它可能需要继承 Animal 抽象类，同时实现 Swimmable（可游泳的）和 Walkable（可行走的）接口。

四、 代码更灵活的背后原理

你提到的“让代码更灵活”这一点是关键。接口和抽象类之所以能带来这种灵活性，主要是因为它们促进了：

• 面向接口编程 (Program to an interface, not an implementation)：你的代码应该依赖于接口或抽象类型，而不是具体的实现。这样，当底层实现改变时，只要接口不变，你的上层代码就不需要修改。这极大地提高了代码的解耦性。
• 多态性 (Polymorphism)：通过接口或抽象类，你可以统一处理不同具体实现的对象。例如，一个 List<Flyable> 可以存放 Bird 实例，也可以存放 Airplane 实例，调用 fly() 方法时，各自执行自己的飞行逻辑。
• 扩展性 (Extensibility)：当需要新增一种行为（如一个新功能），或者新增一个实现类时，只需创建新的实现类并实现相应的接口或继承抽象类即可，而无需修改现有代码。这符合“开闭原则”（Open/Closed Principle），即对扩展开放，对修改关闭。
• 可测试性 (Testability)：通过接口，你可以方便地为依赖项创建模拟对象（Mock Object）或桩（Stub），从而更容易地对代码进行单元测试。

理解这些概念可能需要一些时间和实践。多看开源代码中它们的使用场景，并尝试自己设计一些小模块，你会逐渐体会到它们的强大之处和带来的设计美感。祝你在编程之路上越走越远！