基本原則

1. 儘量在合適的場合使用單例
使用單例可以減輕載入的負擔，縮短載入的時間，提高載入的效率，但並不是所有地方都適用於單例，簡單來說，單例主要適用於以下三個方面：
第一，控制資源的使用，通過執行緒同步來控制資源的併發訪問；
第二，控制例項的產生，以達到節約資源的目的；
第三，控制資料共享，在不建立直接關聯的條件下，讓多個不相關的程序或執行緒之間實現通訊。
2. 儘量避免隨意使用靜態變數
要知道，當某個物件被定義為static變數所引用，那麼GC通常是不會回收這個物件所佔有的記憶體，如

public class A{ 
   private static B b = new B(); 
}

• 1
• 2
• 3

此時靜態變數b的生命週期與A類同步，如果A類不會解除安裝，那麼b物件會常駐記憶體，直到程式終止。

3. 儘量避免過多過常的建立Java物件
儘量避免在經常呼叫的方法，迴圈中new物件，由於系統不僅要花費時間來建立物件，而且還要花時間對這些物件進行垃圾回收和處理，在我們可以控制的範圍內，最大限度的重用物件，最好能用基本的資料型別或陣列來替代物件。

4. 儘量使用final修飾符
帶有final修飾符的類是不可派生的。在JAVA核心API中，有許多應用final的例子，例如java.lang.String，為String類指定final防止了使用者覆蓋length()方法。另外，如果一個類是final的，則該類所有方法都是final的。java編譯器會尋找機會內聯（inline）所有的final方法（這和具體的編譯器實現有關）。此舉能夠使效能平均提高50%。
如：讓訪問例項內變數的getter/setter方法變成”final：
簡單的getter/setter方法應該被置成final，這會告訴編譯器，這個方法不會被過載，所以，可以變成”inlined”,例子：

class MAF { 
     public void setSize (int size) { 
          _size = size; 
     } 
     private int _size; 
}
 
更正
 
class DAF_fixed { 
     final public void setSize (int size) { 
          _size = size; 
     } 
     private int _size; 
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

5. 儘量使用區域性變數
呼叫方法時傳遞的引數以及在呼叫中建立的臨時變數都儲存在棧（Stack）中，速度較快。其他變數，如靜態變數，例項變數等，都在堆（Heap）中建立，速度較慢。

6. 儘量處理好包裝型別和基本型別兩者的使用場所
雖然包裝型別和基本型別在使用過程中是可以相互轉換，但它們兩者所產生的記憶體區域是完全不同的，基本型別資料產生和處理都在棧中處理，包裝型別是物件，是在堆中產生例項。在集合類物件，有物件方面需要的處理適用包裝型別，其他的處理提倡使用基本型別。

7. 慎用synchronized，儘量減小synchronize的方法
都知道，實現同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，所以儘量避免無謂的同步控制。synchronize方法被呼叫時，直接會把當前物件鎖 了，在方法執行完之前其他執行緒無法呼叫當前物件的其他方法。所以synchronize的方法儘量小，並且應儘量使用方法同步代替程式碼塊同步。

8. 儘量使用StringBuilder和StringBuffer進行字串連線

9. 儘量不要使用finalize方法
實際上，將資源清理放在finalize方法中完成是非常不好的選擇，由於GC的工作量很大，尤其是回收Young代記憶體時，大都會引起應用程式暫停，所以再選擇使用finalize方法進行資源清理，會導致GC負擔更大，程式執行效率更差。另外，不推薦用finalize方法的根本原因在於，JVM的規範並不保證何時執行該方法，所以用這個方法來釋放資源很不合適，有可能造成長時間資源得不到釋放。
10. 儘量使用基本資料型別代替物件

String str = "hello";

• 1

上面這種方式會建立一個“hello”字串，而且JVM的字元快取池還會快取這個字串；

String str = new String("hello");

• 1

此時程式除建立字串外，str所引用的String物件底層還包含一個char[]陣列，這個char[]陣列依次存放了h,e,l,l,o

11. 多執行緒使用map、list原則
在未發生執行緒安全前提下應儘量使用HashMap、ArrayList，HashTable、Vector等使用了同步機制，降低了效能。

12. 儘量合理的建立HashMap
當你要建立一個比較大的hashMap時，充分利用這個建構函式

public HashMap(int initialCapacity, float loadFactor); 

• 1

避免HashMap多次進行了hash重構,擴容是一件很耗費效能的事，在預設中initialCapacity只有16，而loadFactor是 0.75，需要多大的容量，你最好能準確的估計你所需要的最佳大小，同樣的Hashtable，Vectors也是一樣的道理。

13. 儘量減少對變數的重複計算
如：

for(int i=0;i<list.size();i++)

• 1

應該改為

for(int i=0,len=list.size();i<len;i++)

• 1

並且在迴圈中應該避免使用複雜的表示式，在迴圈中，迴圈條件會被反覆計算，如果不使用複雜表示式，而使迴圈條件值不變的話，程式將會執行的更快。

14. 儘量避免不必要的建立
如：

A a = new A();
 
if(i==1){list.add(a);}
應該改為
if(i==1){
  A a = new A();
  list.add(a);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

15. 儘量在finally塊中釋放資源
程式中使用到的資源應當被釋放，以避免資源洩漏。這最好在finally塊中去做。不管程式執行的結果如何，finally塊總是會執行的，以確保資源的正確關閉。

16. 儘量確定StringBuffer的容量
StringBuffer 的構造器會建立一個預設大小（通常是16）的字元陣列。在使用中，如果超出這個大小，就會重新分配記憶體，建立一個更大的陣列，並將原先的陣列複製過來，再 丟棄舊的陣列。在大多數情況下，你可以在建立 StringBuffer的時候指定大小，這樣就避免了在容量不夠的時候自動增長，以提高效能。
如：
StringBuffer buffer = new StringBuffer(1000);

17. 儘量早釋放無用物件的引用
大部分時，方法區域性引用變數所引用的物件 會隨著方法結束而變成垃圾，因此，大部分時候程式無需將區域性，引用變數顯式設為null。
例如：
Java程式碼

Public void test(){      
  Object obj = new Object();      
  …… 
 
  Obj=null;      
}

• 1
• 2
• 3
• 4
• 5
• 6

上面這個就沒必要了，隨著方法test()的執行完成，程式中obj引用變數的作用域就結束了。但是如果是改成下面：

   Public void test(){      
      Object obj = new Object();      
      ……      
      Obj=null;      
      //執行耗時，耗記憶體操作；或呼叫耗時，耗記憶體的方法     
      …… 
  }

• 1
• 2
• 3
• 4
• 5
• 6
• 7

這時候就有必要將obj賦值為null，可以儘早的釋放對Object物件的引用。

18. 儘量避免使用二維陣列
二維資料佔用的記憶體空間比一維陣列多得多，大概10倍以上。

19. 儘量避免使用split
除非是必須的，否則應該避免使用split，split由於支援正則表示式，所以效率比較低，如果是頻繁的幾十，幾百萬的呼叫將會耗費大量資源，如果確實需要頻繁的呼叫split，可以考慮使用apache的StringUtils.split(string,char)，頻繁split的可以快取結果。

20. ArrayList & LinkedList
一個是線性表，一個是連結串列，一句話，隨機查詢儘量使用ArrayList，ArrayList優於LinkedList，LinkedList還要移動指標，新增刪除的操作LinkedList優於ArrayList，ArrayList還要移動資料，不過這是理論性分析，事實未必如此，重要的是理解好2者得資料結構，對症下藥。

21. 儘量使用System.arraycopy ()代替通過來迴圈複製陣列
System.arraycopy() 要比通過迴圈來複制陣列快的多

22. 儘量快取經常使用的物件
儘可能將經常使用的物件進行快取，可以使用陣列，或HashMap的容器來進行快取，但這種方式可能導致系統佔用過多的快取，效能下降，推薦可以使用一些第三方的開源工具，如EhCache，Oscache進行快取，他們基本都實現了FIFO/FLU等快取演算法。

23. 儘量避免非常大的記憶體分配
有時候問題不是由當時的堆狀態造成的，而是因為分配失敗造成的。分配的記憶體塊都必須是連續的，而隨著堆越來越滿，找到較大的連續塊越來越困難。

24. 慎用異常
當建立一個異常時，需要收集一個棧跟蹤(stack track)，這個棧跟蹤用於描述異常是在何處建立的。構建這些棧跟蹤時需要為執行時棧做一份快照，正是這一部分開銷很大。當需要建立一個 Exception 時，JVM 不得不說：先別動，我想就您現在的樣子存一份快照，所以暫時停止入棧和出棧操作。棧跟蹤不只包含執行時棧中的一兩個元素，而是包含這個棧中的每一個元素。
如果您建立一個 Exception ，就得付出代價。好在捕獲異常開銷不大，因此可以使用 try-catch 將核心內容包起來。從技術上講，您甚至可以隨意地丟擲異常，而不用花費很大的代價。招致效能損失的並不是 throw 操作——儘管在沒有預先建立異常的情況下就丟擲異常是有點不尋常。真正要花代價的是建立異常。幸運的是，好的程式設計習慣已教會我們，不應該不管三七二十一就丟擲異常。異常是為異常的情況而設計的，使用時也應該牢記這一原則。

25. 儘量重用物件
特別是String物件的使用中，出現字串連線情況時應使用StringBuffer代替，由於系統不僅要花時間生成物件，以後可能還需要花時間對這些物件進行垃圾回收和處理。因此生成過多的物件將會給程式的效能帶來很大的影響。

26. 不要重複初始化變數
預設情況下，呼叫類的建構函式時，java會把變數初始化成確定的值，所有的物件被設定成null，整數變數設定成0，float和double變數設定成0.0，邏輯值設定成false。當一個類從另一個類派生時，這一點尤其應該注意，因為用new關鍵字建立一個物件時，建構函式鏈中的所有建構函式都會被自動呼叫。
這裡有個注意，給成員變數設定初始值但需要呼叫其他方法的時候，最好放在一個方法比如initXXX()中，因為直接呼叫某方法賦值可能會因為類尚未初始化而拋空指標異常，如：public int state = this.getState();

27. 資料庫語句儘量使用大寫
在java+Oracle的應用系統開發中，java中內嵌的SQL語言應儘量使用大寫形式，以減少Oracle解析器的解析負擔。

28. 及時關閉資料連線
在java程式設計過程中，進行資料庫連線，I/O流操作，在使用完畢後，及時關閉以釋放資源。因為對這些大物件的操作會造成系統大的開銷。

29. 不使用的物件及時設定為null
過分的建立物件會消耗系統的大量記憶體，嚴重時，會導致記憶體洩漏，因此，保證過期的物件的及時回收具有重要意義。JVM的GC並非十分智慧，因此建議在物件使用完畢後，手動設定成null。
大部分時，方法區域性引用變數所引用的物件 會隨著方法結束而變成垃圾，因此，大部分時候程式無需將區域性、引用變數顯式設為null。
例如：

Public void test(){ 
Object obj = new Object(); 
…… 
Obj=null; 
} 
上面這個就沒必要了，隨著方法test()的執行完成，程式中obj引用變數的作用域就結束了。但是如果是改成下面：
Public void test(){ 
Object obj = new Object(); 
…… 
Obj=null; 
//執行耗時，耗記憶體操作；或呼叫耗時，耗記憶體的方法 
…… 
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

30. 不要在迴圈中使用Try/Catch語句，應把Try/Catch放在迴圈最外層

Error是獲取系統錯誤的類，或者說是虛擬機器錯誤的類。不是所有的錯誤Exception都能獲取到的，虛擬機器報錯Exception就獲取不到，必須用Error獲取。

31. 通過StringBuffer的建構函式來設定他的初始化容量，可以明顯提升效能

StringBuffer的預設容量為16，當StringBuffer的容量達到最大容量時，她會將自身容量增加到當前的2倍+2，也就是2*n+2。無論何時，只要StringBuffer到達她的最大容量，她就不得不建立一個新的物件陣列，然後複製舊的物件陣列，這會浪費很多時間。所以給StringBuffer設定一個合理的初始化容量值，是很有必要的

32. 合理使用java.util.Vector

Vector與StringBuffer類似，每次擴充套件容量時，所有現有元素都要賦值到新的儲存空間中。Vector的預設儲存能力為10個元素，擴容加倍。
vector.add(index,obj) 這個方法可以將元素obj插入到index位置，但index以及之後的元素依次都要向下移動一個位置（將其索引加 1）。 除非必要，否則對效能不利。同樣規則適用於remove(int index)方法，移除此向量中指定位置的元素。將所有後續元素左移（將其索引減 1）。返回此向量中移除的元素。所以刪除vector最後一個元素要比刪除第1個元素開銷低很多。刪除所有元素最好用removeAllElements()方法。
如果要刪除vector裡的一個元素可以使用 vector.remove(obj)；而不必自己檢索元素位置，再刪除，如

int index = indexOf（obj）;vector.remove(index)；

• 1

33. 不用new關鍵字建立物件的例項
用new關鍵詞建立類的例項時，建構函式鏈中的所有建構函式都會被自動呼叫。但如果一個物件實現了Cloneable介面，我們可以呼叫她的clone()方法。clone()方法不會呼叫任何類建構函式。
下面是Factory模式的一個典型實現：

    public static Credit getNewCredit() 
    { 
        return new Credit(); 
    } 
    改進後的程式碼使用clone()方法：
    private static Credit BaseCredit = new Credit(); 
    public static Credit getNewCredit() 
    { 
        return (Credit)BaseCredit.clone(); 
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

34. HaspMap的遍歷

Map<String, String[]> paraMap = new HashMap<String, String[]>(); 
for( Entry<String, String[]> entry : paraMap.entrySet() ) 
{ 
    String appFieldDefId = entry.getKey(); 
    String[] values = entry.getValue(); 
}

• 1
• 2
• 3
• 4
• 5
• 6

利用雜湊值取出相應的Entry做比較得到結果，取得entry的值之後直接取key和value。

35. array(陣列)和ArrayList的使用
array 陣列效率最高，但容量固定，無法動態改變，ArrayList容量可以動態增長，但犧牲了效率。

36. StringBuffer,StringBuilder的區別
java.lang.StringBuffer 執行緒安全的可變字元序列。一個類似於String的字串緩衝區，但不能修改。StringBuilder與該類相比，通常應該優先使用StringBuilder類，因為她支援所有相同的操作，但由於她不執行同步，所以速度更快。為了獲得更好的效能，在構造StringBuffer或StringBuilder時應儘量指定她的容量。當然如果不超過16個字元時就不用了。 相同情況下，使用StringBuilder比使用StringBuffer僅能獲得10%~15%的效能提升，但卻要冒多執行緒不安全的風險。綜合考慮還是建議使用StringBuffer。

37. 儘量使用基本資料型別代替物件。

38. 考慮使用靜態方法
如果你沒有必要去訪問物件的外部，那麼就使你的方法成為靜態方法。她會被更快地呼叫，因為她不需要一個虛擬函式導向表。這同事也是一個很好的實踐，因為她告訴你如何區分方法的性質，呼叫這個方法不會改變物件的狀態。

39. 應儘可能避免使用內在的GET,SET方法
40. 避免在迴圈條件中使用複雜表示式
在不做編譯優化的情況下，在迴圈中，迴圈條件會被反覆計算，如果不使用複雜表示式，而使迴圈條件值不變的話，程式將會執行的更快。例子：

import java.util.Vector; 
    class CEL { 
         void method (Vector vector) { 
             for (int i = 0; i < vector.size (); i++)   // Violation 
                 ; // ... 
         } 
    } 
    
    更正：    
    
    class CEL_fixed { 
         void method (Vector vector) { 
             int size = vector.size () 
             for (int i = 0; i < size; i++) 
                 ; // ... 
         } 
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

41. 為’Vectors’ 和 'Hashtables’定義初始大小
JVM為Vector擴充大小的時候需要重新建立一個更大的陣列，將原原先陣列中的內容複製過來，最後，原先的陣列再被回收。可見Vector容量的擴大是一個頗費時間的事。
通常，預設的10個元素大小是不夠的。你最好能準確的估計你所需要的最佳大小。例子：

import java.util.Vector; 
public class DIC { 
     public void addObjects (Object[] o) { 
         // if length > 10, Vector needs to expand 
         for (int i = 0; i< o.length;i++) {    
             v.add(o);    // capacity before it can add more elements. 
         } 
     } 
     public Vector v = new Vector();   // no initialCapacity. 
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

更正：
自己設定初始大小。

public Vector v = new Vector(20);  
public Hashtable hash = new Hashtable(10);

• 1
• 2

42. 在finally塊中關閉Stream
程式中使用到的資源應當被釋放，以避免資源洩漏。這最好在finally塊中去做。不管程式執行的結果如何，finally塊總是會執行的，以確保資源的正確關閉。
43. 對於常量字串，用’String’ 代替 'StringBuffer’
常量字串並不需要動態改變長度。
例子：

public class USC { 
     String method () { 
         StringBuffer s = new StringBuffer ("Hello"); 
         String t = s + "World!"; 
         return t; 
     } 
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7

更正：把StringBuffer換成String，如果確定這個String不會再變的話，這將會減少執行開銷提高效能。
44. 在字串相加的時候，使用 ’ ’ 代替 " "，
如果該字串只有一個字元的話
例子：

public class STR { 
     public void method(String s) { 
         String string = s + "d"   // violation. 
         string = "abc" + "d"       // violation. 
     } 
}

• 1
• 2
• 3
• 4
• 5
• 6

更正：將一個字元的字串替換成’ ’

public class STR { 
     public void method(String s) { 
         String string = s + 'd' 
         string = "abc" + 'd'   
     } 
}

• 1
• 2
• 3
• 4
• 5
• 6

類和方法優化

No.1：重複程式碼的提煉
重複程式碼是重構收效最大的手法之一，進行這項重構的原因不需要多說。它有很多很明顯的好處，比如總程式碼量大大減少，維護方便，程式碼條理更加清晰易讀。
它的重點就在於尋找程式碼當中完成某項子功能的重複程式碼，找到以後請毫不猶豫將它移動到合適的方法當中，並存放在合適的類當中。
小例項

class BadExample {

    public void someMethod1(){
        //code
        System.out.println("重複程式碼");/* 重複程式碼塊 */
        //code
    }
    
    public void someMethod2(){
        //code
        System.out.println("重複程式碼");/* 重複程式碼塊 */
        //code
    }    
}

/* ---------------------分割線---------------------- */

class GoodExample {

    public void someMethod1(){
        //code
        someMethod3();
        //code
    }
    
    public void someMethod2(){
        //code
        someMethod3();
        //code
    }
    
    public void someMethod3(){
        System.out.println("重複程式碼");/* 重複程式碼塊 */
    }    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35

No.2：冗長方法的分割
有關冗長方法的分割，其實有時候與重複程式碼的提煉是有著不可分割的關係的，往往在我們提煉重複程式碼的過程中，就不知不覺的完成了對某一個超長方法的分割。倘若在你提煉了大部分的重複程式碼之後，某一些冗長方法依然留存，此時就要靜下心來專門處理這些冗長方法了。
這其中有一點是值得注意的，由於我們在分割一個大方法時，大部分都是針對其中的一些子功能分割，因此我們需要給每一個子功能起一個恰到好處的方法名，這很重要。
小例項

class BadExample {

    public void someMethod(){
        //function[1]
        //function[2]
        //function[3]
    }    
}

/* ---------------------分割線---------------------- */

class GoodExample {

    public void someMethod(){
        function1();
        function2();
        function3();
    }
    
    private void function1(){
        //function[1]
    }
    
    private void function2(){
        //function[2]
    }

    private void function3(){
        //function[3]
    }    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31

No.3：巢狀條件分支的優化（1）
大量的巢狀條件分支是很容易讓人望而卻步的程式碼，我們應該極力避免這種程式碼的出現。儘管結構化原則一直在說一個函式只能有一個出口，但是在這麼大量的巢狀條件分支下，讓我們忘了這所謂的規則吧。
有一個專業名詞叫衛語句，可以治療這種恐怖的巢狀條件語句。它的核心思想是，將不滿足某些條件的情況放在方法前面，並及時跳出方法，以免對後面的判斷造成影響。經過這項手術的程式碼看起來會非常的清晰
小例項

class BadExample {

    public void someMethod(Object A,Object B){
        if (A != null) {
            if (B != null) {
                //code[1]
            }else {
                //code[3]
            }
        }else {
            //code[2]
        }
    }    
}

/* ---------------------分割線---------------------- */

class GoodExample {

    public void someMethod(Object A,Object B){
        if (A == null) {
            //code[2]
            return;
        }
        if (B == null) {
            //code[3]
            return;
        }
        //code[1]
    }    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31

No.4：巢狀條件分支的優化（2）
此處所說的巢狀條件分支與上面的有些許不同，它無法使用衛語句進行優化，而應該是將條件分支合併，以此來達到程式碼清晰的目的。由這兩條也可以看出，巢狀條件分支在編碼當中應當儘量避免，它會大大降低程式碼的可讀性。
小例項

class BadExample {

    public void someMethod(Object A,Object B){
        if (A != null) {
            if (B != null) {
                //code
            }
        }
    }    
}

/* ---------------------分割線---------------------- */

class GoodExample {

    public void someMethod(Object A,Object B){
        if (A != null && B != null) {
            //code
        }
    }    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

No.5：去掉一次性的臨時變數
生活當中我們都經常用一次性筷子，這無疑是對樹木的摧殘。然而在程式當中，一次性的臨時變數不僅是對效能上小小的摧殘，更是對程式碼可讀性的褻瀆。因此我們有必要對一些一次性的臨時變數進行手術。
小例項

class BadExample {
    
    private int i;

    public int someMethod(){
        int temp = getVariable();
        return temp * 100;
    }
    
    public int getVariable(){
        return i;
    }    
}

/* ---------------------分割線---------------------- */

class GoodExample {

    private int i;

    public int someMethod(){
        return getVariable() * 100;
    }
    
    public int getVariable(){
        return i;
    }    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

No.6：消除過長引數列表
對於一些傳遞了大批引數的方法，對於追求程式碼整潔的程式猿來說，是無法接受的。我們可以嘗試將這些引數封裝成一個物件傳遞給方法，從而去除過長的引數列表。大部分情況下，當你嘗試尋找這樣一個物件的時候，它往往已經存在了，因此絕大多數情況下，我們並不需要做多餘的工作。
小例項

class BadExample {
    
    public void someMethod(int i,int j,int k,int l,int m,int n){
        //code
    }    
}

/* ---------------------分割線---------------------- */

class GoodExample {

    public void someMethod(Data data){
        //code
    }    
}

class Data{
    
    private int i;
    private int j;
    private int k;
    private int l;
    private int m;
    private int n;
　　//getter&&setter    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26

No.7：提取類或繼承體系中的常量
這項重構的目的是為了消除一些魔數或者是字串常量等等，魔數所帶來的弊端自不用說，它會讓人對程式的意圖產生迷惑。而對於字串等型別的常量的消除，更多的好處在於維護時的方便。因為我們只需要修改一個常量，就可以完成對程式中所有使用該常量的程式碼的修改。
順便提一句，與此類情況類似並且最常見的，就是Action基類中，對於INPUT、LIST、SUCCESS等這些常量的提取。
小例項

class BadExample {
    
    public void someMethod1(){
        send("您的操作已成功！");
    }
    
    public void someMethod2(){
        send("您的操作已成功！");
    }
    
    public void someMethod3(){
        send("您的操作已成功！");
    }
    
    private void send(String message){
        //code
    }
}

/* ---------------------分割線---------------------- */

class GoodExample {
    
    protected static final String SUCCESS_MESSAGE = "您的操作已成功！";

    public void someMethod1(){
        send(SUCCESS_MESSAGE);
    }
    
    public void someMethod2(){
        send(SUCCESS_MESSAGE);
    }
    
    public void someMethod3(){
        send(SUCCESS_MESSAGE);
    }
    
    private void send(String message){
        //code
    }    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

No.8：讓類提供應該提供的方法
很多時候，我們經常會操作一個類的大部分屬性，從而得到一個最終我們想要的結果。這種時候，我們應該讓這個類做它該做的事情，而不應該讓我們替它做。而且大部分時候，這個過程最終會成為重複程式碼的根源。
小例項

class BadExample {
    
    public int someMethod(Data data){
        int i = data.getI();
        int j = data.getJ();
        int k = data.getK();
        return i * j * k;
    }
    
    public static class Data{
        
        private int i;
        private int j;
        private int k;
        
        public Data(int i, int j, int k) {
            super();
            this.i = i;
            this.j = j;
            this.k = k;
        }

        public int getI() {
            return i;
        }
        
        public int getJ() {
            return j;
        }
        
        public int getK() {
            return k;
        }        
    }    
}

/* ---------------------分割線---------------------- */

class GoodExample {
    
    public int someMethod(Data data){
        return data.getResult();
    }
    
    public static class Data{
        
        private int i;
        private int j;
        private int k;
        
        public Data(int i, int j, int k) {
            super();
            this.i = i;
            this.j = j;
            this.k = k;
        }

        public int getI() {
            return i;
        }
        
        public int getJ() {
            return j;
        }
        
        public int getK() {
            return k;
        }
        
        public int getResult(){
            return i * j * k;
        }        
    }    
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74

No.9：拆分冗長的類
這項技巧其實也是屬於非常實用的一個技巧，只不過由於它的難度相對較高。針對這個技巧，大部分時候，拆分一個類的關注點應該主要集中在類的屬性上面。拆分出來的兩批屬性應該在邏輯上是可以分離的，並且在程式碼當中，這兩批屬性的使用也都分別集中於某一些方法當中。如果實在有一些屬性同時存在於拆分後的兩批方法內部，那麼可以通過引數傳遞的方式解決這種依賴。
類的拆分是一個相對較大的工程，畢竟一個大類往往在程式中已經被很多類所使用著，因此這項重構的難度相當之大，一定要謹慎，並做好足夠的測試。
No.10：提取繼承體系中重複的屬性與方法到父類
這項技巧大部分時候需要足夠的判斷力，很多時候，這其實是在向模板方法模式邁進的過程。往往這一類重構都不會是小工程，因此這一項重構與第九種類似，都需要足夠的謹慎與測試。而且需要足夠確認，這些提取到父類中的屬性或方法，應該是子類的共性的時候，才可以使用這項技巧。

結束語

以上僅是Java方面程式設計時的效能優化，效能優化大部分都是在時間、效率、程式碼結構層次等方面的權衡，各有利弊，不要把上面內容當成教條，或許有些對我們實際工作適用，有些不適用，還望根據實際工作場景進行取捨吧，活學活用，變通為宜。