1、单例模式
定义：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
通用代码：（是线程安全的）
public class Singleton {
private static final Singleton singleton = new Singleton();
//限制产生多个对象
private Singleton(){
}
//通过该方法获得实例对象
public static Singleton getSingleton(){
return singleton;
}
//类中其他方法，尽量是 static
public static void doSomething(){
} }
使用场景：
● 要求生成唯一序列号的环境；
● 在整个项目中需要一个共享访问点或共享数据，例如一个 Web 页面上的计数
器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确
保是线程安全的；
● 创建一个对象需要消耗的资源过多，如要访问 IO 和数据库等资源；
● 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式
（当然，也可以直接声明为 static 的方式）。
线程不安全实例：
public class Singleton {
private static Singleton singleton = null;
//限制产生多个对象
private Singleton(){
}
//通过该方法获得实例对象
public static Singleton getSingleton(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
} }
解决办法：
加 synchronized 来实现。最优的办法是如通用代码那样写。
2、工厂模式
定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
Product 为抽象产品类负责定义产品的共性，实现对事物最抽象的定义；
Creator 为抽象创建类，也就是抽象工厂，具体如何创建产品类是由具体的实现工
厂 ConcreteCreator 完成的。
具体工厂类代码：
public class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T> c){
Product product=null;
try {
product =
(Product)Class.forName(c.getName()).newInstance();
} catch (Exception e) {
//异常处理
}
return (T)product;
} }
简单工厂模式：
一个模块仅需要一个工厂类，没有必要把它产生出来，使用静态的方法
多个工厂类：
每个人种（具体的产品类）都对应了一个创建者，每个创建者独立负责创建对应的
产品对象，非常符合单一职责原则
代替单例模式：
单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象
延迟初始化：
ProductFactory 负责产品类对象的创建工作，并且通过 prMap 变量产生一个缓存，对需要再次被重用的对象保留使用场景：jdbc 连接数据库，硬件访问，降低对象的产生和销毁
3、抽象工厂类
定义：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。
抽象工厂类代码：
public abstract class AbstractCreator {
//创建 A 产品家族
public abstract AbstractProductA createProductA();
//创建 B 产品家族
public abstract AbstractProductB createProductB();
}
使用场景：
一个对象族（或是一组没有任何关系的对象）都有相同的约束。
涉及不同操作系统的时候，都可以考虑使用抽象工厂模式
4、模板方法
定义：定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
AbstractClass 叫做抽象模板，它的方法分为两类：
● 基本方法
基本方法也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。
● 模板方法
可以有一个或几个，一般是一个具体方法，也就是一个框架，实现对基本方法的调度，完成固定的逻辑。
注意： 为了防止恶意的操作，一般模板方法都加上 final 关键字，不允许被覆写。
具体模板：ConcreteClass1 和 ConcreteClass2 属于具体模板，实现父类所定义的一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现
使用场景：
● 多个子类有公有的方法，并且逻辑基本相同时。
● 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由
各个子类实现。
● 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然
后通过钩子函数（见“模板方法模式的扩展”）约束其行为。
5、建造者模式
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
● Product 产品类
通常是实现了模板方法模式，也就是有模板方法和基本方法，例子中的
BenzModel 和 BMWModel 就属于产品类。
● Builder 抽象建造者
规范产品的组建，一般是由子类实现。例子中的 CarBuilder 就属于抽象建造者。
● ConcreteBuilder 具体建造者
实现抽象类定义的所有方法，并且返回一个组建好的对象。例子中的 BenzBuilder
和 BMWBuilder 就属于具体建造者。
● Director 导演类
负责安排已有模块的顺序，然后告诉 Builder 开始建造
使用场景：
● 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
● 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，
则可以使用该模式。
● 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使
用建造者模式非常合适。
建造者模式与工厂模式的不同：
建造者模式最主要的功能是基本方法的调用顺序安排，这些基本方法已经实现了，
顺序不同产生的对象也不同；
工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。
6、代理模式
定义：为其他对象提供一种代理以控制对这个对象的访问。
● Subject 抽象主题角色
抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。
● RealSubject 具体主题角色也叫做被委托角色、被代理角色。它才是冤大头，是业务逻辑的具体执行者。
● Proxy 代理主题角色
也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。
普通代理和强制代理：
普通代理就是我们要知道代理的存在，也就是类似的 GamePlayerProxy 这个类的存在，然后才能访问；强制代理则是调用者直接调用真实角色，而不用关心代理是否存在，其代理的产生是由真实角色决定的。
普通代理：
在该模式下，调用者只知代理而不用知道真实的角色是谁，屏蔽了真实角色的变更对高层模块的影响，真实的主题角色想怎么修改就怎么修改，对高层次的模块没有任何的影响，只要你实现了接口所对应的方法，该模式非常适合对扩展性要求较高的场合。
强制代理：
强制代理的概念就是要从真实角色查找到代理角色，不允许直接访问真实角色。高层模块只要调用 getProxy 就可以访问真实角色的所有方法，它根本就不需要产生一个代理出来，代理的管理已经由真实角色自己完成。
动态代理：
根据被代理的接口生成所有的方法，也就是说给定一个接口，动态代理会宣称“我已经实现该接口下的所有方法了”。两条独立发展的线路。动态代理实现代理的职责，业务逻辑 Subject 实现相关的逻辑功能，两者之间没有必然的相互耦合的关系。通知 Advice 从另一个切面切入，最终在高层模块也就是 Client 进行耦合，完成逻辑的封装任务。动态代理调用过程示意图：动态代理的意图：横切面编程，在不改变我们已有代码结构的情况下增强或控制对象的行为。
首要条件：被代理的类必须要实现一个接口。
7、原型模式
定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式通用代码：
public class PrototypeClass implements Cloneable{
//覆写父类 Object 方法
@Override
public PrototypeClass clone(){
PrototypeClass prototypeClass = null;
try {
prototypeClass = (PrototypeClass)super.clone();
} catch (CloneNotSupportedException e) {
//异常处理
}
return prototypeClass;
} }
原型模式实际上就是实现 Cloneable 接口，重写 clone（）方法。
使用原型模式的优点：
● 性能优良
原型模式是在内存二进制流的拷贝，要比直接 new 一个对象性能好很多，特别是
要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。
● 逃避构造函数的约束
这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的
使用场景：
● 资源优化场景
类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
● 性能和安全要求的场景
通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模
式。
● 一个对象多个修改者的场景
一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以
考虑使用原型模式拷贝多个对象供调用者使用。
浅拷贝和深拷贝：
浅拷贝：Object 类提供的方法 clone 只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝，其他的原始类型比如 int、long、char、string（当做是原始类型）等都会被拷贝。
注意： 使用原型模式时，引用的成员变量必须满足两个条件才不会被拷贝：一是类的成员变量，而不是方法内变量；二是必须是一个可变的引用对象，而不是一个原始类型或不可变对象。
深拷贝：对私有的类变量进行独立的拷贝
如：thing.arrayList = (ArrayList)this.arrayList.clone();
来源：CSDN
作者：梦想零落成诗～
链接：https://blog.csdn.net/weixin_44863780/article/details/103801983