形式一."見兔撒鷹".
如果有一個類有一個集合成員,可以在爲此成員添加元素時再把具體集合建立起來,以免浪費空間和時間.
例:
1 public class Company{
2 private List members=null;
3
4 public void addMember(Member member){
5 if(members=null){
6 members=new ArrayList();
7 }
8
9 members.add(member);
10 }
11 }
12
異曲同工的另外一個例子:
1 public class Singleton{
2 private static Singleton instance=null;
3
4 public static synchronized Singleton getInstance(){
5 // 要用的時候再把Singleton建立起來
6 if(instance==null){
7 instance=new Singleton();
8 }
9
10 return instance;
11 }
12 }
13
形式二."只管結果,不顧過程"
從集合中取區間元素時,可以直接從上下限之間取來,讓try...catch...去處理越界的事.
題設:有個數不定元素的列表(allTodoes),需要從中取N個,起始位置不限,你怎麼編寫程序.
很多人開始進行越界的判斷,出來一堆if else,有時還需要在紙上寫好思路,完畢後還有多方測試,生怕出錯,即使編寫好後其他人維護起來也是小心翼翼的.其實沒必要這麼麻煩.
例.
1 int start=pageIndex*pageSize;
2 int end=start+pageSize;
3
4 for(int i=start;i<end;i++){
5 try{
6 todoResult.addTodo((Todo)allTodoes.get(i));
7 }
8 catch(Exception ex){
9 continue;
10 }
11 }
題外話:分支和循環語句天生就不容易理解,尤其是在嵌套較深的時候,因爲這是機器的思維特性.還是try...catch...比較貼近人類思維.
形式三."奉旨行事"
在查詢中,如果把查詢條件和遴選過程分開來更有益,程序也因此解耦合.這纔是OO化的查詢.
需求:從公司的職員列表中,找出男性且年齡大於22的成員.
傳統寫法:
1 List allmembers=company.getMembers();// 取得所有成員
2 List results=new ArrayList();// 結果列表
3
4 for(Iterator it=allmembers.iterator();it.hasNext();){
5 Member member=(Member)it.next();
6
7 if(member.getAge()>22 && member.isMale()){ // 篩選,這裏是把查詢條件和遴選過程融合在一起,條件一變立即就得加個分支.
8 results.add(member);
9 }
10 }
11
這種寫法沒有錯,但是不是面向對象的寫法,它有以下缺陷:
1.查詢條件和篩選過程沒有分離.
2.這樣寫的後果使Company變成了一個失血模型而不是領域模型.
3.換查詢條件的話,上面除了"篩選"一句有變化外其它都是模板代碼,重複性很高.
真正符合OO的查詢應該是這樣:
1 MemberFilter filter1=new MemberFilter(){
2 public boolean accept(Member member) {
3 return member.isMale() && member.getAge()>22;
4 }
5 };
6
7 List ls=company.listMembers(filter1);
這段代碼成功的把查詢條件作爲一個接口分離了出去,接口代碼如下:
1 public interface MemberFilter{
2 public boolean accept(Member member);
3 }
而類Company增加了這樣一個函數:
1 public List listMembers(MemberFilter memberFilter){
2 List retval=new ArrayList();
3
4 for(Iterator it=members.iterator();it.hasNext();){
5 Member member=(Member)it.next();
6
7 if(memberFilter.accept(member)){
8 retval.add(member);
9 }
10 }
11
12 return retval;
13 }
這就把模板代碼歸結到了類內部,外面不會重複書寫了.Company也同時擁有了數據和行爲,而不是原來的數據容器了.
形式四."化繁爲簡"
這種結構將多個分支語句變換爲一個查表結構,這樣做對擴充程序結構,修改具體數額都很方便,使程序更易於維護.還可以把歸結出的表結構放在持久介質中如XML文件,數據庫等,用到的時候再取,這樣做在條件變化時不需要修改程序.
原始代碼(VB代碼,但應該不妨礙理解):
1 Dim count1
2 count1 = salary.Value + USA.Value * Drate + JAN.Value * Jrate - 4000
3 If count1 < 500 Then
4 tax.Value = count1 * 0.05
5 ElseIf count1 < 2000 Then
6 tax.Value = count1 * 0.1 - 25
7 ElseIf count1 < 5000 Then
8 tax.Value = count1 * 0.15 - 125
9 ElseIf count1 < 20000 Then
10 tax.Value = count1 * 0.2 - 375
11 ElseIf count1 < 40000 Then
12 tax.Value = count1 * 0.25 - 1375
13 ElseIf count1 < 60000 Then
14 tax.Value = count1 * 0.3 - 3375
15 Else
16 tax.Value = count1 * 0.3 - 3375
17 End If
變換如下:
這是個稅率計算的語句段，公式是確定的：稅=月薪*稅率-折扣，稅率又和月薪有關係，月薪越高稅率越高，首先這裏可以歸納出一個基本類：
1 public class TaxItem{
2 float limit; // 月薪界限
3 float ratio;// 稅率
4 float discount;// 折扣
5
6 public TaxItem(float limit,float ratio,float discount){
7 this.limit=limit;
8 this.ratio=ratio;
9 this.discount=discount;
10 }
11
12 public TaxItem(){
13 this(0.0f,0.0f,0.0f);
14 }
15
16 public float getDiscount() {
17 return discount;
18 }
19
20 public float getLimit() {
21 return limit;
22 }
23
24 public float getRatio() {
25 return ratio;
26 }
27 }
28
29
然後就是稅計算類：
1 public class TaxCaculator{
2 private static ArrayList list=new ArrayList();
3
4 public TaxCaculator(){
5 // 這裏把各個等級加入到鏈表中，注意添加順序是由小到大
6 list.add(new TaxItem(500.0f,0.05f,0.0f));
7 list.add(new TaxItem(2000.0f,0.1f,25.0f));
8 list.add(new TaxItem(5000.0f,0.15f,125.0f));
9 list.add(new TaxItem(20000.0f,0.2f,375.0f));
10 list.add(new TaxItem(40000.0f,0.25f,1375.0f));
11 list.add(new TaxItem(60000.0f,0.3f,3375.0f));
12 }
13
14 // 這個函數用來計算所得稅
15 public float getTax(float salary){
16 TaxItem item=new TaxItem();
17
18 for(int i=0;i<list.size();i++){
19 item=(TaxItem)list.get(i);
20
21 if(salary>item.getLimit()){
22 continue;
23 }
24 else{
25 break;
26 }
27 }
28
29 // 返回最終結果，當然，這個公式也可以放在TaxItem 類中，這裏就見仁見智了。
30 return salary*item.getRatio()-item.getDiscount();
31 }
32 }
調用如下 :
1 TaxCaculator taxCaculator=new TaxCaculator();
2
3 float salary=1000.f;
4 System.out.println("Salary="+salary +" Tax="+taxCaculator.getTax(salary));
5
6 salary=2000.f;
7 System.out.println("Salary="+salary +" Tax="+taxCaculator.getTax(salary));
8
9 salary=3000.f;
10 System.out.println("Salary="+salary +" Tax="+taxCaculator.getTax(salary));
形式五."分而治之"
該結構將分支語句的執行部分分散到單獨的類中處理,降低了系統耦合度,程序也更容易維護.
舉例如下:
在日常工作中，我們經常需要解析一段字符串並交由相應的函數進行處理，例如TCP/IP通信中的命令解析和用戶自定義文件解析等場合，通常的處理方法是這樣：
if(命令==”AAA”){
函數AAA執行；
}
else if(命令==”BBB”){
函數BBB執行；
}
.
.
.
else{
函數XXX執行；
}
這種方法在命令較少時是有效的，當命令衆多時，if語句和相關的函數將會形成一個巨集，給檢查，維護和擴充帶來了很大的不便，久而久之將會成爲系統性能提升的瓶頸。
一個成功的軟件程序必須儘可能簡單並易於重構和擴展，在命令模式和Java反射機制的幫助下，我們可以從容解決上述問題，達到簡單並易於重構和擴展的要求。以下將簡要說明解決方案。
1. 製作一個命令的抽象接口.
1 public interface Command{
2 public abstract void execute(String[] args);
3 }
2. 讓每種命令都實現這個接口.
1 // 命令一
2 public class CommandType01 implements Command{
3 public void execute(String[] args){
4 System.out.println("/n commandType01 start!");
5 System.out.print("/t commandType01 Length="+args.length);
6 System.out.println("/n commandType01 End!");
7 }
8 }
9
10 // 命令二
11 public class CommandType02 implements Command{
12 public void execute(String[] args){
13 System.out.println("/n commandType02 start!");
14
15 System.out.print("/t commandType02 is:");
16 for(String item:args){
17 System.out.print("/t "+item);
18 }
19
20 System.out.println("/n commandType02 End!");
21 }
22 }
23
24 // 命令三
25 public class CommandType03 implements Command{
26 public void execute(String[] args){
27 System.out.println("/n commandType03 start!");
28 System.out.print("/t commandType03 last Nation="+args[args.length-1]);
29 System.out.println("/n commandType03 End!");
30 }
31 }
32
33
讓每種命令都實現execute接口的用意是強制每個命令的執行方式一致,簡化調用時的處理,但執行內容應該根據實際情況決定.
例如
命令一的執行內容是輸出參數的個數
命令二的執行內容是輸出參數的內容
命令三的執行內容是輸出最後一個參數
3. 將命令防置到命令中心中去
命令中心類的代碼如下:
1 public class Mediation{
2 Command cmmd;// 命令對象的引用
3 String[] cmmdArgs;// 參數列表
4
5 public Mediation(){
6
7 }
8
9 public void fetchCommand(String strCmmd){
10 cmmdArgs=strCmmd.split("/s+");// 分析原始命令
11
12 String className="Command"+cmmdArgs[0];// 根據分析後命令的第一個參數得到類名
13
14 try{
15 Class cls=Class.forName(className);// 利用反射機制得到類
16 cmmd=(Command)cls.newInstance();// 由類得到類實例
17 }
18 catch(Exception ex){
19 ex.printStackTrace();
20 }
21 }
22
23
24 public void executeCommand(){
25 cmmd.execute(cmmdArgs);// 執行命令對象的execute方法
26 }
27
28 }
4．執行過程
1 Mediation mediation = new Mediation();
2 // 取得命令一併執行
3 mediation.fetchCommand("Type01 AB CD");
4 mediation.executeCommand();
5
6 // 取得命令二並執行
7 mediation.fetchCommand("Type02 1 2 3 4");
8 mediation.executeCommand();
9
10 // 取得命令三並執行
11 mediation.fetchCommand("Type03 USA Russia China");
12 mediation.executeCommand();
13
執行效果如下：
commandType01 start!
commandType01 Length=3
commandType01 End!
commandType02 start!
commandType02 is: Type02 1 2 3 4
commandType02 End!
commandType03 start!
commandType03 last Nation=China
commandType03 End!
由上可見，我們使用反射機制消除了龐大的分支語句，把命令的執行過程分散到了Command的各個子類中，降低了命令類和控制中心類的耦合程度，達到了簡單並易於重構和擴展的要求。如果新增一種命令，只需增加Command的一個子類就可以了。
很多情況下命令的execute函數需要命令中心類或者其它類的信息，這時可以在Command接口類和Command的子類中間添加一個類CommandBase，在其中包含一個命令中心類或者其它類的引用，並增加相應的getter/setter函數，Command的子類繼承這個類並實現Command的接口即可，最後在fetchCommand函數中傳入中心類或者其它類的引用即可。
注意:這裏對命令和Command的子類類名有特殊要求，即一種命令對應一種子類，子類類名可以由命令的首個參數簡單組合而來，否則還是避免不了分支語句。
以上五種組織形式,若加以靈活運用,相信能減少一些代碼臭味.