摘要：檢查參數(shù)的有效性每當(dāng)編寫方法或者構(gòu)造器時，應(yīng)該考慮它的參數(shù)有哪些限制。為了保護實例的內(nèi)部信息避免受到這種攻擊，對于構(gòu)造器的每個可變參數(shù)進行保護性拷貝是必要的，并且使用備份對象作為實例的組件，而不是使用原始的對象。

每當(dāng)編寫方法或者構(gòu)造器時，應(yīng)該考慮它的參數(shù)有哪些限制。應(yīng)該把這些限制寫到文檔中，并且在這個方法體開頭處，通過顯示的檢查來實施這些限制。養(yǎng)成這樣的習(xí)慣非常重要。

public final class Period {
    private final Date start;
    private final Date end;
    
    public Period(Date start, Date end) {
        if (start.compareTo(end) > 0) {
            throw new IllegalArgumentException(start + " after " + end);
        }
        this.start = start;
        this.end = end;
    }
    
    public Date start() {
        return start;
    }
    
    public Date end() {
        return end;
    }

}

因為Date類本身時可變的，所以，

Date start = new Date();
Date end = new Date();
Period p = new Period(start, end);
end.setYear(78); // 這個操作把實例的內(nèi)部信息修改了。

為了保護Period實例的內(nèi)部信息避免受到這種攻擊，對于構(gòu)造器的每個可變參數(shù)進行保護性拷貝是必要的，并且使用備份對象作為Period實例的組件，而不是使用原始的對象。

public Period(Date start, Date end) {
    this.start = new Date(start.getTime());
    this.end = new Date(end.getTime());
    
    if (this.start.compareTo(this.end) > 0) {
        throw new IllegalArgumentException(start + " after " + end);
    }
}

注意，保護性拷貝是在檢查參數(shù)的有效性之前進行的，并且有效性檢查是針對拷貝之后的對象，而不是原始的對象。

但是改變Period實例仍然是有可能的，因為它的訪問方法提供了對其內(nèi)部成員的訪問能力。

Date start = new Date();
Date end = new Date();
Period p = new Period(start, end);
p.end().setYear(78); // 這個操作把實例的內(nèi)部信息修改了。

為了防御這第二種攻擊，只需改這兩個訪問方法，使它返回可變內(nèi)部域的保護性拷貝即可。

public Date start() {
    return new Date(start.getTime());
}

public Date end() {
    return new Date(end.getTime());
}

在內(nèi)部組件被返回給客戶端之前，對它們進行保護性拷貝也是同樣的道理。

只要有可能，都應(yīng)該使用不可變的對象作為對象內(nèi)部的組件，這樣就不必再為保護性拷貝操心。

如果類具有從客戶端得到或者返回到客戶端的可變組件，類就必須保護性地拷貝這些組件。
如果拷貝的成本受到限制，并且類信任它的客戶端會恰當(dāng)?shù)匦薷慕M件，就可以在文檔中指明客戶端的職責(zé)使不得修改受到影響的組件，以此來代替保護性拷貝。

首要目標(biāo)是選擇易于理解的。

第二目標(biāo)是選擇與大眾認可的名稱相一致的名稱。

每個方法都應(yīng)該盡其所能。方法太多會使類難以學(xué)習(xí)、使用、文檔化、測試和維護。

對于類和接口所支持的每個動作，都提供一個功能齊全的方法。

目標(biāo)是四個參數(shù)，或者更少。

有三種方法可以縮短過長的參數(shù)列表。
第一種是把方法分解成多個方法，每個方法只需要這些參數(shù)的一個子集。
第二種是創(chuàng)建輔助類，用來保存參數(shù)的分組。
第三種是從對象構(gòu)建到方法調(diào)用都采用Builder模式。

如果使用的是類而不是接口，則限制了客戶端只能傳入特定的實現(xiàn)，如果碰巧輸入的數(shù)據(jù)是以其他的形式存在，就會導(dǎo)致不必要的、可能非常昂貴的拷貝操作。

它是代碼更易于閱讀和編寫，也使以后更易于添加更多的選項。

下面的程序試圖根據(jù)一個集合是Set、List，還是其他的集合類型來分類。

public class CollectionClassifier {
    public static String classify(Set set) {
        return "Set";
    }
    
    public static String classify(List list) {
        return "List";
    }
    
    public static String classify(Collection collection) {
        return "Unknow Collection";
    }
    
    public static void main(String[] args) {
        Collection[] collections = {
            new HashSet(),
            new ArrayList(),
            new HashMap().values()
        };
        
        for(Collection collection : collections) {
            System.out.println(classify(collection));
        }
    }
}

可能期望會打印“Set”，接著是“List”，以及“Unknow Collection”，實際上不是這樣。而是“Unknow Collection”打印三次。

因為classify方法被重載（overload）了，而要調(diào)用哪個重載方法是在編譯時做出決定的。對于for循環(huán)中的三次迭代，參數(shù)的編譯時類型都是相同的，Collection。每次迭代的運行時類型都是不同的，但這并不影響對重載方法的選擇。因為該參數(shù)的編譯時類型為Collection，所以，唯一合適的重載方法是第三個，classify(Collection)，在循環(huán)的每次迭代中，都會調(diào)用這個重載方法。

對于重載方法（overload method）的選擇是靜態(tài)的，而對于被覆蓋的方法（overriden method）的選擇則是動態(tài)的。

選擇被覆蓋的方法的正確版本是在運行時的，選擇的依據(jù)時被調(diào)用方法所在對象的運行時類型。

再看看下面這個程序。

class Wine {
    String name() {
        return "wine";
    }
}

class SparklingWine extends Wine {
    @Override
    String name() {
        return "sparkling wine";
    }
}

class Champagne extends SparklingWine {
    @Override
    String name() {
        return "champagne";
    }
}

public class Overriding {
    public static void main(String[] args) {
        Wine[] wines = {
            new Wine(),
            new SparklingWine(),
            new Champagne()
        };
        
        for(Wine wine : wines) {
            System.out.println(wine.name());
        }
    }
}

這個程序打印“wine”、“sparkling wine”和“champagne”。

可以對第一個程序修改一下，用單個方法替換三個重載的classify方法，如下。

public static String classify(Collection collection) {
    return collection instanceof Set ? "Set" :
           collection instanceof List ? "List" : "Unknow Collection";
}

因為覆蓋機制時規(guī)范，而重載機制是例外。

到底怎樣才算是胡亂使用重載機制呢？這個問題仍有爭議。安全而保守的策略是，永遠不要導(dǎo)出兩個具有相同參數(shù)數(shù)目的重載方法。

Java 1.5發(fā)行版本中增加了可變參數(shù)方法，一般稱作variable arity method（可匹配不同長度的變量方法）[JLS，8.4.1]。

可變參數(shù)方法接受零個或者多個指定類型的參數(shù)。可變參數(shù)機制通過先創(chuàng)建一個數(shù)組，數(shù)組的大小為在調(diào)用位置所傳遞的參數(shù)數(shù)量，然后將參數(shù)值傳到數(shù)組中，最后將數(shù)組傳遞給方法。

static int sum(int... args) {
    int sum = 0;
    for (int arg : args) {
        sum += arg;
    }
    return sum;
}

當(dāng)真正需要讓一個方法帶有不定數(shù)量的參數(shù)時，可變參數(shù)就非常有效。可變參數(shù)是為printf而設(shè)計的。printf和反射機制都從可變參數(shù)中極大地受益。

在重視性能地情況下，需要小心。可變參數(shù)方法的每次調(diào)用都會導(dǎo)致進行一次數(shù)組分配和初始化。

需要可變參數(shù)的靈活性，但又無法承受性能成本，可以這么做。

public void foo() {}
public void foo(int a1) {}
public void foo(int a1, int a2) {}
public void foo(int a1, int a2, int a3) {}
public void foo(int a1, int a2, int a3, int... rest) {}

在定義參數(shù)數(shù)目不定的方法時，可變參數(shù)方法是一種很方便的方式，但是不應(yīng)該被過度濫用。如果使用不當(dāng)，會產(chǎn)生混亂的結(jié)果。

對于一個返回null而不是零長度數(shù)組或者集合的方法，幾乎每次調(diào)用該方法都需要曲折的處理方式。這樣很容易出錯，因為編寫客戶端程序的程序員可能會忘記寫專門的代碼來處理null返回值。