设计模式初探--创建型模式

创建型模式#

创建型模式：就是创建对象的模式，抽象了实例化的过程。关注的是对象的创建，创建型模式将创建对象的过程进行抽象，可以理解为将创建对象进行了封装，作为客户程序只需使用对象，不再关心创建对象过程的逻辑。

简单工厂模式#

简单工厂模式 (Simple Factory Pattern)：又称为静态工厂方法 (Static Factory Method) 模式，在简单工厂模式中，可以根据参数的不同返回不同类的实例（一个按钮根据形状参数按钮返回不同的形状）。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

实现方法#

工厂类（Factory）：负责根据传入参数（如字符串、枚举等）创建对应的产品对象。

public class VendorFactory {
    public static IVender createVendor(String type) {
        switch (type) {
            case "A": return new VendorA();
            case "B": return new VendorB();
            default: throw new RuntimeException("供应商不存在");
        }
    }
}

抽象产品（Abstract Product）：定义所有产品的公共接口。
```
public interface IVender {
    void order();
}
```

具体产品（Concrete Product）：实现抽象产品接口的类，每个类对应一种产品类型。

public class VendorA implements IVender {
    @Override
    public void order() { System.out.println("A供应商下单成功"); }
}

使用#

IVender vendor = VendorFactory.createVendor("A");
vendor.order();  // 输出：A供应商下单成功

工厂方法模式#

核心思想是将对象的创建过程抽象化，允许子类决定实例化哪个具体类，从而在不修改客户端代码的情况下扩展系统功能。

组成部分#

抽象工厂（Creator）
具体工厂（Concrete Creator）
抽象产品（Product）
具体产品（Concrete Product）

实现#

// 抽象产品
interface Car {
    void show();
}

// 具体产品
class CarA implements Car {
    @Override
    public void show() { System.out.println("小米SU7"); }
}

// 抽象工厂
abstract class Factory {
    public abstract Car createCar();
}

// 具体工厂
class CarFactoryA extends Factory {
    @Override
    public Car createCar() { return new CarA(); }
}

../_images/SimpleFactory.jpg

实现方法#

工厂类（Factory）：负责根据传入参数（如字符串、枚举等）创建对应的产品对象。

public class VendorFactory {
    public static IVender createVendor(String type) {
        switch (type) {
            case "A": return new VendorA();
            case "B": return new VendorB();
            default: throw new RuntimeException("供应商不存在");
        }
    }
}

抽象产品（Abstract Product）：定义所有产品的公共接口。
```
public interface IVender {
    void order();
}
```

具体产品（Concrete Product）：实现抽象产品接口的类，每个类对应一种产品类型。

public class VendorA implements IVender {
    @Override
    public void order() { System.out.println("A供应商下单成功"); }
}

使用#

IVender vendor = VendorFactory.createVendor("A");
vendor.order();  // 输出：A供应商下单成功

工厂方法模式#

核心思想是将对象的创建过程抽象化，允许子类决定实例化哪个具体类，从而在不修改客户端代码的情况下扩展系统功能。

组成部分#

抽象工厂（Creator）
具体工厂（Concrete Creator）
抽象产品（Product）
具体产品（Concrete Product）

实现#

// 抽象产品
interface Car {
    void show();
}

// 具体产品
class CarA implements Car {
    @Override
    public void show() { System.out.println("小米SU7"); }
}

// 抽象工厂
abstract class Factory {
    public abstract Car createCar();
}

// 具体工厂
class CarFactoryA extends Factory {
    @Override
    public Car createCar() { return new CarA(); }
}

抽象工厂模式#

一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。

应用条件

当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。

工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。

模式结构#

AbstractFactory：抽象工厂
ConcreteFactory：具体工厂
AbstractProduct：抽象产品
Product：具体产品

[示例](抽象工厂模式（通俗易懂）_抽象工厂通俗的方式 - CSDN 博客)

原型模式#

通过复制现有对象（原型）来创建新对象，而非通过传统的构造函数实例化。它特别适用于需要高效创建复杂对象或动态生成同类对象的场景。

组成#

抽象原型（Prototype）：定义克隆方法的接口（如Cloneable接口）。
具体原型（Concrete Prototype）：实现克隆逻辑的具体对象（如重写clone()方法）。
客户端（Client）：通过调用原型对象的克隆方法创建新对象。

克隆方式：浅拷贝，深拷贝（收到实现或通过序列化）。

实现#

// 抽象原型（实现Cloneable接口）
public abstract class Shape implements Cloneable {
    protected String type;
    public abstract void draw();

    @Override
    public Shape clone() {
        try {
            return (Shape) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();  // 不会发生
        }
    }
}

// 具体原型：圆形
public class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }

    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

// 客户端调用
Shape original = new Circle();
Shape clone = original.clone();  // 克隆对象
clone.draw();  // 输出：绘制圆形

单例模式#

确保一个类在整个应用程序生命周期中只有一个实例，并提供一个全局访问点。通过单例模式，可以避免多个实例带来的资源浪费和数据不一致问题。

如何保证只有一个单例：

让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

实现方法#

单例模式 - 知乎

懒汉式（第一次调用时才会被创建）

public class Singleton {
    private static Singleton instance;

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

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            instance = new Singleton();
        }
        return instance;
    }
}

饿汉式（类加载时就创建实例）

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

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

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