我不是個偉大的程式設計師；我只是個有著一些優秀習慣的好程式設計師而己

本人比較直接，不說虛的，直接上乾貨。

 目錄

　　Long Parameter List（過長引數列）　　Divergent Change（發散式變化）　　Shotgun Surgery（散彈式修改）　　Feature Envy（依戀情結）　　Data Clumps（資料泥團）　　Primitive Obsession（基本型別偏執）　　Switch Statements（switch驚悚現身）

Long Parameter List（過長引數列）

上一節有提過，當函式的入參過多時，可以用第三招，引數物件化，把引數封裝成物件，然後引數物件當成函式的入參，達到減少引數的作用。除了引數物件化，還可以使用另一種方法來處理。這種方法叫做：Replace Parameter with Method（以函式取代引數）

優化思路

前提，這個引數是隻被賦值一次的1、如果有必要，將引數的計算過程提煉到一個獨立函式中。2、將函式內有使用引數的地方替換成獨立函式。3、每次替換後，測試。4、全部替換完成後，最後把這個引數刪除。eg:未優化的程式碼

public double getPrice() {

      int basePrice = _quantity * _itemPrice;
      int discountLevel;
      if (_quantity > 100) discountLevel = 2;
      else discountLevel = 1;
      double finalPrice = discountedPrice (basePrice, discountLevel);
      return finalPrice;

  }

  private double discountedPrice (int basePrice, int discountLevel) {
      if (discountLevel == 2) return basePrice * 0.1;
      else return basePrice * 0.05;
  }
 

優化 1，2，3步驟 優化引數basePrice

public double getPrice() {

      int basePrice = getBasePrice();
      int discountLevel;
      if (_quantity > 100) discountLevel = 2;
      else discountLevel = 1;
      double finalPrice = discountedPrice ( discountLevel);
      return finalPrice;

  }

  private double discountedPrice ( int discountLevel) {
      if (discountLevel == 2) return getBasePrice() * 0.1;
      else return getBasePrice() * 0.05;
  }
  
  private int getBasePrice(){
    return _quantity * _itemPrice;
  }
 

優化4步驟 去掉引數basePrice

public double getPrice() {

      int discountLevel;
      if (_quantity > 100) discountLevel = 2;
      else discountLevel = 1;
      double finalPrice = discountedPrice ( discountLevel);
      return finalPrice;

  }

  private double discountedPrice ( int discountLevel) {
      if (discountLevel == 2) return getBasePrice() * 0.1;
      else return getBasePrice() * 0.05;
  }
  
  private int getBasePrice(){
    return _quantity * _itemPrice;
  }

優化1，2，3，4步驟，去掉discountLevel引數，獨立函式返回值要為discountLevel 最後賦值的值

public double getPrice() {

      double finalPrice = discountedPrice ();
      return finalPrice;

  }

  private double discountedPrice () {
      if (getDiscountLevel() == 2) return getBasePrice() * 0.1;
      else return getBasePrice() * 0.05;
  }
  
  private double getDiscountLevel(){
      if (_quantity > 100) return 2;
      else return 1;
        
  }  
  
  private double getBasePrice(){
    return _quantity * _itemPrice;
  }

從上述程式碼可看出，getPrice主函式finalPrice引數已經可以直接優化了。

public double getPrice() {

      return discountedPrice ();

  }

可以發現getPrice函式直接呼叫discountedPrice 函式，所以可用Inline Method（將函式內聯化）合併這兩個函式

public double getPrice() {
    if (getDiscountLevel() == 2) return getBasePrice() * 0.1;
      else return getBasePrice() * 0.05;

  }
  
  private double getDiscountLevel(){
      if (_quantity > 100) return 2;
      else return 1;
        
  }  
  
  private double getBasePrice(){
    return _quantity * _itemPrice;
  }

我們只關心主函式的計算過程，一些過程性的計算，像上述這樣，獨立函數出來。程式碼邏輯會十分清晰，可讀性很好。存在一個重要的例外。如果明顯不希望封裝的物件與主物件之間存在某種依賴關係，可以把引數資料從封裝物件中抽出來，當成函式的引數。也是合理的。但是要注意，當引數列太多或者引數變化頻繁時，就要考慮優化了。

Divergent Change（發散式變化）

你發現你想要修改的一個函式，卻必須同時修改諸多不相關的函式，例如，當你想要新增一個新的產品型別，你需要同步修改對產品查詢，顯示，排序的函式。有以上這些情況的話，就需要優化程式碼了針對某一外界 變化的所有相應修改，都只應該發生在單一class中，而這個新class內的所有內容都應該反應該外界變化。通過提煉類的方式，找出因著某特定原因而造成的所有變化，獨立類。問題原因：通常，這種發散式修改是由於程式設計結構不合理或者“複製-貼上式程式設計”。

優化思路

運用提煉類拆分類的行為。如果不同的類有相同的行為，你可以考慮通過繼承來合併類和提煉子類。效果：提高程式碼組織結構減少重複程式碼

Shotgun Surgery（散彈式修改）

-- 注意霰彈式修改 與 發散式變化 區別 : 發散式變化是在一個類受多種變化影響, 每種變化修改的方法不同, 霰彈式修改是 一種變化引發修改多個類中的程式碼;

優化思路

1、程式碼集中到某個類中 : 使用 Move Method(搬移函式) 和 Move Field(搬移欄位) 把所有需要修改的程式碼放進同一個類中;2、 程式碼集中到新建立類中 : 沒有合適類存放程式碼, 建立一個類, 使用 Inline Class(內聯化類) 方法將一系列的行為放在同一個類中;3、造成分散式變化 : 上面的兩種操作會造成 Divergent Change（分散式變化）, 使用Extract Class 處理分散式變化;

Feature Envy（依戀情結）

函式對某個class的興趣高過對自己所處之 class的興趣。無數次經驗裡，我們看到某個函式 為了計算某值，從另一個物件那兒呼叫幾乎半打的取值函式。影響：資料和行為不在一處，修改不可控。解決方案：讓資料和行為在一起，通過 Extract Method（提煉函式）和Move Method（搬移函式）的方法來處理，這函式到該去的地方。例子：參考一個優秀博主提供的例子

優化思路

1、函式全部資料來自另外一個類      做法：將資料提煉到一個獨立函式中  Move method。2、函式部分資料來自另外一個類      做法：將“部分資料”提煉到一個函式中 Move method。3、函式的資料來自不同類      做法：將資料分類，分別提煉各自的獨立的函式，在將這些函式移到各自屬於的類中。

Data Clumps（資料泥團）

資料泥團指的是經常一起出現的資料，比如每個方法的引數幾乎相同，處理方式與過長引數列的處理方式相同，用Introduce Parameter Object（引入引數物件）將引數封裝成物件。

優化思路

1、觀察經常一起出現的資料；2、通過提煉類的方法，放到屬於他們的物件中；3、用物件來代替這些資料；4、編譯測試。eg：未優化程式碼例子參考一個優秀博主提供的例子

public class Car{
    // 賓士
    public void printBenz(String brand, String model, Integer price, double power) {
        printBasicInfo(brand, model, price, power);
        getTax(power, price);
    }

    // 寶馬
    public void printBmw(String brand, String model, Integer price, double power) {
        printBasicInfo(brand, model, price, power);
        getTax(power, price);
    }

    // 提煉列印基本資訊方法
    private void printBasicInfo(String brand, String model, Integer price, double power) {
        System.out.println("品牌" + brand);
        System.out.println("型號：" + model);
        System.out.println("動力：" + power);
        System.out.println("價格：" + price);
    }

    // 提煉計算稅費的方法
    private double getTax(double power, Integer price){
        double salePrice = price;
        if (price > 200000) {
            salePrice = price * 0.98;
        }

        if (power <= 1.6) {
            return salePrice * 0.05;
        } else {
            return salePrice * 0.1;
        }
    }
}

優化1,2步驟上面程式碼方法中，我們發現方法的引數大致相同，這時候我們可以用引數物件化來處理。

public class CarEntity {

    private String brand;
    private String model;
    private Integer price;
    private Double power;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    public Double getPower() {
        return power;
    }

    public void setPower(Double power) {
        this.power = power;
    }

}

優化3，4步驟

// 賓士
    public void printBenz(CarEntity carEntity) {
        printBasicInfo(carEntity);
        // 計算稅費
        getTax(carEntity);
    }

    // 寶馬
    public void printBmw(CarEntity carEntity) {
        printBasicInfo(carEntity);
        getTax(carEntity);
    }

    private void printBasicInfo(CarEntity carEntity) {
        System.out.println("品牌" + carEntity.getBrand());
        System.out.println("型號：" + carEntity.getModel());
        System.out.println("動力：" + carEntity.getPower());
        System.out.println("價格：" + carEntity.getPrice());
    }
    // 計算稅費
    private double getTax(CarEntity carEntity) {
        // 打折後價格
        double salePrice = carEntity.getPrice();
        if (carEntity.getPrice() > 200000) {
            salePrice = carEntity.getPrice() * 0.98;
        }

        if (carEntity.getPower() <= 1.6) {
            return salePrice * 0.05;
        } else {
            return salePrice * 0.1;
        }
    }

經過以上的優化，程式碼就更加健壯了。

Primitive Obsession（基本型別偏執）

寫程式碼時總喜歡用基本型別來當引數，而不喜歡用物件。當要修改需求和擴充套件功能時，複雜度就增加了。

優化思路

1、如果你有一組應該總是被放在一起的屬性或引數，可以用提煉類的方式來處理；2、如果你在引數列中看到多個基本型資料，可以引用引數物件；3、如果你發現自己正從array中挑選資料，可以用物件取代陣列。優化步驟1和2之前的例子說明了很多次，不再重複。優化步驟3用物件取代陣列：你有一個數組（array），其中的元素各自代表不同的東西。就可以用物件來表示陣列。eg:

String[] row = new String[3];
  row [0] = "Liverpool";
  row [1] = "15";

//物件取代陣列
  Performance row = new Performance();
  row.setName("Liverpool");
  row.setWins("15");

Performance 物件裡包含name屬性和wins屬性，且這兩個屬性被定義為private ，同時擁有get方法和set方法。

Switch Statements（switch驚悚現身）

面向物件程式的一個最明顯特徵就是：少用switch (或case）語句。從本質上說， switch語句的問題在於重複（duplication）。

優化思路

這種情況我們可以引用工廠 + 策略模式。用工廠把重複的switch提煉到一起構建成一個工廠類，策略模式把switch分支中執行的動作提煉成單獨的類。例子參考一個優秀博主提供的例子更多精彩內容，請等待後續更新。文章也同步到了部落格園：https://www.cnblogs.com/zenghw/p/9114428.html***************************************************************************

作者：小虛竹
歡迎任何形式的轉載，但請務必註明出處。
限於本人水平，如果文章和程式碼有表述不當之處，還請不吝賜教。

我不是個偉大的程式設計師，我只是個有著一些優秀習慣的好程式設計師而己