設計模式隨筆一

六個原則（Solid）

Single Responsibility Principle：單一職責原則--接口職責單一，類的設計儘量只有一個原因引起變化。

Open Closed Principle：開閉原則--一個軟件實體如類（抽象）、模塊、方法應該對擴展開放，對修改關閉。

Liskov Substitution Principle：里氏替換原則--父類能出現的地方，子類就可以替換父類。

Law of Demeter：迪米特法則--一個對象應該對其他對象有最少的瞭解（合理的公開public方法，儘量最少）。

Interface Segregation Principle：接口隔離原則--建立單一接口，不要建立臃腫龐大的接口（爲模塊提供單一接口）。

Dependence Inversion Principle：依賴倒置原則--面向接口（抽象類）編程。

設計模式

1.單例模式

確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例。

public final  class Singleton {

	private static final Singleton INSTANCE = new Singleton();
	
	private Singleton(){}
	
	public static Singleton getInstance() {
		return INSTANCE;
	}
	
	public static void otherMethod(){
		
	}
}

//多線程版本<pre class="java" name="code">public static Singleton getInstance(){      
    if (instance == null)      
        synchronized(instance){      
            if(instance == null)      
                instance = new Singleton();      
        }      
    return instance;       
}

//按需加載

public class Singleton{      
    private Singleton(){      
        …      
    }      
    private static class SingletonContainer{      
        private static Singleton instance = new Singleton();      
    }      
    public static Singleton getInstance(){      
        return SingletonContainer.instance;      
    }      
}

Note:在併發編程中，需要考慮同步處理。

2.工廠方法模式

定義一個用於創建對象的接口，讓子類決定實例化哪一個類。

在工廠方法模式中，抽象產品類Product負責定義產品的共性，實現對事物最抽象的定義。產品就是對象，就是要創建的對象。

一個通用的例子

	// 抽象產品：對象
	public abstract class Product {
		// 公共方法
		public void pubMethod() {
			// 具體邏輯實現
		}

		// 抽象方法
		public abstract void absMethod();
	}

	// 具體產品
	public class ConcreteProduct extends Product {
		private ConcreteProduct(){}
		@Override
		public void absMethod() {
			// 具體實現
		}
	}

	// 抽象工廠
	public abstract class Factory {
		// 創建產品，更加參數創建
		public abstract <T extends Product> T create(Class<T> clazz);
	}

	// 具體工廠
	public class ConcreteFactory extends Factory {
		@SuppressWarnings("unchecked")
		@Override
		public <T extends Product> T create(Class<T> clazz) {
			try {
				Product product = null;
				product = (Product) Class.forName(clazz.getName())
						.newInstance();
				return (T) product;
			} catch (Exception e) {
				e.printStackTrace();
			}
			return null;
		}

	}

	public static void main(String[] args) {
		Factory fac = new ConcreteFactory();
		Product pro = fac.create(ConcreteProduct.class);
	}

在單一場景中，修改爲簡單工廠模式

// 簡單工廠
	public class SimpleFactory  { 
		@SuppressWarnings("unchecked")
		public <T extends Product> T create(Class<T> clazz) {
			try {
				Product product = null;
				product = (Product) Class.forName(clazz.getName())
						.newInstance();
				return (T) product;
			} catch (Exception e) {
				e.printStackTrace();
			}
			return null;
		}
	}

延遲初始化中應用工廠模式

public final class MapFactory {
	private static final Map<String, Product> map = new HashMap<>();

	public static synchronized Product create(String name) {
		Product p = null;
		if (map.containsKey(name)) {
			p = map.get(name);
		} else {
			p = new ConcreteProduct();
			map.put(name, p);
		}
		return p;
	}
}