Java構造器與構建器的使用

我們在平常類的構建過程中，可能會面臨很多問題，可擴張性、安全性等等。想象一下，這樣一個場景，我們現在要創建一個類，其中有6個屬性，其中又有4個屬性的值是不太確定的（可能某個對象就不需要其中的某個值），這時我們怎么創建這個類呢？以下是幾種方法：

使用普通構造器

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

    public Test(int servingSize, int servings) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = 0;
    }

    public Test(int servingSize, int servings, int calories) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = 0;
    }

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

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

    public Test(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) {
        Test test = new Test(1,2,3,0,5,6);
}

如上所示，在實例化對象時，我們需要傳入相應的值，這時發現：

1. 第四個參數不是我們需要的，但是還不得不給他傳遞一個值
2. 我們在傳值時，很容易出錯，某兩個參數值互換了位置，這在工作時是不好發現的，但是程序會報錯

所以上面的方式在涉及到參數比較多，而且參數值不太確定是否需要時，這種方法會給我們的編碼以及后期維護帶來很大的困擾，我們再改進一下。

JavaBeans模式

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

    public Test() {

    }

    public void setServingSize(int servingSize) {
        this.servingSize = servingSize;
    }

    public void setServings(int servings) {
        this.servings = servings;
    }

    public void setCalories(int calories) {
        this.calories = calories;
    }

    public void setFat(int fat) {
        this.fat = fat;
    }

    public void setSodium(int sodium) {
        this.sodium = sodium;
    }

    public void setCarbohydrate(int carbohydrate) {
        this.carbohydrate = carbohydrate;
    }


}

如上，我們先創建一個無參構造方法（可以不寫出來，會默認創建），接下來就是利用setter方法給屬性賦值

public static void main(String[] args) {
        Test test = new Test();
        test.setServingSize(1);
        test.setCalories(2);
        test.setCalories(3);
        test.setSodium(5);
        test.setCarbohydrate(6);
}

如上，我們需要的對象不需要fat屬性，我們就不用給其賦值，這中方法有幾個好處：

1. 客戶端調用簡單，也就是實例化對象的過程十分簡單，並且不會出現把值傳遞出錯的風險
2. 別人能夠很好的使用且理解簡單

但是我們知道，javaBeans有個缺點：

1. 線程不安全，因為對象的創建分在了好幾步的過程中，不能保證對象狀態的一致性

我們可以確保線程的安全，這就需要我們額外的精力（我們可以在對象構造完成，並且不允許在凍結之前使用時，手動凍結，實際中很少使用，編譯器無法確定我們是否調用的freeze方法
）。因此這種方法也不夠理想，還有什么繼續改進的地方嗎？

構建器（建造者模式的一種形式）

public class Test {
    private int servingSize;
    private int servings;
    private int calories;
    private int fat;
    private int sodium;
    private int carbohydrate;
    
    public static class Builder {
        private int servingSize;
        private int servings;
        private int calories;
        private int fat;
        private int sodium;
        private int carbohydrate;
        
        public Builder (int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }
        
        public Builder calories(int calories) {
            calories = calories;
            return this;
        }

        public Builder fat(int fat) {
            fat = fat;
            return this;
        }

        public Builder sodium(int sodium) {
            sodium = sodium;
            return this;
        }

        public Builder carbohydrate(int carbohydrate) {
            carbohydrate = carbohydrate;
            return this;
        }
        
        public Test builder () {
            return new Test(this);
        }
    }
    
    private Test(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) {
        Test test = new Builder(1,2).calories(3).fat(4).sodium(5).carbohydrate(6).builder();
}

這樣就保證了對象在不變的情況下，簡單明了地實現了對象實例化（至於代碼中的內部類，我們以后細說）。