为什么阿里开发手册推荐用静态工厂方法代替构造器？

最新推荐文章于 2025-01-13 11:10:40 发布

原创最新推荐文章于 2025-01-13 11:10:40 发布 · 1.4k 阅读

45 ·

CC 4.0 BY-SA版权

本文为博主原创文章，未经博主允许不得转载。

文章标签：

#java #开发语言 #静态工厂方法 #构造器

搬砖工逆袭Java架构师专栏收录该内容

543 篇文章

订阅专栏

在这里插入图片描述

🍅 作者简介：哪吒，优快云2021博客之星亚军🏆、新星计划导师✌、博客专家💪

🍅 哪吒多年工作总结：Java学习路线总结，搬砖工逆袭Java架构师

🍅 技术交流：定期更新Java硬核干货，不定期送书活动

🍅 关注公众号【哪吒编程】，回复 1024 ，获取《10万字208道Java经典面试题总结(附答案)》2024修订版pdf，背题更方便，一文在手，面试我有

一、构造函数的问题

当类有多个构造器时，静态工厂方法可以通过有意义的名称来区分不同的创建方式，使代码更易读。

有的杠精可能要说话了：通过改变参数列表中参数类型的顺序或个数，我就可以提供多个不同的构造器，有什么问题吗？

我想说的是，你这样并不符合编码规范，有如下几个问题：

1、方法名都是一个，容易混淆

编码规约规定，方法名称见名知意，你TMD都是一个名，搞笑呢？

如果某人看到new Person(“John”, 25)或new Person(25, “John”)，他可能会混淆它们的作用，尤其是当参数数量和类型相同而顺序不同的时候。

public class Person {
    private String name;
    private int age;
    private boolean isEmployed;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.isEmployed = false; // 默认值
    }

    public Person(String name, boolean isEmployed) {
        this.name = name;
        this.age = 0; // 默认值
        this.isEmployed = isEmployed;
    }

    public Person(int age, String name) {
        this.name = name;
        this.age = age;
        this.isEmployed = false; // 默认值
    }
}

参数相同，顺序不同，谁是谁，你记得住吗？

参数顺序不同的构造器可能导致调用时不小心传入了错误顺序的参数，结果得到一个非预期的对象。

如果顺序被搞错，编译器不会报错，但会导致运行时的逻辑错误。

Person person = new Person("John", 25);  // 想调用第一个构造器
Person person2 = new Person(25, "John"); // 想调用第三个构造器，结果参数位置错误，产生错误的数据

2、扩展性问题

当你需要扩展类并添加更多构造器时，如果通过改变参数顺序和数量来实现重载，可能会迅速导致构造器的组合方式爆炸，难以维护，估计连你自己都看不明白了。

这谁写的代码？拉出去砍了。

现在裁员盛行，你要小心了。

3、构造函数每次被调用都要创建一个新对象

这能有什么问题？这不都是Java中默认的嘛，每当你使用 new 关键字调用一个类的构造函数时，都会创建一个对象实例。

创建新对象涉及分配内存和初始化对象，这在性能上有一定开销。如果在短时间内需要频繁创建和销毁大量对象，这种开销可能会显著影响系统性能。

构造函数的每次调用都创建新对象，也会使对象的缓存和复用变得困难。

在数据库连接池中，我们希望复用已经存在的连接，而不是每次都创建一个新连接，这时构造函数的行为就显得不合适。

二、静态工厂方法如何解决构造器的问题呢？

问题1：方法名都是一个，容易混淆

静态工厂方法可以通过有意义的命名来避免这种混淆，见名知意。

这是静态工厂方法的一个重要优势。不同于构造函数必须与类名相同，静态工厂方法可以根据其创建对象的逻辑和用途使用不同的名称，从而提高代码的可读性和明确性。

通过静态工厂方法，如createChild、createEmployedAdult和createUnemployedAdult，你可以清晰地表达每个方法的用途，避免了通过构造器参数类型来区分的混淆问题。每个方法的名字直接说明了创建对象的用途，提升了代码的可读性。

改进后的代码：

public class Person {
    private String name;
    private int age;
    private boolean isEmployed;

    // 私有构造器，防止直接实例化
    private Person(String name, int age, boolean isEmployed) {
        this.name = name;
        this.age = age;
        this.isEmployed = isEmployed;
    }

    // 静态工厂方法，解决方法名混淆问题
    public static Person createChild(String name) {
        return new Person(name, 0, false); // 默认年龄为0，未就业
    }

    public static Person createEmployedAdult(String name, int age) {
        return new Person(name, age, true); // 成人，已就业
    }

    public static Person createUnemployedAdult(String name, int age) {
        return new Person(name, age, false); // 成人，未就业
    }
}

问题2：扩展性问题

静态工厂方法可以通过添加新的方法来扩展对象创建的方式，从而提高代码的扩展性。

假如需要增加新的构造方式（如裁员人员），你可以轻松地通过添加createRetiredPerson静态工厂方法来实现，而无需更改现有的构造函数或担心重载导致的代码复杂化。静态工厂方法的扩展性使得代码更容易维护和增强。

// 新增静态工厂方法，支持扩展需求
public static Person createLayoffPerson(String name) {
    return new Person(name, 35, true); // 默认35岁，在职
}

问题3：构造函数每次被调用都要创建一个新对象

静态工厂方法可以通过缓存对象、实现单例模式或其他优化策略，避免每次都创建新对象，从而提升性能和资源利用效率。

public class Person {
    private String name;
    private int age;
    private boolean isEmployed;

    private static final Person DEFAULT_CHILD_INSTANCE = new Person("Default Child", 0, false);

    // 私有构造器
    private Person(String name, int age, boolean isEmployed) {
        this.name = name;
        this.age = age;
        this.isEmployed = isEmployed;
    }

    // 使用缓存的实例，避免每次都创建新对象
    public static Person getDefaultChildInstance() {
        return DEFAULT_CHILD_INSTANCE;
    }

    // 其他静态工厂方法
    ...
}

对于重复多次的调用，静态工厂方法可以返回同一个对象，这就可以控制存在哪些实例，被称为实例受控。

三、实例受控

遇到生僻词汇，哪吒的第一反应就是问问ChatGPT。

import java.util.HashMap;
import java.util.Map;

public class Person {
    private String name;
    private int age;
    private boolean isEmployed;

    // 用于存储创建的实例
    private static final Map<String, Person> instances = new HashMap<>();

    // 私有构造器，防止直接实例化
    private Person(String name, int age, boolean isEmployed) {
        this.name = name;
        this.age = age;
        this.isEmployed = isEmployed;
    }

    // 静态工厂方法，解决方法名混淆问题，并实现实例受控
    public static Person createChild(String name) {
        String key = name + ":child";
        if (!instances.containsKey(key)) {
            instances.put(key, new Person(name, 0, false));
        }
        return instances.get(key);
    }

    public static Person createEmployedAdult(String name, int age) {
        String key = name + ":employed:" + age;
        if (!instances.containsKey(key)) {
            instances.put(key, new Person(name, age, true));
        }
        return instances.get(key);
    }

    public static Person createUnemployedAdult(String name, int age) {
        String key = name + ":unemployed:" + age;
        if (!instances.containsKey(key)) {
            instances.put(key, new Person(name, age, false));
        }
        return instances.get(key);
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", isEmployed=" + isEmployed + "}";
    }
}

结合代码示例，ChatGPT4o解释说明实例受控是什么？

通过静态工厂方法和实例缓存机制，你可以在重复调用时返回同一个对象，从而实现实例受控。这种设计可以精确控制一个类的实例数量，避免内存浪费，提高性能，同时提供了更好的代码管理和扩展性。

四、静态工厂方法可以返回任何子类型的对象

静态工厂方法可以返回Person类的任意子类型对象，而不仅限于返回Person本身。这种设计使得代码更具扩展性和灵活性。

通过静态工厂方法，子类的具体实现对外部是透明的。外部调用者不需要知道这些子类的存在或如何实现，只需通过工厂方法获取所需的对象。这种设计增强了封装性，方便后续扩展。

这种灵活性使得静态工厂方法比构造器更有优势，特别是在实现设计模式（如工厂模式、单例模式、享元模式）时。

我们创建几个Person类的子类，Child、EmployedAdult、UnemployedAdult。

每个子类代表不同类型的Person，具有特定的行为和属性。

例如，Child类的age默认设为0，isEmployed设为false，表示未就业；EmployedAdult和UnemployedAdult分别表示不同就业状态的成年人。

通过静态工厂方法分别创建并返回不同子类的实例，它们隐藏了子类的具体实现，调用者只需要通过这些方法创建对象，不需要知道具体的子类结构。

五、Java 8中允许接口包含静态方法了，和静态工厂方法有关系吗？

1、接口与静态方法

我觉得这一变革多少和静态工厂方法的使用有一定的关系，它提供了接口设计更大的灵活性和功能性。

在java 8之前，实用工具方法通常定义在单独的工具类中（例如Collections或Arrays），而不是直接在接口中。这导致了一些不便，比如工具类不能直接访问接口的内部细节。

允许接口包含静态方法，使接口本身能够提供多样化的对象创建逻辑，这种灵活性是传统构造器所无法提供的。

例如，你可以在接口中定义一个静态工厂方法来返回该接口的某个实现类的实例，这样做简化了客户端代码的使用，也隐藏了实现的细节。

public interface Person {
    String getName();
    int getAge();

    static Person create(String name, int age) {
        return new PersonImpl(name, age);  // 返回接口的实现类实例
    }
}

// 私有实现类
class PersonImpl implements Person {
    private final String name;
    private final int age;

    private PersonImpl(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public int getAge() {
        return age;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Person person = Person.create("哪吒", 30);
        System.out.println(person.getName() + " is " + person.getAge() + " years old.");
    }
}

2、与默认方法结合使用

Java 8还引入了默认方法，允许接口在提供方法签名的同时也提供默认实现。默认方法与静态方法结合，使得接口不仅可以提供默认行为，还可以提供创建实例的方法和相关工具。

这使得接口可以拥有类似于抽象类的功能，而无需引入多继承的复杂性。

3、支持函数式接口

Java 8引入了函数式接口的概念，特别是在Lambda表达式和方法引用中被广泛使用。静态方法可以用来提供工厂方法或其他辅助方法，支持和增强函数式接口的使用。

例如，在Comparator接口中，静态方法comparing是一个静态工厂方法，用于创建比较器，这在函数式编程中非常有用。

六、Java9中支持私有的静态方法，但静态字段必须是公有的

1、为什么Java9中支持私有的静态方法

（1）实现代码重用和封装

Java 9中支持私有的静态方法是为了增强代码的封装性和重用性，特别是在使用静态工厂方法代替构造器的场景中，私有静态方法可以帮助我们更好地组织和管理对象创建的复杂逻辑。

在这个例子中，validateName和validateAge是私有的静态方法，它们封装了对象创建时的验证逻辑。这些方法只在接口内部使用，并不会暴露给接口的使用者。这种设计提高了代码的复用性和封装性，同时使得静态工厂方法的实现更加简洁。

public interface Person {
    String getName();
    int getAge();

    static Person createChild(String name) {
        validateName(name);
        return new Child(name);
    }

    static Person createEmployedAdult(String name, int age) {
        validateName(name);
        validateAge(age);
        return new EmployedAdult(name, age);
    }

    // 私有静态方法，供内部逻辑使用
    private static void validateName(String name) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Name cannot be null or empty");
        }
    }

    private static void validateAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Age must be at least 18");
        }
    }
}