总览

总共有 23 种设计模式。这些模式可以分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）、行为型模式（Behavioral Patterns）。

1、创建型模式

1.1、※工厂模式（Factory Pattern）Spring中大量使用

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

实现：1、一个抽象接口Shape；2、若干实现了抽象接口的实体类Square, Circle；3、一个工厂类ShapeFactory包含创建实体类的方法 getShape()；4、一个Demo使用工厂类创建实体对象并执行对应方法

//1、一个抽象接口`Shape`；
public interface Shape {
    void draw();
}

//2、若干实现了抽象接口的实体类`Square`, `Circle`；
class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("画一个圆");
    }
}
class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("画一个方");
    }
}

//3、一个工厂类`ShapeFactory`包含创建实体类的方法 `getShape()`；
class ShapeFactory {
    //使用 getShape 方法获取形状类型的对象
    public Shape getShape(String type){
        if(type == null){
            return null;
        }
        if("circle".equals(type)){
            return new Circle();
        } else if ("square".equals(type)) {
            return new Square();
        }else{
            return null;
        }
    }
}

//4、一个Demo使用工厂类创建实体对象并执行对应方法
public class Demo {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        //获取 Circle 的对象，并调用它的 draw 方法
        Shape circle = shapeFactory.getShape("circle");
        circle.draw();

        //获取 Square 的对象，并调用它的 draw 方法
        Shape square = shapeFactory.getShape("square");
        square.draw();
    }
}

1.2、※单例模式（Singleton Pattern）spring默认使用

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

优点：1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

实现：1、一个单例类，其中包含一个该类的静态实例对象，私有的构造函数，一个静态方法获取实例对象，若干实例方法；2、一个Main获取单例对象并验证。

class SingleObject{
    private static SingleObject singleObject = new SingleObject();
    
    private SingleObject(){
    }
    
    //让构造函数为 private，这样该类就不会被实例化
    public static SingleObject getInstance(){
        return singleObject;
    }
    
    //获取唯一可用的对象
    public void show(){
        System.out.println("这是单例对象");
    }
}

public class Main{
	public static void main (String[] args){
		SingleObject object = SingleObject.getInstance();
		object.show();
	}
}

1.3、抽象工厂模式（Abstract Factory Pattern）

1.4、建造者模式（Builder Pattern）

1.5、原型模式（Prototype Pattern）

2、结构型模式

2.1、※适配器模式（Adapter Pattern）

2.2、桥接模式（Bridge Pattern）

2.3、过滤器模式（Filter、Criteria Pattern）

2.4、组合模式（Composite Pattern）

2.5、※代理模式（Proxy Pattern）

2.6、外观模式（Facade Pattern）

2.7、享元模式（Flyweight Pattern）

2.8、装饰器模式（Decorator Pattern）

3、行为型模式

3.1、※责任链模式（Chain of Responsibility Pattern）

3.2、命令模式（Command Pattern）

3.3、解释器模式（Interpreter Pattern）

3.4、迭代器模式（Iterator Pattern）

3.5、中介者模式（Mediator Pattern）

3.6、备忘录模式（Memento Pattern）

3.7、※观察者模式（Observer Pattern）

3.8、状态模式（State Pattern）

3.9、空对象模式（Null Object Pattern）

3.10、策略模式（Strategy Pattern）

3.11、※模板模式（Template Pattern）

3.12、访问者模式（Visitor Pattern）