Java創建對象的方法清單 —— 原來還可以這樣創建對象

本文結合《Effective Java》第二章《創建和銷燬對象》和自己的理解及實踐，介紹了兩種比使用構造器更優雅的創建對象方法，文章發佈於專欄Effective Java，歡迎讀者訂閱。

靜態工廠方法創建對象

使用靜態工廠方法代替構造器去創建對象，有很多的優點，由於內容比較獨立，此前已經單獨成篇，篇幅不多，建議讀者在閱讀下面內容之前，先瀏覽一下 Java靜態工廠方法 —— 有了它，你還需要工廠模式嗎

構建器  多構造參數時創建對象的利器

無論是使用構造函數，還是使用上面介紹的靜態工廠方法，在遇上需要多個可選構造參數時，都不能有很好的擴展性。

舉個例子，一個類，創建時有一個必填參數，五個可選參數，那麼，如果採用構造器的方法，就要提供

構造器1： 包含1個必填參數

構造器2： 包含1個必填參數，1個可選參數

構造器3： 包含1個必填參數，2個可選參數

依此類推...

這種方式叫做重疊構造器模式，下面代碼就是上面這種思路的一個例子：

public class NutritionFacts {
    private final int servingSize;   // (mL)            required
    private final int servings;      // (per container) required
    private final int calories;      //                 optional
    private final int fat;           // (g)             optional
    private final int sodium;        // (mg)            optional
    private final int carbohydrate;  // (g)             optional

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories) {
        this(servingSize, servings, calories, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }

    public NutritionFacts(int servingSize, int servings,
           int calories, int fat, int sodium, int carbohydrate) {
        this.servingSize  = servingSize;
        this.servings     = servings;
        this.calories     = calories;
        this.fat          = fat;
        this.sodium       = sodium;
        this.carbohydrate = carbohydrate;
    }

    public static void main(String[] args) {
        NutritionFacts cocaCola =
            new NutritionFacts(240, 8, 100, 0, 35, 27);
    }
}

這樣的代碼顯然是不可以接受的，一方面，寫這個類的人需要提供很多構造函數，另一方面，使用這個構造函數的人，需要非常仔細的按照順序給構造函數傳入參數，如果不小心顛倒了其中兩個參數的順序，就會造成錯誤的發生。

當然，我們可以不在創建對象的時候就給對象的屬性賦值呀，我們可以採用setter方法嘛，這也是一種方法，叫JavaBean模式。

舉個例子：

public class NutritionFacts {
    // Parameters initialized to default values (if any)
    private int servingSize  = -1;  // Required; no default value
    private int servings     = -1;  //     "     "     "      "
    private int calories     = 0;
    private int fat          = 0;
    private int sodium       = 0;
    private int carbohydrate = 0;

    public NutritionFacts() { }

    // Setters
    public void setServingSize(int val)  { servingSize = val; }
    public void setServings(int val)     { servings = val; }
    public void setCalories(int val)     { calories = val; }
    public void setFat(int val)          { fat = val; }
    public void setSodium(int val)       { sodium = val; }
    public void setCarbohydrate(int val) { carbohydrate = val; }


    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts();
        cocaCola.setServingSize(240);
        cocaCola.setServings(8);
        cocaCola.setCalories(100);
        cocaCola.setSodium(35);
        cocaCola.setCarbohydrate(27);
    }
}

這樣子看似不錯，但遺憾的是，這種方法存在兩個缺陷：

1. 這種方法，使得構造的過程分成了好幾個過程，在這幾個過程中，對象處於不同的狀態，而我們無法保證，在這個過程中間，對象不會被用來做其他的事。

2. 這種方法，阻止了把類做成不可變類的的可能，因爲不可變類的示例一旦創建，就不會讓外界去改變它的。

幸運的是，我們還有第三種方法，也就是今天要講的——構建器模式，這種方法，不直接創建想要的對象，而是首先使用必要參數，創建一個bulider對象，然後使用類似於set的方法，給builder對象賦予需要的可選參數，最後調用bulider對象的bulider方法，最終創建想要的對象。

舉個例子：

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories      = 0;
        private int fat           = 0;
        private int carbohydrate  = 0;
        private int sodium        = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings    = servings;
        }

        public Builder calories(int val)
            { calories = val;      return this; }
        public Builder fat(int val)
            { fat = val;           return this; }
        public Builder carbohydrate(int val)
            { carbohydrate = val;  return this; }
        public Builder sodium(int val)
            { sodium = val;        return this; }

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

客戶端調用代碼：

    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
            calories(100).sodium(35).carbohydrate(27).build();
    }

使用構建器模式，代碼變得更容易編寫，易於閱讀。同時避免了JavaBean模式將一個對象的創建過程拆分成子過程的缺點。

使用單例模式創建單例類

單例模式，是指把一個類設計成爲只允許有一個實例的方法，這裏也作爲創建對象的知識點放在這篇文章吧，不過我就不自己講了，因爲已經有人講的非常完美。這裏安利一篇講單例模式的文章，講的非常全面  Hi，我們再來聊一聊Java的單例吧

總結

構造函數並不是創建對象的首先方式，我們還可以採用靜態工廠方法和構建器的方式去創建對象。

如果一個類的實例需要傳入多個必填和可選參數，我們可以考慮使用構建器模式。