Patrones de diseño: patrones de creación y sus códigos correspondientes: patrón de fábrica, patrón de fábrica abstracto, patrón singleton, patrón prototipo

Patrón de diseño creacional

Descripción general: se utiliza principalmente para encapsular la lógica de creación de instancias de objetos durante el proceso de creación de objetos. Para ello, define una interfaz pública para crear objetos, pero permite que las subclases decidan qué clase crear una instancia.
Ventajas: el proceso de creación de instancias de objetos se puede desacoplar del código del cliente, lo que hace que el código del cliente sea más flexible y escalable.

Ejemplo: este segmento de código es un segmento de código público

// 定义产品接口A
public interface ProductA {
    
    
    void operation();
}

// 实现具体产品A1
public class ConcreteProductA1 implements ProductA {
    
    
    @Override
    public void operation() {
    
    
        System.out.println("ConcreteProductA1 operation");
    }
}

// 实现具体产品A2
public class ConcreteProductA2 implements ProductA {
    
    
    @Override
    public void operation() {
    
    
        System.out.println("ConcreteProductA2 operation");
    }
}

// 定义产品接口B
public interface ProductB {
    
    
    void operation();
}

// 实现具体产品B1
public class ConcreteProductB1 implements ProductB {
    
    
    @Override
    public void operation() {
    
    
        System.out.println("ConcreteProductB1 operation");
    }
}

// 实现具体产品B2
public class ConcreteProductB2 implements ProductB {
    
    
    @Override
    public void operation() {
    
    
        System.out.println("ConcreteProductB2 operation");
    }
}

Patrón de fábrica

Crear una fábrica que solo produzca productos específicos.

// 实现具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    
    
    @Override
    public ProductA createProductA() {
    
    
    	// 只生成产品A1
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
    
    
    	// 只生成产品B1
        return new ConcreteProductB1();
    }
}

// 实现具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
    
    
    @Override
    public ProductA createProductA() {
    
    
    	// 只生成产品A2
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
    
    
    	// 只生成产品B2
        return new ConcreteProductB2();
    }
}

patrón abstracto de fábrica

Fábrica abstracta, se pueden crear múltiples fábricas.

// 抽象工厂接口
public interface AbstractFactory {
    
    
	// 负责创建A1、B1产品的工厂
    ProductA createProductA();
    // 负责创建A2、B2产品的工厂
    ProductB createProductB();
}

Finalmente ejecute el fragmento de código de fábrica.

// 客户端代码
public class Client {
    
    
    public static void main(String[] args) {
    
    
    	// 创建多个工厂，以至于来生成特定工厂所支持的产品
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA1.operation();
        productB1.operation();
        productA2.operation();
        productB2.operation();
    }
}

Patrón singleton

Asegúrese de que una clase tenga solo una instancia y proporcione un punto de acceso global para acceder a la instancia, pero se producirá seguridad de subprocesos (usando el método de bloqueo para resolverlo)

public class Singleton {
    
    
    // 私有的静态成员变量，用于保存单例的实例
    private static Singleton instance;

    // 私有的构造函数，防止外部代码通过new关键字创建该类的实例
    private Singleton() {
    
    
    }

    // 公共的静态方法，用于获取单例的实例
    public static synchronized Singleton getInstance() {
    
    
        if (instance == null) {
    
    
            instance = new Singleton();
        }
        return instance;
    }

    // 其他业务逻辑方法
    public void someMethod() {
    
    
        System.out.println("Singleton's someMethod");
    }
}

// 调用单例模式的实例
public class Client {
    
    
    public static void main(String[] args) {
    
    
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        // 输出 true，说明两个变量指向同一个实例
        System.out.println(singleton1 == singleton2); 
        singleton1.someMethod();
        singleton2.someMethod();
    }
}

Patrón de prototipo

Al copiar un objeto existente para generar un nuevo objeto sin crearlo a través de un constructor, el patrón prototipo permite realizar modificaciones según sea necesario.

public class Prototype implements Cloneable {
    
    
    private String name;

    public Prototype(String name) {
    
    
        this.name = name;
    }

    public String getName() {
    
    
        return name;
    }
	
    @Override
    public Prototype clone() throws CloneNotSupportedException{
    
    
    	// 实现对象的浅拷贝
        return (Prototype) super.clone();
    }
}

// 使用原型模式
public class Client {
    
    
    public static void main(String[] args) {
    
    
        Prototype prototype = new Prototype("Prototype");

        try {
    
    
            Prototype clone = prototype.clone();
            System.out.println(clone.getName()); // 输出 "Prototype"

            // 修改原型对象的属性值
            prototype.name = "Modified Prototype";
            System.out.println(prototype.getName()); // 输出 "Modified Prototype"
            System.out.println(clone.getName()); // 输出 "Prototype"
        } catch (CloneNotSupportedException e) {
    
    
            e.printStackTrace();
        }
    }
}