所謂單一職責原則，就是就一個類而言，應該僅有一個引起它的變化的原因。換句話說，一個類的功能要單一，只做與它相關的事情。
這個原則是最簡單、最容易理解，卻是最不容易做到的事情。這個原則的道理誰都理解，可是在實踐中呢？

　　我們來看一個例子：

if(action.equals("load")&&tab.equals("1")){
request.setAttribute("tabId",tab);
form.set("tabId",tab);
speciManager.loadIncrement(actionForm, request, tab);
}
if(action.equals("Save")&&tab.equals("1")){
System.out.println("inter increment save action");
……
request.setAttribute("tabId",tab);
}
if(action.equals("load")&&tab.equals("2")){
request.setAttribute("tabId",tab);
form.set("tabId",tab);
speciManager.loadMeasureMent(actionForm, request, tab);
}
if(action.equals("Save")&&tab.equals("2")){
……
System.out.println("inter increment save action");
speciManager.loadIncrement(actionForm, request, tab);
form.set("tabId",tab);
request.setAttribute("tabId",tab);

}

　　一看就知道這個類做了太多的工作，它既要load一個tab為1的頁面和一個tab為2的頁面；又要save一個tab為1頁面和一個tab為2的頁面。這個類的代碼我只截取了里面很少的一部分，絕大部分的代碼我都省略掉了。這段代碼寫到最后是越來越混亂，直到最后失敗。

　　對照著這個例子，我們再來分析一下為什么要遵守單一職責愿則：

　　第一、有助于我們分析和編碼的思路的清晰。當你的代碼里有了三層或以上的if語句或for語句的嵌套的時候，你不要跟我說，你已經把問題分析得很清楚了。多層嵌套的if或for語句只能說明你還沒有把問題分析清楚。

　　第二、使我們的編碼、測試和維護變得簡單。

　　第三、將一個個復雜的問題簡單化以后，易于代碼的重用。當你的代碼的多個功能攪和在一起的時候，你是沒辦法考慮代碼的重用的，因為你的每一處代碼都有不同。

　　第四、易于系統的擴展。

　　好了，在這里一二三四的列舉單一職責的原則不管用，我們需要看看實際的效果才好。現在我們就來看看模式是怎么來遵守這一原則的：
首先，我們來看簡單工廠模式。工廠類只有一個功能，就是產生一個個的對象產品。就這么一個簡單的功能，但如果我們不把它拿出來，在客戶端就會出現這樣的代碼：

if(type.equals(“apple”))
{
Apple apple = new Apple();
……
}
else if(type.equals(“orange”))
{
Orange orange = new Orange();
……
}
else if(type.equals(“Banana”))
{
Banana banana = new Banana();
……
}

　　有了工廠，我們的客戶端就變成這樣：

Fruit fruit = Factory.getInstance(type);
……

　　我們的客戶端調用起來多么的簡單，而且系統擴展起來也與客戶端無關。

　　我們再來看模板方法模式。

public abstract class Template {

public void totalAction()
{
commonAction();
differentAction();
}
private void commonAction()
{
//......
}
public abstract void differentAction();

}

　　這是一個模板類，它只做了一件事，就是所有子類的共同行為；然后去由它的子類單獨完成自己的不同的行為。

　　這樣的蓄意讓類的職責單一，擁有的好處是：第一、所有的子類的共同行為，只在模板類里構造一次，實現了代碼的重用。第二、將各子類不同的行為分配到各子類里去，使得子類極為簡單，易于實現。

　　命令模式和策略模式的原理都相同，命令模式是對行為的封裝，而策略模式是對算法的封裝。兩者都是要把相同的關注點和對他們的調用分離開，如命令模式是將行為和對它們的調用分離開，而策略模式是將算法和對它們的調用分離開。這里我們只以命令模式來說明問題。

If(condition1)
{
//condition1下的行為
doThing1();
}
else if(condition2)
{
//condition2下的行為
doThing2();
}
else if(condition3)
{
//condition3下的行為
doThing3();
}
……

　　命令模式可以方便的對上面的代碼進行優化：

public interface Common
{
public void doThing();
}
public class Common1 implements Common
{
public void doThing()
{
//condition1下的行為
doThing1();
}
}
public class Common2 implements Common
{
public void doThing()
{
//condition2下的行為
doThing2();
}
}
public class Common13implements Common
{
public void doThing()
{
//condition3下的行為
doThing3();
}

}

　　客戶端：

Common common;
If(condition1) common = new Common1();
else if(condition2) common = new Common2();
else if(condition3) common = new Common3();
common.doThing();

　　命令模式通過將行為從調用者那里分離出來，達到了下面幾個目的：第一，分離關注，對各個行為進行單獨的關注，減少錯誤的出現。不管是對行為類還是它的調用者，都變得簡單。第二，行為類通過對接口的實現，使得它們的調用者可以對它們進行動態綁定，增加了程序的靈活性和擴展性。

　　代理模式將一個類的核心功能和它的附加功能區別開來，分別放在不同的類里面，從而使每一個類的功能更加單一。

Public interface ProxyInterface
{
public void doing();
}
public class MainClass implements ProxyInterface
{
public void doing()
{
//core function
……
}
}
public class ProxyClass implements ProxyInterface
{
private ProxyInterface core = new MainClass();
public void doing()
{
//appending to do
……
//main function
core.doing();
}
}

　　我們可以看到，通過代理模式，上面的MainClass類用來實現核心功能，而ProxyClass類用來實現附加功能，這樣使得兩個類的功能都非常簡單，易于實現。

　　總之，單一職責原則是一個既簡單又實用的原則。我們遵守了這一原則，可能會多寫一些類和代碼，但磨刀不誤砍柴工。該原則既有利于我們編碼思路的清晰，又大大增強了代碼的可維護性和擴展性。
還等什么呢？