三种简单的设计模式（单例、工厂、代理）

三种简单的设计模式

单例模式

​ 保证一个类，只能存在一个实例

1. 私有的构造器
2. 私有的静态的该类的引用
3. 公共的访问方式

• 懒汉式：在第一次调用方法的时候再创建实例 --> 效率高，线程不安全

  public class SingleTon01 {
  	// 2.私有的静态的该类引用
  	private static SingleTon01 singleTon01 = null;
  	// 1.私有的构造器
  	private SingleTon01() {
  	}
  	// 3.公共的访问方式
  	public static SingleTon01 newInstance() {
  		if (singleTon01 == null) {
  			singleTon01 = new SingleTon01();
  		}
  		return singleTon01;
  	}
  
  }
  

• 饿汉式：在类第一次加载完成时就创建实例 --> 效率低，线程安全

  public class SingleTon02 {
  	// 2.私有的静态的该类引用
  	private static SingleTon02 singleTon02 = new SingleTon02();
  	// 1.私有的构造器
  	private SingleTon02() {
  	}
  	// 3.公共的访问方式
  	public static SingleTon02 newInstance() {
  		return singleTon02;
  	}
  
  }
  

• 懒汉式效率高，但是线程不安全，可以通过同步锁(synchronized)保证线程安全

  public class TaskManager {
  	// 2.私有的静态的该类引用
  	private static TaskManager taskManager = null;
  	// 1.私有的构造器
  	private TaskManager() {
  	}
  	// 3.公共的访问方式
  	public static TaskManager newInstance() {
          // 双重检查 double check:锁的范围小，效率高
  		if (taskManager == null) {
  			synchronized (TaskManager.class) {
  				if (taskManager == null) {
  					taskManager = new TaskManager();
  				}
  			}
  		}
  		return taskManager;
  	}
  }
  

生产者模式

​ 定义了一个创建对象的类，由这个类来封装实例化对象的行为。一般由下面三部分组成：

1. 抽象产品角色：具体产品角色继承的父类|实现的父接口
2. 具体产品角色：抽象产品角色的实现类或者子类
3. 工厂角色：帮助创建实例

• 以汽车制造简单示例一下：

  • 抽象的汽车父接口:

    public interface Car {
        ... ...
    }
    

  • 具体的产品子类：

    public class BMW implements Car{
    	... ...
    }
    public class Mercedes implements Car{
    	... ...
    }
    public class Porsche implements Car{
    	... ...
    }
    ... ...
    

  • 简单汽车工厂类：

    public class SimpleCarFactory {
    	public Car make(String brand) {
    		Car car = null;
    		if (brand == "BMW") {
    			car = new BMW();
    		} else if (brand == "Mercedes") {
    			car = new Mercedes();
    		} else if (brand == "Porsche") {
    			car = new Porsche();
    		} ... ...
    		return car;
    	}
    }
    

代理模式

​ 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。
这里简单了解一下静态代理模式，一般需要满足以下三个条件：

1. 真实角色和代理角色实现相同的接口
2. 代理角色持有真实角色的引用，通过成员属性维护
3. 代理行为

• 优点：降低与真实角色的沟通，扩展功能的实现，降低耦合度，便于后期维护

• 以售房为例示范一下：

  • 创建服务类接口

    public interface House {	
    	void forSale();
    }
    

  • 创建一个真实角色类（房东）：

    public class Landlord implements House {
    	@Override
    	public void forSale() {
    		System.out.println("有房待售...");
    	}
    }
    

  • 创建代理类（中介）：

    public class Agent implements House {
    	private Landlord landlord = null;
    	public Agent(Landlord landlord) {
    		this.landlord = landlord;
    	}
    	@Override
    	public void forSale() {
    		System.out.println("寻找房源...");
    		landlord.forSale();
    		System.out.println("接收委托...");
    	}
    }