Java Academy · 课时

工具类与静态工厂方法

Q: 「工具类与静态工厂方法」这节课中我会学到什么？

设计不可实例化的工具类，并提供静态工厂方法作为构造方法的替代方案 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

设计不可实例化的工具类，并提供静态工厂方法作为构造方法的替代方案

工具类与静态工厂方法 是 CoddyKit 上的免费 Java Academy 课时。这是第 4 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

工具类与静态工厂方法

工具类提供没有实例状态的静态辅助方法。静态工厂方法是构造方法的命名替代方案，可提高可读性，并支持缓存和更大的灵活性。

工具类

工具类没有实例状态，只是静态方法的容器。请通过声明私有构造方法使其不可实例化。

final class StringUtils {
    // Private constructor prevents instantiation
    private StringUtils() {
        throw new UnsupportedOperationException("Utility class");
    }

    public static boolean isBlank(String s) {
        return s == null || s.strip().isEmpty();
    }

    public static String capitalize(String s) {
        if (isBlank(s)) return s;
        return Character.toUpperCase(s.charAt(0)) + s.substring(1).toLowerCase();
    }
}

System.out.println(StringUtils.isBlank("  ")); // true
System.out.println(StringUtils.capitalize("hELLO")); // Hello

标准库工具类

Java 标准库中有许多工具类：集合、数组、对象、文件、路径和数学工具。

import java.util.*;

List<Integer> nums = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9, 3));

Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

System.out.println(Collections.min(nums)); // 1
System.out.println(Collections.max(nums)); // 9

Collections.shuffle(nums); // random order

int[] arr = {3, 1, 4, 1, 5};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 1, 3, 4, 5]
System.out.println(Arrays.binarySearch(arr, 4)); // 3 (index)

静态工厂方法

静态工厂方法是一种具有明确名称的静态方法，用于创建并返回实例。优点包括：名称更具描述性，可以返回缓存实例或子类型实例，也可以返回空值。

class Connection {
    private final String host;
    private final int port;
    private final boolean ssl;

    private Connection(String host, int port, boolean ssl) {
        this.host = host; this.port = port; this.ssl = ssl;
    }

    // Named factory methods — more expressive than constructors
    public static Connection plain(String host) {
        return new Connection(host, 80, false);
    }
    public static Connection secure(String host) {
        return new Connection(host, 443, true);
    }
}
Connection c = Connection.secure("api.example.com");
// Much clearer than: new Connection("api.example.com", 443, true)

使用静态工厂进行缓存

静态工厂可以返回缓存的实例，避免为常用值重复分配对象（例如 Integer.valueOf 会为 -128..127 范围内的值执行此操作）。

class Color {
    private static final Map<String, Color> CACHE = new HashMap<>();

    public final int r, g, b;

    private Color(int r, int g, int b) {
        this.r = r; this.g = g; this.b = b;
    }

    public static Color of(int r, int g, int b) {
        String key = r + "," + g + "," + b;
        return CACHE.computeIfAbsent(key, k -> new Color(r, g, b));
    }

    public static final Color RED   = of(255, 0, 0);
    public static final Color GREEN = of(0, 255, 0);
    public static final Color BLUE  = of(0, 0, 255);
}
System.out.println(Color.of(255,0,0) == Color.RED); // true (cached)

工厂方法与构造方法：命名

静态工厂方法的常见命名约定：

of——聚合工厂
from——转换工厂
valueOf——转换工厂（较早的 API）
getInstance——单例
创建方法或 newInstance——新建对象
get——灵活用途

// Java API examples:
Optional.of(value)               // of
LocalDate.from(temporal)         // from
Integer.valueOf(42)              // valueOf
Calendar.getInstance()           // getInstance
Array.newInstance(type, length)  // newInstance

// Your own:
HttpRequest.post("https://api.example.com/users")
ApiResponse.error(404, "Not found")
Payment.creditCard("4242...", 9999, "USD")

返回子类型

工厂方法可以返回一个子类型，而声明的返回类型是接口。这样，调用方就不会与具体实现耦合。

interface Validator<T> {
    boolean validate(T value);
    String errorMessage();
}

class EmailValidator implements Validator<String> {
    public boolean validate(String email) { return email.contains("@"); }
    public String errorMessage() { return "Invalid email address"; }
}

class Validators {
    // Returns interface type — hides implementation
    public static Validator<String> email() { return new EmailValidator(); }
    public static Validator<String> notBlank() {
        return new Validator<>() {
            public boolean validate(String s) { return s != null && !s.isBlank(); }
            public String errorMessage() { return "Value required"; }
        };
    }
}

通过静态工厂使用构建器

将私有构造方法、静态工厂和嵌套的 Builder 结合起来，以构建复杂对象。

class EmailMessage {
    private final String to, subject, body;
    private final boolean html;

    private EmailMessage(Builder b) {
        this.to = b.to; this.subject = b.subject;
        this.body = b.body; this.html = b.html;
    }

    public static Builder builder(String to) { return new Builder(to); }

    public static class Builder {
        private final String to;
        private String subject = "", body = "";
        private boolean html = false;

        Builder(String to) { this.to = to; }
        public Builder subject(String s) { this.subject = s; return this; }
        public Builder body(String b) { this.body = b; return this; }
        public Builder html() { this.html = true; return this; }
        public EmailMessage build() { return new EmailMessage(this); }
    }
}
EmailMessage.builder("alice@co.com").subject("Welcome!").html().build();

在工厂方法中进行验证

工厂方法非常适合在构造对象之前验证输入，并根据上下文抛出有意义的异常。

class PortNumber {
    private final int value;

    private PortNumber(int value) { this.value = value; }

    public static PortNumber of(int port) {
        if (port < 1 || port > 65535)
            throw new IllegalArgumentException(
                "Port must be 1-65535, got: " + port);
        return new PortNumber(port);
    }

    public static PortNumber http()  { return new PortNumber(80); }
    public static PortNumber https() { return new PortNumber(443); }

    public int value() { return value; }
    public boolean isPrivileged() { return value < 1024; }
}
System.out.println(PortNumber.https().isPrivileged()); // true

集合接口：静态工厂

Java 9 及更高版本新增了 List.of()、Set.of() 和 Map.of()，这些静态工厂方法用于创建不可变集合。

import java.util.*;

List<String> fruits = List.of("Apple", "Banana", "Cherry");
Set<Integer> ids    = Set.of(1, 2, 3, 4, 5);
Map<String, Integer> ages = Map.of("Alice", 30, "Bob", 25);

// All are unmodifiable:
try {
    fruits.add("Durian"); // UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Cannot modify!");
}

// Map.entry and Map.ofEntries for > 10 entries
Map<String, String> config = Map.ofEntries(
    Map.entry("host", "localhost"),
    Map.entry("port", "8080")
);

应优先使用工厂方法的情况

在以下情况下，应优先选择静态工厂方法而不是构造方法：

您希望使用具有描述性的名称
工厂可能返回缓存实例或子类型实例
需要在构造对象之前进行验证
您希望控制实例数量（单例或对象池）

// Constructor: hard to know what this means
new Complex(0.5, -1.2);

// Factory: clear meaning
Complex.fromPolar(1.3, Math.PI / 4); // polar form
Complex.rectangular(0.5, -1.2);      // rectangular form

// Constructor: no caching
new Boolean(true); // deprecated — creates new object!

// Factory: returns cached instance (Boolean.TRUE or FALSE)
Boolean.valueOf(true); // returns Boolean.TRUE singleton

快速检查

与公共构造方法相比，静态工厂方法的主要优势是什么？

回顾：工具类与静态工厂方法

要点：

工具类：使用私有构造方法的不可继承类，且所有方法均为静态方法
静态工厂方法是构造方法的命名替代方案
常见命名包括 of、from、valueOf、getInstance、创建和 newInstance
工厂可以返回缓存实例——参见 Integer.valueOf(-128..127)
工厂可以返回子类型，同时隐藏具体实现
对于复杂的多参数构造，请在工厂内部使用构建器

常见问题解答

「工具类与静态工厂方法」课时是免费的吗？

是的 — 「工具类与静态工厂方法」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「工具类与静态工厂方法」这节课中我会学到什么？

设计不可实例化的工具类，并提供静态工厂方法作为构造方法的替代方案你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 4 节课，共 4 节。

「工具类与静态工厂方法」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Java Academy