1. Java接口核心概念解析接口Interface是Java语言中实现抽象的核心机制之一。与抽象类不同接口是完全抽象的契约定义它规定了实现类必须遵守的行为规范。理解接口的关键在于把握其定义规范与实现分离的设计哲学。1.1 接口的基本语法结构一个标准的Java接口声明如下public interface Animal { // 常量定义隐式public static final String TYPE 生物; // 抽象方法隐式public abstract void eat(); // 默认方法Java 8 default void breathe() { System.out.println(呼吸氧气); } // 静态方法Java 8 static void displayType() { System.out.println(TYPE); } }接口的特点包括方法默认是public abstract的可省略修饰符变量默认是public static final的Java 8开始支持默认方法和静态方法Java 9开始支持私有方法1.2 接口与抽象类的区别初学者常混淆接口和抽象类它们的核心差异在于特性接口抽象类实例化不能不能构造方法没有可以有方法实现Java 8前不能有可以有具体方法多继承一个类可实现多个接口只能单继承成员变量只能是常量可以是普通变量设计目的定义行为规范提供部分实现实际开发中当需要定义行为契约时优先使用接口当需要代码复用时考虑抽象类。2. 接口的典型应用场景2.1 回调机制实现接口最经典的应用是实现回调Callback模式。例如GUI事件处理// 回调接口 interface ClickListener { void onClick(); } // 使用回调的按钮类 class Button { private ClickListener listener; public void setClickListener(ClickListener listener) { this.listener listener; } public void click() { if(listener ! null) { listener.onClick(); } } } // 实际使用 public class Main { public static void main(String[] args) { Button btn new Button(); btn.setClickListener(() - System.out.println(按钮被点击了)); btn.click(); } }2.2 策略模式应用接口可以优雅地实现策略模式使算法可以相互替换interface SortingStrategy { void sort(int[] array); } class BubbleSort implements SortingStrategy { Override public void sort(int[] array) { // 冒泡排序实现 } } class QuickSort implements SortingStrategy { Override public void sort(int[] array) { // 快速排序实现 } } class Sorter { private SortingStrategy strategy; public void setStrategy(SortingStrategy strategy) { this.strategy strategy; } public void executeSort(int[] array) { strategy.sort(array); } }2.3 面向接口编程实践良好的Java设计提倡面向接口编程原则// 不好的写法 class MySQLDatabase { public void saveData() { // MySQL特定实现 } } // 好的写法 interface Database { void saveData(); } class MySQLDatabase implements Database { Override public void saveData() { // MySQL特定实现 } } class OracleDatabase implements Database { Override public void saveData() { // Oracle特定实现 } }面向接口编程的优势降低耦合度提高代码扩展性便于单元测试符合开闭原则3. Java 8接口新特性详解3.1 默认方法Default Methods默认方法允许接口提供方法实现解决了接口演化问题interface Vehicle { void start(); default void honk() { System.out.println(嘟嘟嘟); } } class Car implements Vehicle { Override public void start() { System.out.println(汽车启动); } // 可以不实现honk() }默认方法使用场景接口需要新增方法但不想破坏现有实现提供通用功能实现实现类似混入Mixin的功能注意当多个接口有相同默认方法时实现类必须重写该方法或用InterfaceName.super.method()指定3.2 静态方法接口中的静态方法为工具方法提供了更好的组织方式interface MathOperations { static int add(int a, int b) { return a b; } } // 使用方式 int sum MathOperations.add(5, 3);与工具类的区别语义更明确访问控制更灵活与接口相关的操作更内聚3.3 私有方法Java 9Java 9允许接口定义私有方法提高代码复用interface Logger { default void logInfo(String message) { doLog(INFO, message); } default void logError(String message) { doLog(ERROR, message); } private void doLog(String level, String message) { System.out.println([ level ] message); } }4. 接口设计最佳实践4.1 单一职责原则每个接口应该只关注一个特定功能领域// 不好的设计 interface Animal { void eat(); void sleep(); void fly(); // 不是所有动物都会飞 } // 好的设计 interface Animal { void eat(); void sleep(); } interface Flyable { void fly(); }4.2 接口隔离原则客户端不应被迫依赖它们不使用的接口// 违反ISP的设计 interface Worker { void work(); void eat(); void sleep(); } // 符合ISP的设计 interface Workable { void work(); } interface Eatable { void eat(); } interface Sleepable { void sleep(); }4.3 标记接口的使用空接口可以作为标记使用虽然注解更现代interface Serializable { // 没有任何方法 } class MyClass implements Serializable { // 实现类 }现代Java开发中更推荐使用注解Target(ElementType.TYPE) Retention(RetentionPolicy.RUNTIME) public interface MyMarker { }5. 常见问题与解决方案5.1 菱形继承问题当多个接口有相同默认方法时interface A { default void foo() { System.out.println(A); } } interface B { default void foo() { System.out.println(B); } } class C implements A, B { // 必须重写foo() Override public void foo() { A.super.foo(); // 显式选择A的实现 } }解决方案重写冲突方法使用InterfaceName.super.method()指定重构接口设计避免冲突5.2 接口与抽象类的选择决策流程参考需要多继承→ 选接口需要共享代码→ 考虑抽象类只定义行为规范→ 选接口需要维护状态→ 考虑抽象类5.3 接口演化策略当需要修改已发布的接口时优先考虑添加默认方法新增接口继承原接口使用适配器模式绝对避免删除或修改已有方法6. 实战案例支付系统设计6.1 支付接口定义public interface PaymentGateway { // 支付方法 PaymentResult processPayment(PaymentRequest request); // 退款方法 RefundResult processRefund(RefundRequest request); // 查询支付状态 default PaymentStatus checkPaymentStatus(String transactionId) { throw new UnsupportedOperationException(状态查询未实现); } // 获取支付渠道名称 String getGatewayName(); }6.2 具体实现示例public class AlipayGateway implements PaymentGateway { Override public PaymentResult processPayment(PaymentRequest request) { // 调用支付宝SDK实现 return new PaymentResult(true, ALI System.currentTimeMillis()); } Override public RefundResult processRefund(RefundRequest request) { // 调用支付宝退款API return new RefundResult(true, 退款成功); } Override public String getGatewayName() { return 支付宝支付; } }6.3 使用工厂模式整合public class PaymentGatewayFactory { private static final MapString, PaymentGateway gateways new HashMap(); static { gateways.put(alipay, new AlipayGateway()); gateways.put(wechat, new WechatPayGateway()); gateways.put(union, new UnionPayGateway()); } public static PaymentGateway getGateway(String type) { PaymentGateway gateway gateways.get(type.toLowerCase()); if(gateway null) { throw new IllegalArgumentException(不支持的支付类型); } return gateway; } }7. 接口测试技巧7.1 使用Mock对象测试public class PaymentServiceTest { Test public void testProcessPayment() { // 创建mock对象 PaymentGateway mockGateway Mockito.mock(PaymentGateway.class); // 设置预期行为 when(mockGateway.processPayment(any())) .thenReturn(new PaymentResult(true, mock-tx-123)); // 测试系统 PaymentService service new PaymentService(mockGateway); PaymentResult result service.processOrder(new Order()); // 验证结果 assertTrue(result.isSuccess()); verify(mockGateway).processPayment(any()); } }7.2 接口契约测试使用Pact等工具验证接口契约Pact(consumer ConsumerApp) public RequestResponsePact createPact(PactDslWithProvider builder) { return builder .given(订单存在) .uponReceiving(支付请求) .path(/pay) .method(POST) .willRespondWith() .status(200) .body(new PactDslJsonBody() .booleanType(success, true) .stringType(transactionId, tx-123)) .toPact(); }8. 性能考量与优化8.1 接口方法调用的开销Java接口方法调用通过虚方法表vtable实现与类方法调用性能相当。现代JVM优化后差异可以忽略不计。8.2 减少接口数量优化在极端性能敏感场景如高频交易系统中减少不必要的接口层次合并相关的小接口考虑使用final类替代8.3 默认方法的影响默认方法会增加接口初始化的开销但只在首次加载时发生。合理使用不会影响运行时性能。9. 现代Java中的接口演进9.1 函数式接口与LambdaJava 8引入的函数式接口只有一个抽象方法的接口与Lambda表达式完美配合FunctionalInterface interface StringProcessor { String process(String input); default StringProcessor andThen(StringProcessor after) { return input - after.process(process(input)); } } // 使用示例 StringProcessor upperCase String::toUpperCase; StringProcessor trim String::trim; StringProcessor pipeline trim.andThen(upperCase); String result pipeline.process( hello ); // 输出HELLO9.2 接口与模式匹配Java 17引入的模式匹配可以简化接口类型判断record Circle(double radius) implements Shape {} record Rectangle(double w, double h) implements Shape {} interface Shape { default double area() { return switch(this) { case Circle c - Math.PI * c.radius() * c.radius(); case Rectangle r - r.w() * r.h(); default - throw new IllegalStateException(); }; } }10. 企业级应用中的接口设计10.1 分层架构中的接口应用典型的三层架构中接口的使用// 持久层接口 public interface UserRepository { User findById(Long id); void save(User user); } // 服务层接口 public interface UserService { UserDTO getUserDetails(Long userId); void updateUserProfile(UserProfileDTO profile); } // 控制层接口 public interface UserController { ResponseEntityUserDTO getUser(PathVariable Long id); ResponseEntityVoid updateUser(RequestBody UserProfileDTO dto); }10.2 微服务中的接口设计在微服务架构中接口常用于定义服务契约API规范客户端SDK设计跨服务通信协议public interface InventoryService { GET(/api/inventory/{sku}) InventoryInfo getInventory(Path(sku) String sku); POST(/api/inventory/adjust) Response adjustInventory(Body InventoryAdjustment adjustment); }11. 接口与设计模式深度结合11.1 工厂方法模式interface Logger { void log(String message); } interface LoggerFactory { Logger createLogger(); } class FileLoggerFactory implements LoggerFactory { Override public Logger createLogger() { return new FileLogger(); } } class ConsoleLoggerFactory implements LoggerFactory { Override public Logger createLogger() { return new ConsoleLogger(); } }11.2 观察者模式interface Observer { void update(String event); } interface Observable { void addObserver(Observer o); void removeObserver(Observer o); void notifyObservers(String event); } class NewsAgency implements Observable { private final ListObserver observers new ArrayList(); Override public void addObserver(Observer o) { observers.add(o); } Override public void notifyObservers(String event) { observers.forEach(o - o.update(event)); } }12. 接口的替代方案与比较12.1 抽象类当需要以下特性时考虑抽象类共享代码实现维护对象状态控制构造过程定义protected方法12.2 注解现代Java中注解可以部分替代标记接口的功能Retention(RetentionPolicy.RUNTIME) Target(ElementType.TYPE) public interface MyComponent { String value() default ; }12.3 函数式接口对于单一方法场景函数式接口更简洁FunctionalInterface interface Validator { boolean validate(String input); }13. 接口在框架中的应用13.1 Spring框架中的接口应用Spring大量使用接口实现控制反转public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory { String getId(); String getApplicationName(); // ... } public interface BeanFactory { Object getBean(String name) throws BeansException; // ... }13.2 JPA中的Repository接口Spring Data JPA通过接口自动生成实现public interface UserRepository extends JpaRepositoryUser, Long { ListUser findByLastName(String lastName); Query(SELECT u FROM User u WHERE u.email ?1) User findByEmailAddress(String email); }14. 接口设计反模式14.1 过于庞大的接口反模式示例interface GodInterface { void saveUser(); void updateUser(); void deleteUser(); void sendEmail(); void generateReport(); // ... 数十个不相关方法 }改进方案按单一职责拆分使用接口组合14.2 过度依赖默认方法反模式interface Utility { default void util1() { /* 实现 */ } default void util2() { /* 实现 */ } // ... 大量默认方法 }更好的做法将工具方法放入工具类使用静态导入14.3 接口污染反模式interface A { void method1(); } interface B extends A { void method2(); void method3(); // 继承了不需要的method1() }解决方案使用接口组合而非继承遵循接口隔离原则15. 接口的未来发展趋势15.1 更灵活的接口组合Java可能会引入更灵活的接口组合方式类似Kotlin的接口委托interface A { void foo(); } interface B { void bar(); } class C implements A, B { private final A aDelegate new AImpl(); private final B bDelegate new BImpl(); Override public void foo() { aDelegate.foo(); } Override public void bar() { bDelegate.bar(); } }15.2 与值类型的结合随着值类型Value Types的发展接口可能会有新的应用方式interface Point { double x(); double y(); default double distanceTo(Point other) { double dx x() - other.x(); double dy y() - other.y(); return Math.sqrt(dx*dx dy*dy); } }16. 接口调试技巧16.1 动态代理调试使用动态代理记录接口调用public class DebugProxy implements InvocationHandler { private final Object target; public DebugProxy(Object target) { this.target target; } Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(调用方法: method.getName()); return method.invoke(target, args); } public static T T create(T target, ClassT interfaceType) { return (T) Proxy.newProxyInstance( interfaceType.getClassLoader(), new Class?[] { interfaceType }, new DebugProxy(target) ); } } // 使用方式 Database db DebugProxy.create(new RealDatabase(), Database.class);16.2 接口方法断点在IDE中可以为接口方法设置断点在接口方法声明处设置断点所有实现类的该方法调用都会暂停特别适合调试多态调用17. 接口文档化实践17.1 Javadoc规范良好的接口文档示例/** * 定义缓存服务的基本操作契约 * * param K 键类型 * param V 值类型 */ public interface CacheServiceK, V { /** * 将值放入缓存 * param key 缓存键非空 * param value 缓存值 * throws NullPointerException 如果key为null */ void put(K key, V value); /** * 从缓存获取值 * param key 缓存键 * return 对应的值如果不存在返回null */ V get(K key); }17.2 使用Swagger注解结合OpenAPI规范文档化REST接口Tag(name 用户管理) public interface UserApi { Operation(summary 获取用户详情) ApiResponse(responseCode 200, description 用户详情) GetMapping(/users/{id}) UserDto getUser(Parameter(description 用户ID) PathVariable Long id); }18. 接口版本管理策略18.1 兼容性演进原则只添加新方法默认方法优先不删除已有方法不修改已有方法签名必要时创建新接口继承原接口18.2 版本化接口示例// v1 public interface PaymentService { PaymentResult pay(PaymentRequest request); } // v2 public interface PaymentServiceV2 extends PaymentService { default PaymentResult pay(PaymentRequestV2 request) { // 适配旧接口 PaymentRequest v1Request convert(request); return pay(v1Request); } private PaymentRequest convert(PaymentRequestV2 request) { // 转换逻辑 } }19. 跨平台接口设计19.1 通用序列化接口public interface Serializer { byte[] serialize(Object obj) throws IOException; T T deserialize(byte[] data, ClassT type) throws IOException; default String serializeToString(Object obj) throws IOException { return new String(serialize(obj), StandardCharsets.UTF_8); } default T T deserializeFromString(String data, ClassT type) throws IOException { return deserialize(data.getBytes(StandardCharsets.UTF_8), type); } }19.2 跨语言接口定义使用IDL接口定义语言如Protocol Buffersservice UserService { rpc GetUser (GetUserRequest) returns (UserResponse); rpc CreateUser (CreateUserRequest) returns (UserResponse); }20. 接口性能优化高级技巧20.1 接口方法内联优化对于高频调用的简单接口方法可以使用final类加速public final class FastComparator implements ComparatorString { Override public int compare(String a, String b) { return a.length() - b.length(); } }JVM更容易内联final类的方法调用。20.2 接口与缓存结合为接口方法添加缓存层public class CachedUserService implements UserService { private final UserService delegate; private final Cache cache; public CachedUserService(UserService delegate) { this.delegate delegate; this.cache Caffeine.newBuilder() .maximumSize(1000) .build(); } Override public User getUser(long id) { return cache.get(id, key - delegate.getUser(key)); } }21. 接口安全考量21.1 敏感操作接口设计对于敏感操作接口应添加验证public interface AdminOperation { void performOperation(Secured OperationContext context); } public interface Secured { String[] roles() default {ADMIN}; }21.2 防御性编程实践public interface DataProcessor { /** * throws IllegalArgumentException 如果data为null或空 */ void process(byte[] data); default void safeProcess(byte[] data) { if(data null || data.length 0) { return; } process(data); } }22. 接口与并发编程22.1 线程安全接口设计明确标识线程安全要求/** * 实现类必须是线程安全的 */ public interface Counter { void increment(); long get(); }22.2 异步接口设计public interface AsyncDatabase { CompletableFutureResultSet query(String sql); default void query(String sql, ConsumerResultSet callback) { query(sql).thenAccept(callback); } }23. 接口设计模式进阶23.1 装饰器模式interface Coffee { double getCost(); String getDescription(); } class SimpleCoffee implements Coffee { public double getCost() { return 1.0; } public String getDescription() { return 普通咖啡; } } abstract class CoffeeDecorator implements Coffee { protected final Coffee decoratedCoffee; public CoffeeDecorator(Coffee coffee) { this.decoratedCoffee coffee; } } class WithMilk extends CoffeeDecorator { public WithMilk(Coffee coffee) { super(coffee); } public double getCost() { return decoratedCoffee.getCost() 0.5; } public String getDescription() { return decoratedCoffee.getDescription() , 加牛奶; } }23.2 访问者模式interface ComputerPart { void accept(ComputerPartVisitor visitor); } interface ComputerPartVisitor { void visit(Keyboard keyboard); void visit(Monitor monitor); void visit(Mouse mouse); } class Keyboard implements ComputerPart { public void accept(ComputerPartVisitor visitor) { visitor.visit(this); } }24. 接口与元编程24.1 动态接口实现使用JDK动态代理interface Greeter { String greet(String name); } Greeter greeter (Greeter) Proxy.newProxyInstance( Greeter.class.getClassLoader(), new Class?[] { Greeter.class }, (proxy, method, args) - Hello, args[0] ); System.out.println(greeter.greet(World)); // 输出Hello, World24.2 接口与反射通过反射分析接口public static void analyzeInterface(Class? interfaceType) { System.out.println(接口: interfaceType.getName()); System.out.println(方法:); for(Method method : interfaceType.getMethods()) { System.out.println( method.getName() - 返回值: method.getReturnType()); } if(interfaceType.isAnnotationPresent(FunctionalInterface.class)) { System.out.println(这是一个函数式接口); } }25. 接口在领域驱动设计中的应用25.1 仓储模式接口public interface RepositoryT, ID { T findById(ID id); ListT findAll(); T save(T entity); void delete(ID id); } public interface UserRepository extends RepositoryUser, Long { OptionalUser findByEmail(String email); ListUser findByStatus(UserStatus status); }25.2 领域服务接口public interface OrderProcessingService { OrderConfirmation processOrder(Order order); void cancelOrder(Long orderId); OrderStatus checkOrderStatus(Long orderId); }26. 接口与依赖注入26.1 构造函数注入public class UserService { private final UserRepository repository; // 通过接口注入 public UserService(UserRepository repository) { this.repository repository; } }26.2 方法注入public class ReportGenerator { public void generate(OutputStream output, DataFormatter formatter) { // 使用接口实现格式化 String formatted formatter.format(getData()); output.write(formatted.getBytes()); } } interface DataFormatter { String format(Data data); }27. 接口设计工具与验证27.1 使用ArchUnit验证接口规范ArchTest public static final ArchRule interfaces_should_have_names_ending_with_able classes() .that().areInterfaces() .should().haveSimpleNameEndingWith(able) .orShould().haveSimpleNameEndingWith(Handler) .orShould().haveSimpleNameEndingWith(Service);27.2 接口设计检查清单[ ] 是否遵循单一职责原则[ ] 方法数量是否控制在合理范围通常3-10个[ ] 是否所有方法都是客户端真正需要的[ ] 命名是否准确反映接口用途[ ] 是否考虑了未来的扩展性[ ] 文档注释是否完整[ ] 是否避免了暴露实现细节28. 接口与测试替身28.1 测试桩Stub实现public class StubUserRepository implements UserRepository { private final MapLong, User users new HashMap(); Override public User findById(Long id) { return users.get(id); } // 测试专用方法 public void addUserForTest(User user) { users.put(user.getId(), user); } }28.2 模拟对象Mock验证public class OrderServiceTest { Test public void shouldSaveOrder() { // 创建mock OrderRepository mockRepo mock(OrderRepository.class); OrderService service new OrderService(mockRepo); service.placeOrder(new Order()); // 验证交互 verify(mockRepo).save(any(Order.class)); } }29. 接口与泛型结合29.1 通用CRUD接口public interface CrudRepositoryT, ID { T save(T entity); OptionalT findById(ID id); IterableT findAll(); void deleteById(ID id); boolean existsById(ID id); }29.2 类型安全的构建器interface BuilderT { T build(); } class UserBuilder implements BuilderUser { private String name; private int age; UserBuilder withName(String name) { this.name name; return this; } UserBuilder withAge(int age) { this.age age; return this; } Override public User build() { return new User(name, age); } }30. 接口设计思维训练30.1 识别抽象维度练习给定具体类提取可能接口class FileDataStore { void save(String id, byte[] data) { /*...*/ } byte[] load(String id) { /*...*/ } void delete(String id) { /*...*/ } ListString listAll() { /*...*/ } } // 可能的接口 interface DataStorage { void save(String id, byte[] data); byte[] load(String id); } interface DataManagement { void delete(String id); ListString listAll(); }30.2 接口重构案例重构前class ReportGenerator { void generatePDF(Data data) { /*...*/ } void generateHTML(Data data) { /*...*/ } void generateCSV(Data data) { /*...*/ } }重构后interface ReportFormatter { byte[] format(Data data); } class PDFFormatter implements ReportFormatter { /*...*/ } class HTMLFormatter implements ReportFormatter { /*...*/ } class CSVFormatter implements ReportFormatter { /*...*/ } class ReportGenerator { void generate(Data data, ReportFormatter formatter) { byte[] content formatter.format(data); // 输出内容 } }31. 接口与设计原则实践31.1 依赖倒置原则应用高层模块不应依赖低层模块二者都应依赖抽象// 违反DIP class ReportService { private MySQLDatabase database; public ReportService() { this.database new MySQLDatabase(); } } // 符合DIP class ReportService { private Database database; public ReportService(Database database) { this.database database; } }31.2 里氏替换原则验证子类型必须能够替换它们的基类型interface Collection { Iterator iterator(); } class List implements Collection { // 返回ListIterator也是合法的 Override public ListIterator iterator() { return new ListIterator(this); } }32. 接口与架构风格32.1 六边形架构中的端口// 左侧端口驱动端口 interface OrderController { void placeOrder(OrderDto dto); } // 右侧端口被驱动端口 interface OrderRepository { void save(Order order); }32.2 CQRS中的读写分离interface OrderQueryService { OrderDto getOrderDetails(Long id); ListOrderDto searchOrders(OrderCriteria criteria); } interface OrderCommandService { Long createOrder(OrderCreationDto dto); void cancelOrder(Long id); }33. 接口与设计文档33.1 架构决策记录中的接口## 接口设计决策 **状态**: 已采纳 **背景**: 需要统一不同支付渠道的接入方式 **决策**: 使用PaymentGateway接口抽象支付操作 **影响**: - 所有支付渠道必须实现该接口 - 客户端代码只依赖接口 - 新增支付渠道不影响现有代码33.2 UML接口表示interface Listener { onEvent() } class Button { setListener(Listener) } class MyListener { onEvent() } Button -- Listener MyListener ..| Listener34. 接口与代码生成34.1 注解处理器生成接口实现AutoService(Processor.class) public class BuilderProcessor extends AbstractProcessor { Override public boolean process(Set? extends TypeElement annotations, RoundEnvironment roundEnv) { // 生成接口实现类代码 } } GenerateBuilder interface Person { String getName(); int getAge(); }34.2 使用Lombok简化接口实现interface Person { String getName(); int getAge(); } RequiredArgsConstructor Getter class DefaultPerson implements Person { private final String name; private final int age; }35. 接口与多语言交互35.1 JNI接口设计public interface NativeOperations { void nativeSetup(); int nativeCompute(int input); void nativeCleanup(); } class NativeImpl implements NativeOperations { static { System.loadLibrary(native); } public native void nativeSetup(); public native int nativeCompute(int input); public native void nativeCleanup(); }35.2 WebAssembly接口interface WasmModule { Object invoke(String functionName, Object... args); void release(); } class MyWasmModule implements WasmModule, AutoCloseable { // 实现... Override public void close() { release(); } }36. 接口设计心理学36.1 最小惊喜原则接口设计应避免让使用者感到意外方法名准确反映行为参数顺序符合惯例异常抛出明确文档化返回值类型直观合理36.2 认知负荷控制好的接口设计应考虑单个接口方法数控制在7±2个人类短期记忆限制嵌套接口层级不超过3层相关接口集中定义避免过度抽象37. 接口与编译器优化37.1 接口方法内联条件JVM会内联接口方法当实现类唯一非多态方法调用频率超过阈值方法体足够简单37.2 接口调用性能测试interface Operation { int compute(int a, int b); } class Add implements Operation { public int compute(int a, int b) { return a