设计模式#

简单工厂#

是工厂方法模式的一种特殊实现，又称为静态工厂方法模式

有三个角色：抽象产品，具体产品，工厂类

具体产品

public class Fighter extends Weapon{
    @Override
    public void attack() {
        System.out.println("飞机攻击");
    }
}

public class Tank extends Weapon{
    @Override
    public void attack() {
        System.out.println("坦克攻击");
    }
}

抽象产品

public abstract class Weapon {
    public abstract void attack();
}

工厂类

public class WeaponFactory {
    public static Weapon get(String weaponType) {
        if ("Tank".equals(weaponType)) {
            return new Tank();
        } else if ("Fighter".equals(weaponType)) {
            return new Fighter();
        } else {
            System.out.println("创建失败");
            return null;
        }
    }
}

测试程序

public class Test {
    public static void main(String[] args) {
        Weapon tank = WeaponFactory.get("Tank");
        if (tank != null) {
            tank.attack();
        }
    }
}

优点：

客户只负责消费，工厂类负责生产，生产者和消费者分离，客户端不需要关注实现细节，只负责传入索要即可使用

缺点：

增加工厂产品，需要修改工厂类代码，违反OCP原则，另外工厂的责任大，发生问题的时候系统瘫痪，健壮性差

工厂方法模式#

一个产品对应一个工厂

解决了简单工厂模式中出现的OCP问题

有四个角色：抽象产品，具体产品（多个），抽象工厂类，具体工厂类（多个）

抽象工厂

public abstract class WeaponFactory {
    public abstract Weapon get();
}

具体工厂

public class TankFactory extends WeaponFactory{
    @Override
    public Weapon get() {
        return new Tank();
    }
}

测试程序

public class Test {
    public static void main(String[] args) {
        WeaponFactory factory = new TankFactory();
        Weapon tank = factory.get();
        tank.attack();
    }
}

添加新的产品的时候，只需要增加Weapon的实现类，以及对应武器的工厂实现类即可在不影响原有代码的基础上，通过对应的具体工厂创建武器的实例

缺点：类的复杂性增加，类的数量大

抽象工厂#

抽象工厂提供了一系列相关或相互依赖对象的接口

定义按钮和文本框的通用接口

interface Button {
    void render();
    void onClick();
}

interface TextBox {
    void render();
    void input(String text);
}

实现具体产品，例如Windows风格的按钮和文本框

class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("Windows 风格按钮渲染");
    }
    @Override
    public void onClick() {
        System.out.println("Windows 按钮点击");
    }
}

class WindowsTextBox implements TextBox {
    @Override
    public void render() {
        System.out.println("Windows 风格文本框渲染");
    }
    @Override
    public void input(String text) {
        System.out.println("Windows 文本框输入: " + text);
    }
}

定义一个抽象工厂接口，其中规定了返回两个组件接口的方法

interface GUIFactory {
    Button createButton();
    TextBox createTextBox();
}

继承接口实现方法，返回Window类型的各个组件

class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
    @Override
    public TextBox createTextBox() {
        return new WindowsTextBox();
    }
}

这样通过这个实现抽象工厂的Windows工厂实例去创建对应的各个组件了

定义客户端

我们对于这个工程再次进行封装，提取出抽象工厂作为接口，这样我们在传入工厂实例的时候就可以通过实例初始化各个组件了

public class Application {
    private final Button button;
    private final TextBox textBox;

    public Application(GUIFactory factory) {
        button = factory.createButton();
        textBox = factory.createTextBox();
    }

    public void renderUI() {
        button.render();
        textBox.render();
    }

    public void simulateUserInput() {
        button.onClick();
        textBox.input("Hello, Abstract Factory!");
    }

    public static void main(String[] args) {
        // 使用 Windows 风格
        Application windowsApp = new Application(new WindowsFactory());
        windowsApp.renderUI();
        windowsApp.simulateUserInput();

}

后续我们扩展新的风格只需要：

1.创建Button和TextBox的实现类，2.新风格的工厂实例

在客户端中传入工厂实例即可

双重检查#

通过volatile和两次为null判断和synchronized关键字实现

public class Person {
    private static volatile Person person = null;

    private Person() {}

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

volatile 的必要性

person = new Person();不是原子操作，它分为了三个部分

1.分配内存空间

2.初始化对象

3.将内存地址赋给person

如果没有进行volatile那么JMV可能会继续指令重排（1.3.2），导致其他线程没有拿到初始化的对象

确保一个线程对person的修改，对其他线程立即可见

静态内部类#

通过在单例类中，通过私有的静态内部类，创建单例对象

public class Person {

    private static class Inner {
        private static final Person person = new Person();
    }

    private Person() {}

    public static Person getInstance() {
        return Inner.person;
    }
}

这里使用Person中的Inner内部类的Inner.person时候才会进行加载Inner类，实现了懒加载

饿汉式#

public class Person {
    private static final Person person;
    static {
        person = new Person();
    }

    private Person() {}

    public static Person getInstance() {
        return person;
    }
}

枚举#

枚举方式实现单例模式，是最佳的实现方式，可以有效防止对于单例模式的破坏

public enum Person {
    INSTANCE;
    public static Person getInstance() {
        return INSTANCE;
    }
}

public enum Person {
    INSTANCE;

    private String name;

    // 枚举构造器（天生 private，不可 public/protected）
    Person() {
        this.name = "Default";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

// 使用
Person.INSTANCE.setName("Alice");
System.out.println(Person.INSTANCE.getName()); // 输出 "Alice"

单例破坏#

序列化破坏

public class Main {
    public static void main(String[] args) throws Exception{
        Person p1 = Person.getInstance();
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("sin"));
        oos.writeObject(p1);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("sin"));
        Person p2 = (Person) ois.readObject();
        System.out.println(p1.hashCode() + "\n" + p2.hashCode());
    }
}

• Java 在反序列化 enum 时，不会调用构造方法，而是 直接返回 JVM 维护的唯一实例（类似 readResolve() 的逻辑）。
• enum 的序列化仅存储 name，反序列化时根据 name 查找已有实例（Enum.valueOf）

反射破坏

public class Main {
    public static void main(String[] args) throws Exception{
        Person p1 = Person.getInstance();
        Constructor<Person> constructor = Person.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Person p2 = constructor.newInstance();
        System.out.println(p1.hashCode() + "\n" + p2.hashCode());
    }
}

Java 不允许通过反射创建 enum 实例：

• enum 的构造器默认 private，且 JVM 进行严格限制。
• 即使 反射强行调用 enum 的构造器，也会抛出 IllegalArgumentException

克隆破坏

Person p1 = Person.getInstance();
Person p2 = p1.clone();  // ❌ 创建新对象，破坏单例

enum类的clone方法由final修饰，禁止重写