接口增强：private 方法（JDK 9）

飞翔科技技术分享会上，孔蓝展示了一段接口代码。

public interface Loggable {
    default void logInfo(String msg) {
        System.out.println("[INFO] " + timestamp() + " " + msg);
    }
    default void logError(String msg) {
        System.out.println("[ERROR] " + timestamp() + " " + msg);
    }
    // timestamp() 被迫设为 public，万一被人从外部调用呢？
    static String timestamp() {
        return LocalDateTime.now().toString();
    }
}

白歌立刻指出了问题："timestamp() 被暴露为公开 API，任何实现类都能直接调用。万一未来你想改时间格式，改了就是 Breaking Change。"

小崔插话："那用抽象类不就行了？"

大翔摇头："但 Loggable 的功能需要被多个不相关的类实现，Java 只能单继承，用抽象类就把继承位给占了。"

白歌笑道："这就是 JDK 9 接口 private 方法诞生的原因——既有接口的多实现灵活性，又有抽象类的代码复用能力。"

定义表

概念JDK 版本可见性功能能否被实现类调用
接口抽象方法JDK 1.0public定义接口契约，由实现类提供✅ 必须实现
接口 default 方法JDK 8public提供默认实现，实现类可覆盖✅ 可继承
接口 static 方法JDK 8public接口级别的工具方法✅ 通过接口名调用
接口 private 方法JDK 9private为 default/static 方法提供内部代码复用❌ 对实现类不可见
接口 private static 方法JDK 9private static为 static 方法提供内部代码复用❌ 对实现类不可见

Mermaid 类图：接口方法可见性层次

Mermaid 时序图：default 方法调用 private 方法

为什么需要接口 private 方法

4.1 JDK 8 的尴尬：default 方法间的代码重复

// === JDK 8 时代：只能靠抽取 static 方法，但被迫暴露为 public ===
interface ReportGeneratorJDK8 {
    // 两个 default 方法有共同的格式化逻辑
    default void generateHTML(String title, String content) {
        // 重复代码块 ↓
        String formattedTitle = "<h1>" + title.toUpperCase() + "</h1>";
        String formattedContent = content.replace("\n", "<br>");
        // 重复代码块 ↑
        System.out.println(formattedTitle + formattedContent);
    }

    default void generatePDF(String title, String content) {
        // 重复代码块 ↓ (和上面完全一样！)
        String formattedTitle = "[PDF] " + title.toUpperCase();
        String formattedContent = content.replace("\n", " ");
        // 重复代码块 ↑
        System.out.println(formattedTitle + "\n---\n" + formattedContent);
    }

    // 如果要抽取，只能暴露为 public static —— 污染接口 API
    // public static String formatTitle(String title) { ... }
}

4.2 JDK 9 的解决方案：private 方法消除重复

// === JDK 9：private 方法封装公共逻辑 ===
interface ReportGeneratorJDK9 {
    default void generateHTML(String title, String content) {
        String formatted = formatReport("HTML", title, content);
        System.out.println(formatted);
    }

    default void generatePDF(String title, String content) {
        String formatted = formatReport("PDF", title, content);
        System.out.println(formatted);
    }

    // 私有实例方法：default 方法间的公共逻辑
    private String formatReport(String type, String title, String content) {
        String formattedTitle = "[" + type + "] " + title.toUpperCase();
        String formattedContent = type.equals("HTML")
                ? content.replace("\n", "<br>")
                : content.replace("\n", " ");
        return formattedTitle + "\n---\n" + formattedContent;
    }
}

// === 使用示例 ===
class EmployeeReport implements ReportGeneratorJDK9 { }

public class PrivateMethodDemo {
    public static void main(String[] args) {
        ReportGeneratorJDK9 report = new EmployeeReport();

        System.out.println("=== HTML 报告 ===");
        report.generateHTML("Q2业绩汇报", "营收增长20%\n成本下降5%");

        System.out.println("\n=== PDF 报告 ===");
        report.generatePDF("Q2业绩汇报", "营收增长20%\n成本下降5%");
    }
}

输出：

=== HTML 报告 ===
[HTML] Q2业绩汇报
---
营收增长20%<br>成本下降5%

=== PDF 报告 ===
[PDF] Q2业绩汇报
---
营收增长20% 成本下降5%

private static 方法 — 静态方法的代码复用

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

// === 飞翔科技日志接口 ===
interface Loggable {
    // 公开的 default 方法
    default void logInfo(String msg) {
        System.out.println(formatLog("INFO", msg));
    }

    default void logWarn(String msg) {
        System.out.println(formatLog("WARN", msg));
    }

    default void logError(String msg) {
        System.out.println(formatLog("ERROR", msg));
    }

    // 公开的 static 方法
    static String getSystemStatus() {
        return buildStatus("RUNNING", getCurrentMemory());
    }

    // ====== private 方法：不外露 ======

    // private 实例方法：供 default 方法调用
    private String formatLog(String level, String msg) {
        return String.format("[%s] %s - %s",
            getCurrentTimestamp(), level, msg);
    }

    // private static 方法：供 static 方法调用
    private static String buildStatus(String status, String memory) {
        return "System{" +
               "status='" + status + '\'' +
               ", memory='" + memory + '\'' +
               ", timestamp='" + getCurrentTimestamp() + '\'' +
               '}';
    }

    private static String getCurrentTimestamp() {
        return LocalDateTime.now()
                .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    private static String getCurrentMemory() {
        Runtime runtime = Runtime.getRuntime();
        long used = runtime.totalMemory() - runtime.freeMemory();
        return (used / 1024 / 1024) + "MB";
    }
}

class Server implements Loggable { }

public class PrivateStaticDemo {
    public static void main(String[] args) {
        Server server = new Server();

        server.logInfo("飞翔科技服务器启动");
        server.logWarn("内存使用率超过80%");
        server.logError("数据库连接超时，正在重试...");

        System.out.println("\n=== 系统状态 ===");
        System.out.println(Loggable.getSystemStatus());

        // ❌ 以下调用全部编译错误 —— private 方法不可见
        // server.formatLog("TEST", "msg");
        // Loggable.getCurrentTimestamp();
        // Loggable.buildStatus("OK", "128MB");
    }
}

输出：

[2026-06-14 10:30:15] INFO - 飞翔科技服务器启动
[2026-06-14 10:30:15] WARN - 内存使用率超过80%
[2026-06-14 10:30:15] ERROR - 数据库连接超时，正在重试...

=== 系统状态 ===
System{status='RUNNING', memory='8MB', timestamp='2026-06-14 10:30:15'}

接口 private 方法 vs 抽象类 protected 方法

// === 设计对比：private 方法无法被子接口/实现类调用 ===
interface PaymentProcessor {
    default void process(double amount) {
        validate(amount);        // 调用 private 验证方法
        executePayment(amount);
        logTransaction(amount);
    }

    // 抽象方法：子类必须实现
    void executePayment(double amount);

    // private → 对实现类完全不可见
    private void validate(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("金额必须大于0");
        }
        if (amount > 100000) {
            throw new IllegalArgumentException("单笔交易上限10万");
        }
    }

    private void logTransaction(double amount) {
        System.out.println("[交易日志] 金额: ¥" + amount +
                " | 时间: " + java.time.LocalDateTime.now());
    }
}

// 实现类：只关心业务逻辑，验证和日志由接口统一处理
class WechatPay implements PaymentProcessor {
    @Override
    public void executePayment(double amount) {
        System.out.println("微信支付处理中: ¥" + amount);
        // 无法访问 validate() 和 logTransaction() —— 这正是我们想要的！
    }
}

class Alipay implements PaymentProcessor {
    @Override
    public void executePayment(double amount) {
        System.out.println("支付宝支付处理中: ¥" + amount);
    }
}

public class PaymentDemo {
    public static void main(String[] args) {
        PaymentProcessor wechat = new WechatPay();
        PaymentProcessor alipay = new Alipay();

        System.out.println("=== 微信支付 ===");
        wechat.process(299.99);

        System.out.println("\n=== 支付宝支付 ===");
        alipay.process(5000.00);

        System.out.println("\n=== 异常测试 ===");
        try {
            wechat.process(-100);
        } catch (IllegalArgumentException e) {
            System.out.println("❌ " + e.getMessage());
        }
    }
}

输出：

=== 微信支付 ===
微信支付处理中: ¥299.99
[交易日志] 金额: ¥299.99 | 时间: 2026-06-14T10:30:15.123

=== 支付宝支付 ===
支付宝支付处理中: ¥5000.0
[交易日志] 金额: ¥5000.0 | 时间: 2026-06-14T10:30:15.125

=== 异常测试 ===
❌ 金额必须大于0

易错场景

7.1 private 方法不能被 default 方法覆盖

interface Base {
    private String helper() {
        return "Base.helper()";
    }
    default String execute() {
        return helper();
    }
}

interface Child extends Base {
    // ❌ 这不是覆盖 —— private 方法对子接口不可见
    // private String helper() {
    //     return "Child.helper()";
    // }
    // 上面的代码会编译通过，但它是 Child 自己的新方法，与 Base.helper() 无关

    // ✅ 正确：只能覆盖 default 方法
    @Override
    default String execute() {
        return "Child.execute()";
    }
}

7.2 private 方法与 abstract 方法不能混淆

interface InvalidDesign {
    // ❌ private 方法不能是 abstract —— private 方法必须有实现体
    // private abstract void helper();

    // ❌ private 方法不能是 default —— private 本身就隐含 final
    // private default void helper() { }

    // ✅ 正确
    private void helper() {
        System.out.println("私有辅助方法");
    }
}

面试考点

问题一："JDK 9 为什么引入接口 private 方法？"

核心原因是消除 default 方法和 static 方法之间的代码重复。JDK 8 允许接口有 default 和 static 方法，但多个 default 方法之间有公共逻辑时只能抽取为 public static 或 public default 方法，暴露了不必要的 API。private 方法让接口可以在不污染公开 API 的前提下实现内部代码复用。

问题二："接口 private 方法能被实现类覆盖（override）吗？"

不能。private 方法对实现类和子接口完全不可见，因此不存在覆盖的概念。这与类的 private 方法不会被继承的道理一致。

问题三："接口的 private 方法和抽象类的 protected 方法，在设计上如何选择？"

关键区别在于：接口的 private 方法无法被子类调用或覆盖，适合需要严格封装且不暴露内部实现细节的场景（如验证逻辑、日志格式）；抽象类的 protected 方法允许子类调用和覆盖，适合需要扩展点的模板方法模式。如果你的代码复用逻辑需要被子类参与，用抽象类；如果只是内部消除重复，用接口 private 方法。

白歌更新了飞翔科技的编码规范，新增了一条关于接口设计的：

"接口的 default 方法超过 5 行时，应检查是否有重复逻辑可以抽取为 private 方法。接口不应暴露超过实现类需要知道的 API——private 方法就是你的'内部工具箱'。"