文章目錄

• 一. 用靜態工廠方法代替構造器
• • • 優勢：
    • 劣勢：
    • 實例代碼：
• 二. 遇到多個構造器參數時要考慮使用構建器
• • • ① 重疊構建器
    • ② JavaBeans模式
    • ③ Builder模式
• 三. 用私有構造器或枚舉類型強化Singleton屬性
• • • 方法一：公有靜態成員是個final域
    • 方法二：公有的成員是個靜態工廠
    • 方法三：一個包含單個元素的枚舉類型
• 四. 通過私有構造器強化不可實例化的能力

一. 用靜態工廠方法代替構造器

優勢：

• 有名稱，可以確切地描述正被返回的對象。
• 不必在每次調用的時候都創建新對象。
• 可以返回原返回類型的任何子類型對象。
• 返回的對象的類可以隨著每次調用而產生變化。
• 返回的對象所屬的類，在編寫靜態工廠方法時可以不存在。

劣勢：

• 類如果不含公有的或者受保護的構造器，就不能被子類化。
• 程序員很難發現他們，但是可以通過遵守標準的命名習慣來彌補。

實例代碼：

這是第二版的代碼，在第三版里已經刪去了。不過可以用來便于理解。

// 英文部分可以不看，或者作為參考。/** 用于描述Provider所提供的服務 */ public interface Service { ... // Service-specific methods go here } /** 用于描述Provider，每個Provider都要有自己的newService */ public interface Provider { Service newService(); } // Noninstantiable class for service registration and access public class Services { // 私有化構造方法，不會把工廠實例化，直接用類名。 private Services() { } // Prevents instantiation (Item 4)// 使用Map來存儲各provider及其name的映射。 // 使用final：只是providers一直指向當前HashMap,對HashMap里的內容變化沒有影響。 // Maps service names to services private static final Map<String, Provider> providers = new ConcurrentHashMap<String, Provider>(); public static final String DEFAULT_PROVIDER_NAME = "<def>"; ITEM 1: CONSIDER STATIC FACTORY METHODS INSTEAD OF CONSTRUCTORS 9 // Provider registration API public static void registerDefaultProvider(Provider p) { registerProvider(DEFAULT_PROVIDER_NAME, p); } // 注冊Provider到工廠Services里。 public static void registerProvider(String name, Provider p){ providers.put(name, p); } // Service access API public static Service newInstance() { return newInstance(DEFAULT_PROVIDER_NAME); } // 根據name從工廠中取出對應Provider提供的服務。 public static Service newInstance(String name) { Provider p = providers.get(name); if (p == null) throw new IllegalArgumentException( "No provider registered with name: " + name); return p.newService(); } }

二. 遇到多個構造器參數時要考慮使用構建器

① 重疊構建器

參考下面的代碼，活用this，但是參數多的時候難寫，并且用起來容易出錯。

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); } 12 CHAPTER 2 CREATING AND DESTROYING OBJECTS 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; } }

② JavaBeans模式

• 構造函數就是：ClassName(){}
• 把賦值交給Setters來實現
• 彌補了重疊構造器的不足，容易創建實例，并且易讀
• 缺點1：構造過程中JavaBean可能處于不一致的狀態（畢竟要多次賦值）
• 缺點2：使得把類做成不可變的可能性不存在（不能final，畢竟之后還要set的嘛）

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() { } ITEM 2: CONSIDER A BUILDER WHEN FACED WITH MANY CONSTRUCTOR PARAMETERS 13 // 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; } }

③ Builder模式

• 既保證了像重疊構造器的安全性，也保證像JavaBeans的可讀性
• 描述：用類的Builder，來構建類的對象。

// Builder Pattern 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; // 在構造函數前，先寫好內部類Builder public static class Builder { // Required parameters private final int servingSize; private final int servings; // Optional parameters - initialized to default values // 與類的final不同，此處因為要用setters，因此不設為final。 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; } // 逐個屬性設定值，每次都return this：和之后的具體調用相關 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; } // build()：使用this builder作為參數來構造類的對象。 public NutritionFacts build() { return new NutritionFacts(this); } } // 私有的構造函數，使用已經完全初始化的builder來進行唯一的一次初始化。 private NutritionFacts(Builder builder) { servingSize = builder.servingSize; servings = builder.servings; calories = builder.calories; fat = builder.fat; sodium = builder.sodium; carbohydrate = builder.carbohydrate; } }

• 還適用于類層次結構（這里會麻煩點，涉及到抽象類、范式等等）

// 先來個抽象的父類Pizza！ // Builder pattern for class hierarchies public abstract class Pizza { public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE } final Set<Topping> toppings; // Builder也是抽象的，這里用到T進行一個約束：只能是Pizza.Builder的字類 abstract static class Builder<T extends Builder<T>> { EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class); public T addTopping(Topping topping) { toppings.add(Objects.requireNonNull(topping)); // 這里不能return T，所以先自己寫一個self()函數來代替（返回還未構成的類） return self(); } abstract Pizza build(); // Subclasses must override this method to return "this" protected abstract T self(); } // <?>：只要是繼承了Builder的參數都可用 Pizza(Builder<?> builder) { toppings = builder.toppings.clone(); // See Item 50 } }// 再來兩個子類披薩 // 重寫之前的抽象函數，并且構造函數中要有super(builder) public class NyPizza extends Pizza { public enum Size { SMALL, MEDIUM, LARGE } private final Size size; public static class Builder extends Pizza.Builder<Builder> { private final Size size; public Builder(Size size) { this.size = Objects.requireNonNull(size); } @Override public NyPizza build() { return new NyPizza(this); } @Override protected Builder self() { return this; } } private NyPizza(Builder builder) { super(builder); size = builder.size; } } public class Calzone extends Pizza { private final boolean sauceInside; public static class Builder extends Pizza.Builder<Builder> { private boolean sauceInside = false; // Default public Builder sauceInside() { sauceInside = true; return this; } @Override public Calzone build() { return new Calzone(this); } @Override protected Builder self() { return this; } } private Calzone(Builder builder) { super(builder); sauceInside = builder.sauceInside; } }// 然后實際使用的時候 // 使用類名建builder，一直builder下去，最后讓builder來build對象出來。 NyPizza pizza = new NyPizza.Builder(SMALL) .addTopping(SAUSAGE).addTopping(ONION).build(); Calzone calzone = new Calzone.Builder() .addTopping(HAM).sauceInside().build();

三. 用私有構造器或枚舉類型強化Singleton屬性

• 單例模式

方法一：公有靜態成員是個final域

// Singleton with public final field public class Elvis { // 公有 靜態 final public static final Elvis INSTANCE = new Elvis(); // 構造函數私有化 private Elvis() { ... } public void leaveTheBuilding() { ... } }

方法二：公有的成員是個靜態工廠

相對于方法一，畢竟類的成員還是要用方法來訪問比較好。

// Singleton with public final field public class Elvis { // 把public 變成 private private static final Elvis INSTANCE = new Elvis(); // 構造函數私有化 private Elvis() { ... } // 公有靜態方法，返回唯一的實例。 public static Elvis getInstance(){return INSTANCE} public void leaveTheBuilding() { ... } }

方法三：一個包含單個元素的枚舉類型

• Java的enum和C++的差別很大。
• 這樣子寫會比較簡便。

// Enum singleton - the preferred approach public enum Elvis{// 只有一個“實例”INSTANCE;public void leaveTheBuilding(){...} }

四. 通過私有構造器強化不可實例化的能力

• 這塊感覺沒啥好講的，就是給構造函數加個private。
• 好壞處之類的可以參考書里的內容。

總結

以上是生活随笔為你收集整理的【Effective Java】第二章：静态工厂、构建器、强化Singleton属性、私有构造器、的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。