请讲解Java中的Factory Pattern等四种设计模式

1. 工厂模式（Factory Pattern） #

工厂模式属于创建型设计模式，核心是封装对象的创建逻辑，让调用方无需依赖具体实现类，只通过工厂接口/类获取实例，降低代码耦合度。

两种常见实现： #

简单工厂（Simple Factory）

不属于GoF正式定义的设计模式，但实际开发中广泛使用，适合创建逻辑简单的场景：

// 产品接口
interface Shape {
    void draw();
}

// 具体产品类
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制正方形");
    }
}

// 简单工厂类
class ShapeFactory {
    public static Shape getShape(String type) {
        return switch (type.toLowerCase()) {
            case "circle" -> new Circle();
            case "square" -> new Square();
            default -> throw new IllegalArgumentException("不支持的形状类型");
        };
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("circle");
        circle.draw();
    }
}

工厂方法（Factory Method）

定义一个创建对象的接口，让子类决定实例化哪个类，将对象创建逻辑延迟到子类实现：

// 抽象工厂接口
interface ShapeFactory {
    Shape createShape();
}

// 具体工厂类
class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        ShapeFactory factory = new CircleFactory();
        Shape shape = factory.createShape();
        shape.draw();
    }
}

2. 抽象工厂模式（Abstract Factory Pattern） #

抽象工厂是工厂模式的扩展，用于创建一系列相关或相互依赖的对象族，客户端无需关心具体产品的实现细节，只需要指定对应的工厂即可获取整套配套产品。

示例：跨平台UI组件创建 #

// 抽象产品：按钮
interface Button {
    void render();
}

// 抽象产品：复选框
interface Checkbox {
    void check();
}

// Windows风格具体产品
class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染Windows风格按钮");
    }
}

class WindowsCheckbox implements Checkbox {
    @Override
    public void check() {
        System.out.println("选中Windows风格复选框");
    }
}

// Mac风格具体产品
class MacButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染Mac风格按钮");
    }
}

class MacCheckbox implements Checkbox {
    @Override
    public void check() {
        System.out.println("选中Mac风格复选框");
    }
}

// 抽象工厂接口
interface UIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// Windows风格工厂
class WindowsUIFactory implements UIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

// Mac风格工厂
class MacUIFactory implements UIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        UIFactory factory = new WindowsUIFactory();
        Button button = factory.createButton();
        Checkbox checkbox = factory.createCheckbox();
        
        button.render();
        checkbox.check();
    }
}

3. 单例模式（Singleton Pattern） #

确保一个类全局只有一个实例，并提供统一的全局访问点，常用于日志组件、数据库连接池、配置中心等场景。

几种可靠实现： #

饿汉式（Eager Initialization）

类加载阶段就创建实例，天然线程安全，但可能提前占用内存：

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    private EagerSingleton() {}

    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

双重检查锁（Double-Checked Locking）

延迟加载+线程安全，需用volatile禁止指令重排：

public class DCLSingleton {
    private static volatile DCLSingleton INSTANCE;

    private DCLSingleton() {}

    public static DCLSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (DCLSingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DCLSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

静态内部类（Static Inner Class）

利用类加载机制实现延迟加载和线程安全，性能最优：

public class InnerClassSingleton {
    private InnerClassSingleton() {}

    private static class SingletonHolder {
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }

    public static InnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

枚举实现（Enum Singleton）

最简洁、线程安全且能防止序列化/反射破坏的实现：

public enum EnumSingleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("单例实例执行操作");
    }
}

// 调用方式：EnumSingleton.INSTANCE.doSomething();

4. 建造者模式（Builder Pattern） #

用于构建多参数、复杂对象，将对象的构建过程与最终表示分离，允许逐步配置不同参数，避免构造函数参数过多导致的代码可读性问题。

示例：用户对象构建 #

public class User {
    // 必填参数
    private final String username;
    private final String email;
    // 可选参数
    private final Integer age;
    private final String phone;
    private final String address;

    // 私有构造，仅由Builder调用
    private User(Builder builder) {
        this.username = builder.username;
        this.email = builder.email;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    // 静态内部Builder类
    public static class Builder {
        // 必填参数
        private final String username;
        private final String email;
        // 可选参数，默认值为null
        private Integer age;
        private String phone;
        private String address;

        // Builder构造方法，传入必填参数
        public Builder(String username, String email) {
            this.username = username;
            this.email = email;
        }

        // 链式设置可选参数
        public Builder age(Integer age) {
            this.age = age;
            return this;
        }

        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        // 构建并返回User实例
        public User build() {
            return new User(this);
        }
    }

    // Getter方法
    public String getUsername() { return username; }
    public String getEmail() { return email; }
    public Integer getAge() { return age; }
    public String getPhone() { return phone; }
    public String getAddress() { return address; }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        User user = new User.Builder("john_doe", "john@example.com")
                .age(28)
                .phone("1234567890")
                .address("123 Main St")
                .build();
    }
}

内容的提问来源于stack exchange，提问作者Navod Kamilka