3.5接口

 接口

在 Java 中，接口（Interface）是一种非常重要的概念，它是抽象方法的集合，用于定义一组行为规范。

接口的定义

在 Java 里，使用 interface 关键字来定义接口，其基本语法如下：

[访问修饰符] interface 接口名 [extends 父接口名列表] {
    // 常量定义
    [public static final] 数据类型 常量名 = 值;

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

    // 默认方法（Java 8 及以上）
    [public] default 返回类型 方法名(参数列表) {
        // 方法体
    }

    // 静态方法（Java 8 及以上）
    [public] static 返回类型 方法名(参数列表) {
        // 方法体
    }

    // 私有方法（Java 9 及以上）
    private 返回类型 方法名(参数列表) {
        // 方法体
    }
}

• 访问修饰符：可选，通常为 public，表示该接口可以被任何类访问。
• 接口名：遵循 Java 的命名规范，一般采用大驼峰命名法。
• extends：可选，用于指定该接口继承的父接口。Java 接口支持多继承，即一个接口可以继承多个父接口。
• 常量定义：接口中的常量默认是 public static final 类型，即全局常量，必须在定义时进行初始化，且值不能被修改。
• 抽象方法：接口中的抽象方法默认是 public abstract 类型，只有方法声明，没有方法体，需要实现类去实现。
• 默认方法：Java 8 引入的新特性，使用 default 关键字修饰，有方法体，实现类可以选择是否重写该方法。
• 静态方法：Java 8 引入的新特性，使用 static 关键字修饰，有方法体，可以通过接口名直接调用。
• 私有方法：Java 9 引入的新特性，使用 private 关键字修饰，有方法体，只能在接口内部被调用，用于封装一些通用的逻辑。

接口的特点

• 不能实例化：接口不能直接创建对象，因为它只是一个规范，没有具体的实现。
• 抽象方法：接口中的方法默认是抽象方法，需要实现类去实现这些方法。
• 多实现：一个类可以实现多个接口，通过 implements 关键字，这弥补了 Java 单继承的不足。
• 常量：接口中的变量默认是 public static final 类型的常量，必须在定义时进行初始化。

接口的实现

一个类可以通过 implements 关键字来实现一个或多个接口，实现接口的类必须实现接口中的所有抽象方法。

// 定义一个接口
interface Animal {
    // 抽象方法
    void eat();
    void sleep();

    // 默认方法
    default void move() {
        System.out.println("Animal is moving.");
    }

    // 静态方法
    static void breathe() {
        System.out.println("Animal is breathing.");
    }
}

// 实现类
class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
}

public class InterfaceImplementationExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
        dog.move();
        Animal.breathe();
    }
}

代码解释

• Animal 接口定义了两个抽象方法 eat() 和 sleep()，一个默认方法 move() 和一个静态方法 breathe()。
• Dog 类实现了 Animal 接口，必须实现 eat() 和 sleep() 方法。
• 在 main 方法中，创建了 Dog 对象，调用了 eat()、sleep() 和 move() 方法，通过接口名 Animal 调用了静态方法 breathe()。

接口的继承

接口可以继承其他接口，使用 extends 关键字，一个接口可以继承多个父接口。

// 父接口 1
interface Flyable {
    void fly();
}

// 父接口 2
interface Swimmable {
    void swim();
}

// 子接口，继承了 Flyable 和 Swimmable 接口
interface Amphibious extends Flyable, Swimmable {
    void walk();
}

// 实现类
class Duck implements Amphibious {
    @Override
    public void fly() {
        System.out.println("Duck is flying.");
    }

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

    @Override
    public void walk() {
        System.out.println("Duck is walking.");
    }
}

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

代码解释

• Amphibious 接口继承了 Flyable 和 Swimmable 接口，同时添加了自己的抽象方法 walk()。
• Duck 类实现了 Amphibious 接口，必须实现 fly()、swim() 和 walk() 方法。

接口的使用场景

• 定义规范：接口可以定义一组行为规范，让不同的类去实现这些规范，提高代码的可维护性和可扩展性。
• 多态：通过接口可以实现多态，一个接口的引用可以指向不同的实现类对象，调用不同的实现方法。
• 解耦：接口可以将调用者和实现者分离，降低代码的耦合度，提高代码的灵活性。

Java 接口是一种强大的编程工具，它定义了一组行为规范，使得不同的类可以实现相同的接口，从而实现多态。接口的引入弥补了 Java 单继承的不足，提高了代码的可维护性和可扩展性。

强制重写与显式指定

若实现类同时继承多个含同名 default 方法的接口，必须重写该方法，并通过 接口名.super.方法名() 显式调用特定接口的默认方法：

public interface InterfaceA {{
    default void log() {{
        System.out.println("A  的默认方法");
    }}
}}

public interface InterfaceB {{
    default void log() {{
        System.out.println("B  的默认方法");
    }}
}}

public class MyClass implements InterfaceA, InterfaceB {{
    @Override 
    public void log() {{
        InterfaceA.super.log();   // 显式调用 InterfaceA 的默认方法 
    }}
}}

• 关键点：通过 接口名.super 指定具体接口的 default 方法
• 一个类实现多接口。如果多个接口中存在方法签名冲突，此时不支持多实现

this 在 default 方法中的作用

1. 指向当前对象实例
   this 在 default 方法中引用的是 实现该接口的类的实例。例如：

   public interface Vehicle {{
       default void start() {{
           System.out.println(" 启动车辆：" + this.getClass().getSimpleName()); 
       }}
   }}
   
   public class Car implements Vehicle {{}}

2. 访问接口中的其他成员
   this 可以调用接口中定义的 其他 default 方法 或 静态常量：

   public interface Logger {{
       String DEFAULT_PREFIX = "[LOG]";
       
       default void info(String message) {{
           this.log(DEFAULT_PREFIX  + message);  // 调用另一个 default 方法 
       }}
   
       default void log(String message) {{
           System.out.println(message); 
       }}
   }}

---

使用 this 的限制

1. 无法直接访问实现类的私有成员
   this 仅能访问接口中定义的成员（如 default 方法、常量）或实现类中 重写的公共方法，无法直接访问实现类的私有字段或方法

1. 链式调用
   在 default 方法中通过 this 实现链式调用：

   public interface Builder {{
       default Builder append(String part) {{
           // 实现拼接逻辑 
           return this;
       }}
   }}

2. 模板方法模式
   利用 this 调用抽象方法完成模板逻辑：

   public interface DataProcessor {{
       default void process() {{
           validate();
           transform();
           save();
       }}
   
       void validate();
       void transform();
       void save();
   }}

---