设计模式学习

设计模式分为多种，为创建型模式、结构型模式、行为型模式。

创建型模式有：抽象工厂模式、工厂方法模式、单例模式、生成器模式、原型模式、惰性初始模式、对象池模式等。

一、抽象工厂模式

一种比较常见的设计模式，为具有相同行为和特点的类提供统一的接口。

示例：

	public interface LightInterface{
		public void turnOff();
		public void turnOn();
	}
	public class LightA implements LightInterface{
		public void turnOn(){
			System.out.println("LightA turns on");
		}
		public void turnOff(){
			System.out.println("LightA turns off");
		}
	}
	public class LightB implements LightInterface{
		public void turnOn(){
			System.out.println("LightB turns on");
		}
		public void turnOff(){
			System.out.println("LightB turns off");}
		}
	}








二、工厂方法模式
是一种面向对象的设计模式。通过调用不同的方法返回需要的类，而不是去实例化具体的类。 对实例创建进行了包装。 工厂方法是一组方法， 他们针对不同条件返回不同的类实例，这些类一般有共同的父类。


工厂方法模式实施一种按需分配的策略， 即传入参数进行选择， 工厂方法根据参数进行选择，返回具体的实例。

示例：


public interface Light{
	public void turnOff();
	public void turnOn();
}
public class LightA implements Light{
	public void turnOn(){
		System.out.println("LightA turns on");
	}
	public void turnOff(){
		System.out.println("LightA turns off");
	}
}
public class LightB implements Light{
	public void turnOn(){
		System.out.println("LightB turns on");
	}
	public void turnOff(){
		System.out.println("LightB turns off");
	}
}
public class LightFactory{
	public static Light getLight(int type){
		switch(type){
		case 0:
			return new LightA();
		case 1:
			return new LightB();
		default:
			return null;
		}
	}
}

三、单例模式


是一种常见的设计模式。单例对象的类必须保证只有一个实例存在，当我们在程序中只需要一个全局对象时，可以采用单例模式。

示例：


//懒汉方式。指全局的单例实例在第一次被使用时构建。
public class Singleton {
	private static Singleton INSTANCE = new Singleton();
	private Singleton() {}
	 
	public static Singleton getInstance() {
        	return INSTANCE;
	}
}
//饿汉方式。指全局的单例实例在类装载时构建。
public class Singleton {
	private static Singleton INSTANCE = null;
	private Singleton() {}
	 
	public static synchronized Singleton getInstance() {
		if(INSTANCE == null){
			INSTANCE = new Singleton(); 
		}
		return INSTANCE;
	}
}

四、生成器模式


是一种设计模式，又名：建造模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。



示例：


public class Light{
	private int size = 0;
	public void setSize(int size){
		this.size = size;
	}
	public void print(){
		System.out.println("The light's size is "+size);
	}
}
public abstract class LightBuilder{
	protected Light light;
	public Light getLight(){
		return light;
	}
	public abstract void createNewLightProduct();

}
class LightBuilderA extends LightBuilder{

	@Override
	public void createNewLightProduct() {
		// TODO Auto-generated method stub
		light = new Light();
		light.setSize(10);
	}	
}
class LightBuilderB extends LightBuilder{

	@Override
	public void createNewLightProduct() {
		// TODO Auto-generated method stub
		light = new Light();
		light.setSize(20);
	}	
}

public class Worker{
	private LightBuilder lb;
	public void setBuilder(LightBuilder lb){
		this.lb = lb;
	}
	public Light constructLight(){
		 lb.createNewLightProduct();
		 return lb.getLight();
	}
}
 class BuilderExample {
	 public static void main(String[] args) {
		 Worker worker = new Worker();
		 LightBuilderA A = new LightBuilderA();
		 LightBuilderB B = new LightBuilderB();
		 worker.setBuilder(A);
		 Light la = worker.constructLight();
		 la.print();
	    	 worker.setBuilder(B);
	  	 Light lb = worker.constructLight();
	     	 lb.print();
	}
}
五、原型模式
	特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”，这个原型是可定制的。
	原型模式多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；或者创建值相等，只是命名不一样的同类数据。
示例：
public class Light implements Cloneable {
	private int size=0;
	public void setSize(int size){
		this.size = size;
	}
	public void print(){
		System.out.println("light's size is "+size);
	}
	public Object clone()
	{
		try{
	           return this.getClass().newInstance();
	        }
	        catch(Exception e)
	        {
	           e.printStackTrace();
	           return null;
	        } 
	}
}
	
public static void main(String args[]){ 
	Light light = new Light();
	light.setSize(10);
		
	Light newLight = (Light)light.clone();
	newLight.print();
}






六、惰性初始模式



惰性初始是一种拖延战术。在第一次需求出现以前，先延迟创建物件、计算值或其它昂贵程序。

这通常是以一个旗号来实现，用旗号来标示是否完成其程式。每次请求对象时，会先测试此旗号。如果以完成，直接传回，否则当场执行。

示例：


public class Fruit
{
	private static final Map<String,Fruit> types = new HashMap<String,Fruit>();
	private final String type;
	private Fruit(String type) {
		this.type = type;
	}
	public static synchronized Fruit getFruit(String type) {
	if(!types.containsKey(type))
		types.put(type, new Fruit(type)); // Lazy initialization
	return types.get(type);
	}
}

七、对象池模式

一个对象池是一组已经初始化过且可以使用的物件，而可以不用在有需求时创建和销毁物件。池的用户可以从池子中取得对象，对其进行操作处理，当使用完该对象后，则将该对象的归还给对象池，而不是去销毁它，这是一种特殊的工厂对象。


示例：


public class Light{
	private int size;
	public void setSize(int size){
		this.size = size;
	}
	public int getSize(){
		return size;
	}
}
public class LightUnit{
	private List<Light> lightList = new ArrayList<Light>();
	private List<Boolean> flagList = new ArrayList<Boolean>();
	public LightUnit(){ }
		
	public synchronized void addItem() {
		Light entity = new Light();
	        lightList.add(entity);
	        flagList.add(false);
	}
	private synchronized Light getItem() {
		int iLength = lightList.size();
	        for (int i=0;i<iLength;i++) {
	    		if(!flagList.get(i)){
	           		flagList.set(i, true);
	           		return flagList.get(i);
	        	}
 }return null;}



	public boolean releaseItem(Light light){
		int index = lightList.indexOf(light);
		if(index == -1){
			return false;
		}
		if(flagList.get(index)){
			flagList.set(index, false);
			return true;
		}
 return false;

}}