【面向对象】(1) Java23种设计模式总结

创建型

1.单例(Singleton)

• 目的：单例类在全局只有一个实例，并提供一个全局访问点；
• 优点：减少内存开销、避免对资源的多重占用；
• 缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化；
• 使用场景：任务管理器、Logger类(操作日志文件)、Config类(配置文件)、数据库连接池、线程池、文件系统等
• 6种实现方式

1. 懒汉式，线程不安全

//多线程下，可能多个线程同时进入getInstance方法，创建多个实例
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){} 
    public static Singleton getInstance() {  
	    if (instance == null) {  
	        instance = new Singleton();  
	    }  
    	return instance;  
    }  
}

2. 懒汉式，线程安全

//在实例已经创建的情况下，getInstance方法其实不用加锁了，加锁后，多线程只能依次访问getInstance方法效率很低
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
	    if (instance == null) {  
	        instance = new Singleton();  
	    }  
	    return instance;  
    }  
}

3. 饿汉式

//类加载时就创建一个实例，在没使用到该实例时，存在内存开销，但如果内存开销不大的话，该方法是比较简单的，并保证了线程安全。
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    	return instance;  
    }  
}

4. 双重校验锁

// 保证了线程安全，只在创建实例时加锁，实例创建后，可以直接获取实例，比方法3高效
public class Singleton {  
    private volatile static Singleton singleton;  //volatile关键字
    private Singleton (){}  
    public static Singleton getSingleton() {  
	    if (singleton == null) {  //第一次判空
	        synchronized (Singleton.class) {  
		        if (singleton == null) {  //第二次判空
		            singleton = new Singleton();  
		        }  
	        }  
	    }  
	    return singleton;  
    }  
}

这里有3个问题：
a. 第一次判空的原因：如果instance不为空，那么进入创建实例的过程
b. 第二次判空的原因：在多线程下，如果有两个线程进入该代码块，如果不判空，依然会先后产生两个实例。例如线程1第一次判空通过→线程2第一次判空通过→线程1第二次判空通过，创建实例→此时，如果不判空，又会创建一个实例，因此需要第二次判空
c.volatile关键字作用：instance = new Singleton();该语句不是原子操作，分为理解为3步(1. 为 instance 分配内存空间;2.初始化 instance;3.将 instance 指向分配的内存地址)，由于指令重排列机制，123可能不是顺序执行，可能执行顺序为132，在单线程下正确性是可以保证的，但多线程下可能出现问题。例如：线程1执行了以上1,3步，此时instance不为空，但没初始化→线程2执行第一次判空，instance不为空，直接返回了instance→线程2访问instance的成员变量，会报错。如果加入volatile关键字，禁止指令重排，那么instance的创建按123进行，就不会进入这个不期望的流程。

5. 静态内部类

//懒加载、线程安全
public class Singleton {  
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
}

6. 枚举

//简单、高效、线程安全、防止反射攻击
public enum Singleton {  
    INSTANCE; 
}

简单工厂(Simple Factory)

不属于23种设计模式之一

• 目的：客户创建对象时，不向客户暴露内部细节，只提供一个创建对象的接口
• 实现

1. 客户只需要保持对工厂的引用，然后访问工厂的接口，获取需要的实例

public class Client {
	public static void main(String[] args) {
		SimpleFactory simpleFactory = new SimpleFactory();
		Product product = simpleFactory.createProduct(1);
		// do something with the product
	} 
}

2. 工厂需要根据客户访问接口的参数，返回具体的实例

public class SimpleFactory {
    public Product createProduct(int type) {
        if (type == 1) {
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}

2.工厂方法(工厂模式)

参考: 知乎:3种工厂模式的区别

• 实现

1. 客户不需要传递参数的方法指定实例，只需要确定使用哪个工厂

public class Client {
	public static void main(String[] args) {
		Factory factory1 = new Factory1();
		Product product = factory1.createProduct();
		// do something with the product
	} 
}

2. Factory只是一个接口或抽象类，实例的初始化放在其子类去实现

public class Factory1 implements Factory {
    public Product createProduct() {
        return new Product1();
    }
}

3.抽象工厂(Abstract Factory)

• 当工厂产生的对象类型只有一个时，即为工厂模式，当需要产生多个类型的对象时，就变成了抽象工厂模式，因此可以将抽象工厂模式理解为工厂模式的扩展
• 实现

1. 客户需要两个类型的对象ProductA,ProductB，客户可以指定不同的工厂去获取对象，获取同一个类型的对象，可以指定不同的工厂，更加灵活。

public class Client {
	public static void main(String[] args) {
		Factory factory1 = new Factory1();
		ProductA productA = factory1.createProductA();
		ProductB productB = factory1.createProductB();
		// 也可以指定其他的工厂来获取实例
		//Factory factory2 = new Factory2();
		//ProductA productA = factory2.createProductA();
		//ProductB productB = factory2.createProductB();
	} 
}

2. 实例的初始化依然还是放在具体工厂的实现类中

public class Factory1 implements Factory {
    public ProductA createProductA() {
        return new ProductA();
    }
    public ProductB createProductB() {
        return new ProductB();
    }
}

4.生成器(Builder)

• 构造一个复杂对象时，可以使用Builder方便客户设置某些属性值，然后方便的创建一个对象。
• 例子：在Android中使用AlertDialog

1. 使用

AlertDialog dialig = new AlertDialog.Builder()
.setTitle("")
.setMessage("")
.setXXX()
.build();

2. 内部实现

class AlertDialog{

	static class Builder{
		//Builder创建实例
		AlertDialog instance;
		Builder(){
			instance = new AlertDialog()
		}
		//设置属性
		Builder setTitle(){}
		Builder setXXX(){}
		AlertDialog build(){return instance}
	}
}

5.原型(Prototype)

• 目的：多次获取重复的对象，并保证效率。
• 实现：

1. 客户在不同场景需要多次获取新的重复的对象Obj1,Obj2并使用

public class Client {
	public static void main(String[] args) {
		Object obj1 = ObjCache.getObj1();
		Object obj2 = ObjCache.getObj2();
		obj1.xxx
		obj2.xxx
	} 
}

2. ObjCache中需要缓存Obj1和Obj2，如果对象的创建开销较大时，就可以缓存起来，方便使用

public class ObjCache {
	//这里是已经通过某些途径(如数据库、文件IO等)生成了实例
	Object obj1,obj2;
	public Object getObj1(){
		return obj1.clone();//返回拷贝的实例
	}
	
}

行为型

6.责任链模式

• 目的：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。
• 使用场景：Logger
• 实现：

1. 客户端需要指定发送请求的类型，以及想让那些接受对象处理请求

//这里假定从handler1,handler2,...依次处理请求
//也可以指定其中一个handler，这样之前的handler就不会受到请求
Handler h = HandlerManager.getHandler(1);
//这里指定请求类型，handler根据请求类型判断自己要不要处理这个请求
Request r = Request(type);
h.handle(r);

2. Handler及其实现

//Handler可以是抽象类或接口
public abstract class Handler{
	abstract void handle(Request r);
}
//具体handler的实现
public class Handler1 extends Handler{
	void handle(r){
		//如果请求类型自己可以处理，那么就处理
		//否则就向下一个处理器传递
		HandlerManager.nextHandler(this).handle()
	}
}

3. HandlerManager管理这些处理对象的实例及处理顺序

public class HandlerManager{
	getHandler(type)
	nextHandler(){}
	//可以用链表存这些handler的实例
	LinkedList<Handler>
}

7.命令(Command)

结构型