Java8 后接口的用法总结_java8的接口-CSDN博客

本文链接：https://blog.csdn.net/adorechen/article/details/147565937

Java 8 对接口进行了重要的扩展，引入了默认方法和静态方法，让接口的功能更强大、使用场景更丰富。

一、定义抽象行为

接口的作用是用来抽象行为，提供具体实现类的行为约定。接口尽量使用单一职责原理，保证接口功能的清晰。确实需要多个职责时，使用接口的扩展extends来实现。

下面对单个接口用法进行说明：

1.1 定义抽象方法

这是接口最基本的用法，在 Java 8 之前就已存在。接口里可以定义抽象方法，这些方法没有方法体，实现接口的类必须实现这些抽象方法。

// 定义一个接口
interface Shape {
    // 抽象方法，计算面积
    double area();
    // 抽象方法，计算周长
    double perimeter();
}

// 实现接口的类
class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

1.2 定义默认方法

Java 8 引入了默认方法，使用 default 关键字修饰。默认方法有方法体，实现接口的类可以选择是否重写默认方法。默认方法的主要作用在接口定义了很多方法时，为非必须实现的方法提供默认实现，减少实现类的负担方便使用。

// 定义一个接口
interface Vehicle {
    // 抽象方法
    void start();
    // 默认方法
    default void honk() {
        System.out.println("嘟嘟嘟！");
    }
}

// 实现接口的类
class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("汽车启动了！");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        car.honk(); // 调用默认方法
    }
}

1.3 函数式接口

Java 8 引入了函数式接口的概念，函数式接口是指只包含一个抽象方法的接口，可以使用 @FunctionalInterface 注解进行标注。函数式接口主要用于支持 Lambda 表达式和方法引用。

// 定义函数式接口
@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现函数式接口
        Calculator addition = (a, b) -> a + b;
        int result = addition.calculate(5, 3);
        System.out.println("5 + 3 = " + result);
    }
}

二、工具类实现

2.1 定义静态方法

Java 8 允许在接口中定义静态方法，使用 static 关键字修饰。静态方法属于接口本身，而不是接口的实例，通过接口名可以直接调用。

// 定义一个接口
interface MathUtils {
    // 静态方法，计算两个整数的和
    static int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        // 直接通过接口名调用静态方法
        int sum = MathUtils.add(5, 3);
        System.out.println("5 + 3 = " + sum);
    }
}

三、接口中定义静态变量是一种好的设计吗？

在接口中定义公用的静态变量（即常量）是一种常见的做法，但是否属于好的设计需要根据具体场景判断。

3.1 优势：为什么有人会这样做？

代码复用性
接口中的常量可以被所有实现类直接访问，避免在多个类中重复定义相同的常量，提高代码复用性。
示例：定义一个接口 Constants 存放系统通用常量（如分页大小、状态码等），多个模块的类实现该接口后可直接使用这些常量。
```
public interface Constants {
    int PAGE_SIZE = 10;
    String STATUS_SUCCESS = "0";
}

public class UserService implements Constants {
    public List<User> getUsers(int page) {
        // 直接使用 PAGE_SIZE
        return dao.query("LIMIT " + page + ", " + PAGE_SIZE);
    }
}
```
语义清晰
常量集中定义在接口中，便于维护和理解其用途。例如，将与用户权限相关的常量放在 UserPermission 接口中，命名空间明确。
编译时优化
接口中的常量是 final 类型，属于编译时常量，编译器会将其直接替换到引用的地方（类似宏定义），运行时无需访问接口类，效率较高。

3.2 缺点：为什么可能不是好的设计？

违背接口设计原则（ISP）
** 接口隔离原则（ISP）** 建议接口应专注于定义行为（方法），而非数据（常量）。将常量混入接口中，可能导致接口职责不单一，违反设计模式原则。
反例：若一个接口 UserService 既定义业务方法（如 login()），又定义用户状态常量（如 STATUS_ACTIVE），会让接口变得 “臃肿”，违背职责分离。
实现类被动继承常量（隐性依赖）
实现类通过 implements 关键字继承接口的常量时，会隐性依赖该接口。即使实现类未使用接口中的方法，也必须继承接口以获取常量，导致不必要的耦合。
问题：若后续需要修改常量的归属（如将常量移动到工具类），所有实现类的签名都需修改，维护成本高。
无法支持动态常量
接口中的常量必须在编译时确定值，无法在运行时动态生成（如从配置文件读取）。若需求需要动态调整常量，接口无法满足。
命名空间污染
若多个接口定义同名常量，实现类同时实现这些接口时会引发编译错误（常量名冲突）。
示例：
```
interface A { int X = 1; }
interface B { int X = 2; }
class C implements A, B { // 编译错误：常量 X 重复定义 }
```

3.3 替代方案：更好的设计选择

1. 使用独立的常量类（推荐）

创建专门的 final 类存放常量，通过静态导入使用，避免污染接口职责。
优点：

符合单一职责原则，常量类仅负责存储数据，接口仅定义行为。
无继承耦合，其他类可直接通过类名访问常量，无需实现接口。

// 常量类
public final class AppConstants {
    public static final int PAGE_SIZE = 10;
    public static final String STATUS_SUCCESS = "0";
}

// 使用时静态导入（Java 1.5+）
import static com.example.AppConstants.*;

public class UserService {
    public List<User> getUsers(int page) {
        return dao.query("LIMIT " + page + ", " + PAGE_SIZE); // 直接使用常量
    }
}

2. 枚举类（适用于有限常量集合）

若常量是固定枚举值（如状态、类型），使用枚举类更安全、清晰。

public enum UserStatus {
    ACTIVE("0", "激活"),
    INACTIVE("1", "未激活");

    private final String code;
    private final String desc;

    UserStatus(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    // getter方法
}