如何避免Java中的構造器代碼冗餘？

Question

我有以下類：

class Pair 
{ 
    String car; 
    Integer cdr; 

    public Pair() {} 
    public Pair (String car) { this.car = car; } 
    public Pair (Integer cdr) { this.cdr = cdr; } 

    public Pair (String car, Integer cdr) 
    { 
     this(car); 
     this(cdr); 
    } 
} 

類包含兩個可選值，我想提供一切可能的構造排列。第一個版本不初始化任何東西，第二個版本只初始化第一個值，第三個初始化第二個值。

最後的構造函數是第二個和第三個的組合。但是不可能寫下來，因爲代碼失敗。

 
constructor.java:13: call to this must be first statement in constructor 
     this(cdr); 
      ^
1 error 

是否有可能編寫沒有任何代碼冗餘的最後一個構造函數（也沒有調用相同的setter方法）？

Answer 1

通常，參數較少的構造函數應該使用更多的參數來調用它們。

public Pair() {} 
public Pair(String car) { this(car, null); } 
public Pair(Integer cdr) { this(null, cdr); } 
public Pair(String car, Integer cdr) { this.car = car; this.cdr = cdr; } 

Answer 2

class Pair 
{ 
    String car; 
    Integer cdr; 

    public Pair() {} 
    public Pair (String car) { 
     this(car, null) 
    } 
    public Pair (Integer cdr) { 
     this(null, cdr); 
    } 

    public Pair (String car, Integer cdr) { 
     this.car = car; 
     this.cdr = cdr; 
    } 
} 

Answer 3

鏈的相反方向構造，最具體的是在一個設定的所有字段：

public Pair() { 
    this(null, null); // For consistency 
} 

public Pair(String car) { 
    this(car, null); 
} 

public Pair(Integer cdr) { 
    this(null, cdr); 
} 

public Pair (String car, Integer cdr) { 
    this.car = car; 
    this.cdr = cdr; 
} 

這樣：

• 只有一個地方集字段，它設置所有字段
• 從任何其他構造函數中，您可以指定（並告訴您何時讀取代碼）其他字段的「默認」值。

順便說一句，我強烈建議您將字段設置爲私有（可能是最終），併爲其賦予更多有意義的名稱。請注意，如果你有5個參數和一個帶3的構造函數，其中一個帶有4，另一個帶有5，那麼你可能會選擇連接3 - > 4 - > 5，或者你可以選擇連接3 - > 4 - > 5。直行從3 - > 5

此外，您可能要完全刪除單參數的構造函數 - 這將是更具可讀性有靜態方法來代替，在這裏你可以指定名字的含義：

public static Pair fromCar(String car) { 
    return new Pair(car, null); 
} 

public static Pair fromCdr(Integer cdr) { 
    return new Pair(null, cdr); 
} 

或者在我的意思的首選命名：

public static Pair fromFirst(String first) { 
    return new Pair(first, null); 
} 

public static Pair fromSecond(Integer second) { 
    return new Pair(null, second); 
} 

此時，您可以使Pair類具有通用性，而不用擔心在兩個類型參數相同的情況下將調用哪個構造函數。此外，讀取代碼的任何人都可以理解將構建什麼而不必檢查參數的類型。

Answer 4

您可能在這裏尋找builder pattern。

除此之外，這種模式允許你沒有一個bazillion構造函數來覆蓋所有的情況。對於你的情況，這可能是：

@Immutable // see JSR 305 
public final class Pair 
{ 
    private final String car; 
    private final integer cdr; 

    private Pair(final Builder builder) 
    { 
     car = builder.car; 
     cdr = builder.cdr; 
    } 

    public static Builder newBuilder() 
    { 
     return new Builder(); 
    } 

    // whatever other methods in Pair, including accessors for car and cdr, then: 

    @NotThreadSafe // see JSR 305 
    public final class Builder 
    { 
     private String car; 
     private int cdr; 

     private Builder() 
     { 
     } 

     public Builder withCar(final String car) 
     { 
      this.car = car; 
      return this; 
     } 

     public Builder withCdr(final int cdr) 
     { 
      this.cdr = cdr; 
      return this; 
     } 

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

使用範例：

final Pair newPair = Pair.newBuilder.withCar("foo").withCdr(1).build(); 

優勢：Pair現在是一成不變的！