java 面向对象编程 (OOP)：之接口的定义_java面向对象接口-优快云博客

一、接口的定义 (Interface Definition)

在 Java 中，接口是一种纯抽象的概念，它定义了一组抽象方法（Abstract Methods）和常量（Constant Fields），用于描述类应该具有的行为，但不提供具体的实现。接口是一种规范，是一种契约 (Contract)，它规定了实现类必须遵循的规则。

接口的语法：
```
[访问修饰符] interface 接口名 [extends 父接口列表] {
    // 常量 (public static final)
    [public static final] 数据类型 常量名 = 初始值;

    // 抽象方法 (public abstract)
    [public abstract] 返回类型 方法名(参数列表);

    // 默认方法 (default methods) - Java 8+
    default 返回类型 方法名(参数列表) {
        // 方法体 (默认实现)
    }

    // 静态方法 (static methods) - Java 8+
    static 返回类型 方法名(参数列表) {
        // 方法体 (静态实现)
    }
    
    // 私有方法 (private methods) - Java 9+
    private 返回类型 方法名(参数列表) {
      // 方法体 (私有实现)
    }
}
```
- 访问修饰符：
  - public：接口可以被任何类访问。
  - 默认（不写）：接口只能被同一个包中的类访问。
  - 接口不能使用 private 或 protected 修饰符。
- interface 关键字： 用于声明一个接口。
- 接口名 (Interface Name): 遵循 PascalCase 命名规范（每个单词首字母大写），例如 Flyable, Runnable, Comparable。
- extends 关键字： 接口可以继承其他接口（多继承），使用 extends 关键字，后面跟父接口列表（多个父接口之间用逗号分隔）。
- 常量 (Constant Fields):
  - 接口中可以定义常量，常量默认是 public static final 的，可以省略这些修饰符。
  - 常量名通常使用大写字母，多个单词之间用下划线分隔（例如 MAX_SPEED）。
- 抽象方法 (Abstract Methods):
  - 抽象方法没有方法体（没有花括号 {}），以分号 ; 结尾。
  - 抽象方法默认是 public abstract 的，可以省略这些修饰符。
  - 实现接口的类必须实现接口中定义的所有抽象方法，除非实现类是抽象类。
- 默认方法 (Default Methods) - Java 8+:
  - 默认方法使用 default 关键字修饰，提供了方法的默认实现。
  - 实现类可以选择重写默认方法，也可以直接使用默认实现。
  - 默认方法的主要作用是 接口的演化，允许在不破坏现有实现类的情况下，向接口中添加新的方法。
- 静态方法 (Static Methods) - Java 8+:
  - 静态方法使用 static 关键字修饰，可以直接通过接口名调用。
  - 静态方法不能被实现类重写。
  - 静态方法通常用于提供与接口相关的工具方法或工厂方法。
- 私有方法 (Private Methods) - Java 9+:
  - 私有方法使用 private 关键字修饰, 只能在接口内部被默认方法或静态方法调用。
  - 私有方法用于提取默认方法和静态方法中的公共代码，提高代码复用性，但不能被实现类或子接口使用。
接口的特性：
- 抽象性： 接口是纯抽象的，不能被实例化（不能使用 new 关键字创建接口的对象）。
- 多继承： 接口可以继承多个父接口。
- 实现： 类通过 implements 关键字实现接口。一个类可以实现多个接口。
- 契约： 接口定义了一组规范，所有实现类都必须遵循这些规范。

二、接口的使用场景

接口在 Java 中有着广泛的应用，主要用于以下场景：

定义规范 (Defining Contracts):
- 接口最核心的作用是定义规范，它规定了一组类应该具有的行为。
- 例如，java.util.List 接口定义了列表的行为（例如 add(), remove(), get(), size() 等），所有实现 List 接口的类（例如 ArrayList, LinkedList）都必须提供这些方法的实现。
- 好处：
  - 统一行为： 确保所有实现类都具有相同的行为，方便使用者调用。
  - 可替换性： 可以轻松地替换不同的实现类，而无需修改使用接口的代码（面向接口编程）。

解耦 (Decoupling):

接口可以将接口的定义与实现分离，降低代码之间的耦合度。
模块之间通过接口进行交互，而不是直接依赖于具体的实现类。
好处：
- 提高可维护性： 修改一个实现类不会影响到其他依赖于接口的类。
- 提高可扩展性： 可以方便地添加新的实现类，而无需修改现有代码。
- 提高可测试性： 可以使用 Mock 对象模拟接口的实现，方便进行单元测试。
示例:

  // 定义Dao接口
  interface UserDao {
      User findById(Long id);
      void save(User user);
  }
  // Dao实现类1
  class UserDaoImpl implements UserDao {
      // ...
  }

  // Dao实现类2
  class UserDaoAnotherImpl implements  UserDao{
      //...
  }

  // Service 类依赖于 UserDao 接口，而不是具体的实现类
  class UserService {
      private final UserDao userDao; // 依赖注入

      public UserService(UserDao userDao) {
          this.userDao = userDao;
      }

      // ...
  }

多态性 (Polymorphism):

接口是实现多态性的重要手段。
可以通过接口引用指向不同的实现类对象，并调用相同的方法，实现不同的行为。

示例： (接前面的 Flyable 接口示例)

Flyable flyable = new Bird(); // 接口引用指向实现类对象
flyable.fly(); // 调用 Bird 类的 fly() 方法

flyable = new Airplane(); // 接口引用指向另一个实现类对象
flyable.fly(); // 调用 Airplane 类的 fly() 方法

多重继承 (Multiple Inheritance) 的替代方案：
- Java 不支持类的多重继承（一个类只能有一个直接父类），但一个类可以实现多个接口。
- 通过实现多个接口，可以实现类似多重继承的效果，获得多个接口的行为。
回调 (Callback):
- 接口可以用于实现回调机制。
- 定义一个接口，其中包含一个回调方法。
- 将接口的实现类对象传递给另一个对象。
- 当某个事件发生时，另一个对象调用接口的回调方法，通知实现类对象。
- 示例： 事件监听器 (例如 ActionListener、MouseListener 等) 就是典型的回调机制。
标记接口 (Marker Interface):
- 标记接口是指没有任何方法和常量的接口，例如 java.io.Serializable, java.lang.Cloneable, java.util.RandomAccess。
- 标记接口的作用是给实现类打上一个标记，表示该类具有某种特性。
- 例如，Serializable 接口表示实现类可以被序列化，Cloneable 接口表示实现类可以被克隆。
定义常量
- 在Java早期版本，接口常常被用来定义一组相关的常量。

三、接口与抽象类的对比

特性	接口 (Interface)	抽象类 (Abstract Class)
抽象方法	可以包含抽象方法 (默认 `public abstract`)。	可以包含抽象方法。
非抽象方法	可以包含默认方法 (default methods) 和静态方法 (static methods) (Java 8+)，以及私有方法 (Java 9+)。	可以包含非抽象方法（有方法体的方法）。
成员变量	只能包含常量 (public static final fields)。	可以包含各种类型的成员变量 (实例变量、静态变量)。
构造方法	不能有构造方法。	可以有构造方法（但不能直接创建抽象类的对象，构造方法用于子类初始化）。
继承	接口可以多继承 (extends 多个接口)。	类只能单继承 (extends 一个类)。
实现	类使用 `implements` 关键字实现接口，可以实现多个接口。	类使用 `extends` 关键字继承抽象类，只能继承一个抽象类。
实例化	不能实例化 (不能创建接口的对象)。	不能实例化 (不能创建抽象类的对象)。
设计目的	定义规范 (契约)，强调 “做什么” (what to do)。	代码复用和抽象，强调 “是什么” (what it is)。
使用场景	当你需要定义一组规范，让不同的类实现这些规范时，使用接口。当你需要实现多态性，并且不需要共享代码时，使用接口。当你需要解耦，将接口与实现分离时，使用接口。	当你需要定义一个类的部分实现，并让子类完成剩余的实现时，使用抽象类。当你需要在多个类之间共享代码，并且这些类之间存在 “is-a” 关系时，使用抽象类。当你需要定义一个模板，让子类按照模板的步骤实现具体逻辑时，使用抽象类 (模板方法模式)。

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

优先选择接口： 接口更灵活，更容易解耦，支持多重继承。大多数情况下，优先选择接口。
需要共享代码或定义部分实现时，使用抽象类： 如果需要在多个类之间共享代码，或者需要定义一个类的部分实现，让子类完成剩余的实现，可以使用抽象类。

四、最佳实践

面向接口编程： 在程序设计中，尽量使用接口类型作为变量、参数和返回值的类型，而不是使用具体的实现类类型。这样可以提高代码的灵活性和可扩展性。
接口命名： 接口名通常使用形容词或名词，表示一种能力或特性 (例如 Runnable, Serializable, Comparable, List)。
接口设计： 接口应该小而精，功能单一。避免设计过于庞大的接口，可以将大接口拆分成多个小接口 (接口隔离原则)。
默认方法： 谨慎使用默认方法，避免滥用。默认方法主要用于接口的演化，不要将默认方法作为实现业务逻辑的主要手段。
常量： 如果需要定义常量，可以使用接口，但更推荐使用枚举类 (Enum) 来定义常量。
版本控制： 接口一旦发布, 尽量不要修改其中的抽象方法签名, 否则会导致实现类无法编译。如果需要添加新功能, 可以添加新的 default 方法, 或者定义新的接口。