便于理解的设计模式（创建型模式）【持续更新】

一. 单例模式
1.解释
单例模式时一种创建型设计模式，它保证一个类只有一个实例，并提供了一个全局的访问点来访问该实例。这意味着无论在任何地方请求该类的实例，都会返回相同的实例。
2. 用途
1）全局配置管理：单例模式可以用于管理全局配置信息，以却表应用程序中的所有部分都使用相同的配置。
2）线程池、服务器和连接池：在需要共享资源的情况下，可以使用单例模式来管理线程池、服务器或数据库连接池。
3）日志记录器：单例模式可用于创建日志记录器，以确保应用程序中的所有组件都使用相同的日志实例。
4）窗口管理器和对话框框架：在GUI应用程序中，单例模式可用于管理窗口和对话框的显示和隐藏。

代码示例：

/**
 * @Author: DMXC
 * @Description:
 * @Date: Created in 15:39 2023/10/7
 * @Modified By :
 */
public class Singleton {

    // 私有静态成员变量，用于保存唯一的实例
    private static Singleton instance;

    // 私有构造函数，防止外部实例化
    private Singleton(){
        // 可以进行一些初始化操作
    }

    // 提供全局访问点以获取唯一实例
    public static Singleton getInstance(){
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // 可以添加其他方法和属性
    public void doSomething(){
        System.out.println("提供一些别的方法");
    }


    public static void main(String[] args){
        // 获取单例实例
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        // 验证是否为同一个实例
        System.out.println(singleton1 == singleton2);

        // 调用实例的方法
        singleton1.doSomething();
        singleton2.doSomething();
    }

}

二. 工厂模式

1. 解释
   工厂模式是一种创建类型设计模式，它提供了一种创建对象的方式，而传入将对象的具体类型传入给客户端代码。工厂模式通过定义一个共同的接口或基类来创建对象，并由这使得客户端代码能够通过工厂接口创建对象，而获取知道对象的具体实现。

2. 用途

1. 对象创建复杂性：当对象的创建涉及到一些复杂的逻辑、条件判断或依赖其他对象时，工厂模式可以将这些复杂性封装起来，使客户端代码更加简洁。
2. 避免直接依赖具体类：工厂模式可以降低客户端代码与具体类之间的关联度，因为客户端只依赖工厂接口而不是具体的类。
3. 支持可扩展性：通过添加新的工厂子类,可以轻松地引入新的对象类型，进而修改现有的客户端代码。

代码示例：

// 抽象图形接口
interface Shape {
    void draw();
}

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

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

// 图形工厂接口
interface ShapeFactory {
    Shape createShape();
}

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

// 矩形工厂
class RectangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

在上面的示例中：
Shape是一个抽象图形接口，定义了一个draw()方法。
Circle和Rectangle是具体的图形类，实现了Shape接口的draw()方法。
ShapeFactory是图形工厂接口，定义了一个createShape()方法，用于创建图形对象。
CircleFactory和RectangleFactory是具体的工厂类，分别用于创建圆形和形状对象。
使用工厂模式的示例：

public class Main {
    public static void main(String[] args) {
        // 创建圆形对象
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw(); // 输出 "绘制圆形"

        // 创建矩形对象
        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw(); // 输出 "绘制矩形"
    }
}

三. 抽象工厂模式
1.解释
抽象工厂模式是一种创建类型设计模式，它提供了一种创建一系列相关或依赖对象的方式，并指定其具体类。抽象工厂模式通过定义一个抽象工厂接口，其中包含多个创建方法，每个方法用于创建不同类型的相关对象。具体的工厂类实现了该接口，并负责创建具体类型的对象。
2.用途
1）创建一组相关对象：当需要创建一组相互关联或依赖的对象时，抽象工厂模式可以提供一种一致性的方式来创建它们。
2）隐藏对象创建细节：抽象工厂模式将对象的创建细节封装在工厂类中，客户端代码需要知道具体的对象类。
3）支持可扩展性：通过添加新的工厂类，可以轻松地引入新的对象类型，从而小号修改客户端代码。
3.示例

// 抽象汽车接口
interface Car {
    void drive();
}

// 具体汽车实现
class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶小轿车");
    }
}

class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶SUV");
    }
}

// 抽象摩托车接口
interface Motorcycle {
    void ride();
}

// 具体摩托车实现
class SportsBike implements Motorcycle {
    @Override
    public void ride() {
        System.out.println("骑行跑车");
    }
}

class Cruiser implements Motorcycle {
    @Override
    public void ride() {
        System.out.println("骑行巡航摩托车");
    }
}

// 抽象工厂接口
interface VehicleFactory {
    Car createCar();
    Motorcycle createMotorcycle();
}

// 具体汽车工厂
class CarFactory implements VehicleFactory {
    @Override
    public Car createCar() {
        return new Sedan();
    }

    @Override
    public Motorcycle createMotorcycle() {
        return new Cruiser();
    }
}

// 具体摩托车工厂
class MotorcycleFactory implements VehicleFactory {
    @Override
    public Car createCar() {
        return new SUV();
    }

    @Override
    public Motorcycle createMotorcycle() {
        return new SportsBike();
    }
}

在上面的示例中：
Car和Motorcycle是抽象产品接口，分别表示汽车和摩托车。
Sedan、SUV、SportsBike和Cruiser是具体的产品类，实现了相应的抽象产品接口。
VehicleFactory是抽象工厂接口，定义了创建汽车和摩托车的方法。
CarFactory和MotorcycleFactory是具体工厂类，分别用于创建汽车和雕像对象。
使用抽象工厂模式的示例：

public class Main {
    public static void main(String[] args) {
        // 创建汽车和摩托车工厂
        VehicleFactory carFactory = new CarFactory();
        VehicleFactory motorcycleFactory = new MotorcycleFactory();

        // 创建汽车和摩托车对象
        Car car = carFactory.createCar();
        Motorcycle motorcycle = motorcycleFactory.createMotorcycle();

        // 使用创建的对象
        car.drive();           // 输出 "驾驶小轿车"
        motorcycle.ride();     // 输出 "骑行跑车"
    }
}

四. 建造者模式
1.解释
建造者模式是一种创建类型设计模式，它的作用是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。这样，相同的构建过程可以创建不同的表示。
2.用途
建造者模式常用于需要创建复杂对象的场景。这种情况下，直接通过构造函数传递所有参数可能会非常繁琐，并且一旦参数列表变长，代码的可读性和维护性就会变差。因此，可以使用建造者模式，将对象的狗i教案过程拆分为一系列简单的步骤，通过指挥者来指导构建过程
3.示例

// 产品类
class Product{
	private String car;
	private String  bicycle;

	public void setCar(String car){
		this.car = car;
	}

	public void setBicycle(String bicycle){
		this.bicycle = bicycle;
	}

	public void show(){
		System.out.pritIn("Product tools:" + car + "and" + bicycle);
	}
}

// 抽象建造者
interface Builder{
	void buildCar();
	void buildBicycle();
	Product getResult();
}

// 具体建造者
class ConcreteBuilder implements Builder{

	private Product product;

	public ConcreteBuilder(){
		this.product = new Product();
	}

	@Override
	public void buildCar(){
		product.setCar("帕拉梅拉");
	}

	@Override
	public void buildBicycle(){
		product.ssetBicycle("山地自行车");
	}
	
	@Override
	public Product getResult(){
		return product;
	}
}


// 指挥者
class Director{
	private Builder builder;

	public Director(Builder builder){
		this.builder = builder;
	}
	
	public Product construct(){
		builder.buildCar();
		builder.buildBicycle();
		return builder.getResult();
	}
}

// 客户端代码
public class Main{
	public static void main(String[] args){
		Builder builder = new ConcreteBuilder();
		Director director = new Director(builder);

		Product product = director.construct();
		product.show();
	}
}

其中 Product 是需要构建的复杂对象，Builder 是抽象建造者接口，ConcreteBuilder 是具体建造者实现，Director 是指挥者用来指导构建过程。主方法中，我们创建了 ConcreteBuilder 对象和 Director 对象，通过指挥者来指导构建过程并生成产品。

这个示例中，产品的构建过程被分离出来，客户端不需要直接与产品的构建过程耦合。而且，如果有需要，可以通过继承 Builder 接口并创建新的具体建造者来创建不同的产品表示。

五. 原型模式
1.解释
原型模式是有一种创建型设计模式，其目的是通过复制现有对象来创建新对象，而无需通过标准的构造函数来创建。原型模式通过复制现有对象的原型示例来创建新的对象，从而避免了创建过程中的复杂逻辑。
2.用途
原型模式常用于需要创建大量相似对象的场景，特别是当对象的创建过程比较繁琐或者需要频繁创建时。通过原型模式，我们可以只创建一个原型对象，然后通过复制来创建新的对象，从而提高性能和降低内存消耗。
3.示例

// 实现Cloneable接口，表示这个类可以进行复制
class Sheep implements Cloneable{
	private String name;
	
	private Sheep(String name){
		this.name = name;
	}
	
	// 重写clone方法
	@Override
	public Sheep clone(){
		try{
			return (Sheep) super.clone();
		}catch(CloneNotSupportedException e){
			e.printStackTrace();
			return null;
		}
	}

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

	public String getName(){
		return name;
	}

}

// 客户端代码
public class Main{
	public static void main(String[] args){
		// 创建原型对象
		Sheep originalSheep = new Sheep("羊");

		// 复制原型对象来创建新对象
		Sheep clonedSheep1 = originalSheep.clone();
		clonedSheep1.setName("克隆羊多利");

		Sheep clonedSheep2 = originalSheep.clone();
		clonedSheep2.setName("克隆羊多利2号");

		// 打印
		System.out.println(originalSheep.getName());
		System.out.println(clonedSheep1.getName());
		System.out.println(cloneSheep2.getName());
	}
}

我们创建了一个可复制的类 Sheep，并重写了其 clone 方法。然后在客户端代码中，我们创建了一个原型对象 originalSheep，然后通过克隆它来创建新的对象 clonedSheep1 和 clonedSheep2。最终，我们输出了这三只羊的名字，可以看到它们都是不同的对象。

这个示例中，我们利用原型模式，避免了频繁创建对象的过程，并且通过对原型的复制来创建新对象，提高了性能。