设计模式的概念--创建型模式-CSDN博客

本文链接：https://blog.csdn.net/kkkkm1/article/details/140399666

创建型模式：用于对象的创建过程，关注对象的实例化过程。其中包括：

1.* * 简单工厂方法模式（Simple Factory Method Pattern）：根据不同的参数来实例化不同的类，从而将对象的创建与使用分离(SqlSessionFactory.openSession(ExecutorType execType))。**

// 产品接口
interface Product {
    void operation();
}
// 具体产品类 A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}
// 具体产品类 B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}
// 工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        Product productB = SimpleFactory.createProduct("B");

        productA.operation();
        productB.operation();
    }

1.1简单工厂方法模式的改造

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(Class c) throws Exception {
        return c.forName(c.getName()).newInstance();
    }
}
// 客户端代码
public class Client {
    public static void main(String[] args)  throws Exception {
        Product productA = SimpleFactory.createProduct(ConcreteProductA.class);
        Product productB = SimpleFactory.createProduct(ConcreteProductB.class);
        productA.operation();
        productB.operation();
    }
}

工厂方法模式（Factory Method Pattern）：定义了一个创建对象的接口，但由子类决定实例化哪个类。
抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定其具体类。

// 抽象产品族
interface Button {
    void click();
}
// 具体产品族 A
class WindowsButton implements Button {
    @Override
    public void click() {
        System.out.println("Windows button clicked");
    }
}
// 具体产品族 B
class MacOSButton implements Button {
    @Override
    public void click() {
        System.out.println("MacOS button clicked");
    }
}
// 抽象工厂
interface GUIFactory {
    Button createButton();
}
// 具体工厂 A
class WindowsGUIFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
}
// 具体工厂 B
class MacOSGUIFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacOSButton();
    }
}
public class AbstractFactoryExample {
    public static void main(String[] args) {
        GUIFactory windowsFactory = new WindowsGUIFactory();
        Button windowsButton = windowsFactory.createButton();
        windowsButton.click();

        GUIFactory macosFactory = new MacOSGUIFactory();
        Button macosButton = macosFactory.createButton();
        macosButton.click();
    }
}

单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点(DefaultSingletonBeanRegistry.getSingleton(String beanName, ObjectFactory<?> singletonFactory))。

饿汉式

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

    private EagerSingleton() {
        // 私有构造函数
    }

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

懒汉式

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // 私有构造函数
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

建造者模式（Builder Pattern）：将一个复杂对象的构建过程与其表示分离，以便同样的构建过程可以创建不同的表示(SqlSessionFactoryBuilder. build(Reader reader))。

// 产品类
class Product {
    private String part1;
    private String part2;

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public String toString() {
        return "Part1: " + part1 + ", Part2: " + part2;
    }
}
// 抽象建造者
interface Builder {
    void buildPart1();
    void buildPart2();
    Product getResult();
}
// 具体建造者
class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPart1() {
        product.setPart1("Part A");
    }

    @Override
    public void buildPart2() {
        product.setPart2("Part B");
    }

    @Override
    public Product getResult() {
        return product;
    }
}
// 指导者
class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.buildPart1();
        builder.buildPart2();
    }
}
public class BuilderExample {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);

        director.construct();
        Product product = builder.getResult();
        System.out.println(product);
    }
}

原型模式（Prototype Pattern）：通过复制现有的对象来生成新的实例。

// 原型接口
interface Prototype {
    Prototype clone();
}
// 具体原型类 A
class ConcretePrototypeA implements Prototype {
    @Override
    public Prototype clone() {
        return new ConcretePrototypeA();
    }
}
// 具体原型类 B
class ConcretePrototypeB implements Prototype {
    @Override
    public Prototype clone() {
        return new ConcretePrototypeB();
    }
}
public class PrototypeExample {
    public static void main(String[] args) {
        Prototype prototypeA = new ConcretePrototypeA();
        Prototype clonedA = prototypeA.clone();

        Prototype prototypeB = new ConcretePrototypeB();
        Prototype clonedB = prototypeB.clone();
    }
}