單一職責原則（Single Responsibility Principle）

定義：一個物件應該只包含單一的職責，並且該職責被完整地封裝在一個類中。即：不要存在多於一個導致類變更的原因。通俗的說，就是一個類只負責一項職責。

問題由來：類T負責兩個不同的職責：職責P1，職責P2。當由於職責P1需求發生改變而需要修改類T時，有可能會導致原本執行正常的職責P2功能發生故障。

解決方案：遵循單一職責原則。分別建立兩個類T1、T2，使T1完成職責P1功能，T2完成職責P2功能。這樣，當修改類T1時，不會使職責P2發生故障風險；同理，當修改T2時，也不會使職責P1發生故障風險。

  雖然單一職責原則看起來如此簡單，但由於職責擴散，即便是經驗豐富的程式設計師寫出的程式，也會有違背這一原則的程式碼存在。所謂職責擴散，就是因為某種原因，職責P被分化成粒度更細的職責P1和P2。

  比如：開始時，類T只負責一個職責P，這符合單一職責原則。後來由於某種原因，需要將職責P細分為粒度更細的職責P1、P2，這時如果要使程式遵循單一職責原則，需要將類T也分解為兩個類T1和T2，來分別負責P1、P2兩個職責。但是在程式已經寫好的情況下，這樣做將會耗費大量時間和精力，所以，簡單地修改類T，用它來負責兩個職責是一個比較不錯的選擇，雖然這違背了單一職責原則。

  舉例說明，用一個類描述動物吃東西這個場景：

class Animal{
    public void eat(String animal){
       System.out.println(animal+"吃草");
    }
}

public class Client{
    public static void main(String[] args){
       Animal animal = new Animal();
       animal.eat("牛");
       animal.eat("羊");
       animal.eat("馬");
    }
}

執行結果：

牛吃草
羊吃草
馬吃草
 

  程式上線後，發現問題了，並不是所有的動物都是吃草的，比如狼就是吃肉的。修改時如果遵循單一職責原則，需要將Animal類細分為食草動物Herbivore和肉食性動物Carnivora，程式碼如下：

class Herbivore{
    public void eat(String animal){
       System.out.println(animal+"吃草");
    }
}

class Carnivora{
    public void eat(String animal){
       System.out.println(animal+"吃肉");
    }
}

public class Client{
    public static void main(String[] args){
       Herbivore herbivore = new Herbivore();
       herbivore.eat("牛");
       herbivore.eat("羊");
       herbivore.eat("馬");

       Carnivora carnivora = new Carnivora();
       carnivora.eat("狼");
    }
} 

執行結果：

牛吃草
羊吃草
馬吃草
狼吃肉
 

  我們發現這樣修改花銷是很大的，除了將原來的類分解之外，還需要修改客戶端。而直接修改類Animal來達成目的雖然違背了單一職責原則，但花銷卻要小的多，程式碼如下：

class Animal{
	public void eat(String animal){
		if("狼".equals(animal)){
			System.out.println(animal+"吃肉");
		}else{
			System.out.println(animal+"吃草");
		}
    }
}

public class Client{
	public static void main(String[] args){
		Animal animal = new Animal();
		animal.eat("牛");
		animal.eat("羊");
		animal.eat("馬");
		animal.eat("狼");
	}
}

  可以看到，這種修改方式要簡單得多，但是卻存在著隱患：有一天需要將狼分為北極狼和非北極狼，則又需要修改Animal類的eat方法，而對原有程式碼的修改會呼叫“牛”、“羊”、“馬”等相關功能帶來風險，也許某一天你會發現程式執行結果變成了“非北極狼吃草”了。這種修改方式直接在程式碼級別上違背了單一職責原則，雖然修改起來最簡單，但是隱患也是最大的。還有一種修改方式：

class Animal{
	public void eat(String animal){
		System.out.println(animal+"吃草");		
    }

	public void eat2(String animal){
		System.out.println(animal+"吃肉");		
    }
}

public class Client{
	public static void main(String[] args){
		Animal animal = new Animal();
		animal.eat("牛");
		animal.eat("羊");
		animal.eat("馬");
		animal.eat2("狼");
	}
}

  可以看到，這種修改方式沒有改動原來的方法，而是在類中新加了一個方法，這樣雖然也違背了單一職責原則，但在方法級別上卻是符合單一職責原則的，因為它並沒有動原來方法的程式碼。

  這三種方式各有優缺點，那麼在實際程式設計中，採用哪一種呢？其實這真的比較難說，需要根據實際情況來確定。我的原則是：只有邏輯足夠簡單，才可以在程式碼級別上違反單一職責原則；只有類中方法數量足夠少，才可以在方法級別上違反單一職責原則。在實際應用中的類都要複雜得多，一旦發生職責擴散而需要修改類時，除非這個類本身非常簡單，否則還是遵循單一職責原則的好。

遵循單一職責原則的優點：

1、降低類的複雜性，類的職責清晰明確；

2、提高類的可讀性和可維護性；

3、變更引起的風險降低，變更是必然的，如果單一職責原則遵守的好，當修改一個功能時，可以顯著降低對其他功能的影響。

原文：http://www.cnblogs.com/lhws/archive/2012/03/10/2389189.html