摘要：所以，在讀的核心技術的過程中，我記錄下這些所謂的易忽略的問題，這些問題將會持續更新在我的這個的博客下，也算是激勵自己重新挖掘這些基礎問題的內涵。類路徑只是讓能夠通過配置好的全路徑名找到所需的外部類。

開篇
Java是一門不那么簡單也不那么復雜的語言，Java里面有很多問題和特性是容易被使用者忽視的，這些問題也許會難住新手，同時也許會是老手不小心跌入的無故之坑，只有精于對基礎的提煉才能最大程度地解決類似的疑問。所以，在讀Cay.Horstmann的《Java核心技術》的過程中，我記錄下這些所謂的易忽略的問題，這些問題將會持續更新在我的這個Segment Fault的博客下，也算是激勵自己重新挖掘這些基礎問題的內涵。這個博客將以原書中的章節為分割，大概會是每章一篇，持續更新，每篇的內容也不會一次全部寫完，視我個人對問題的理解和我的閱讀進度而定。

另外，我們從本書第一卷第四章開始，因為前三章無外乎就是在講述歷史和環境配置，我認為和我們的主題不大相關。

public，private等這些訪問控制標識對java的類和包來說都是可用的，而且在類中的屬性和方法、包中的方法來說訪問權限上的定義也是共通的：

public屬性和方法：這些方法的訪問權限是公開的，也就是說所有的類內部和外部對象都可以訪問這些公開的屬性和方法；

public類：這些類的訪問權限是公開的，也就是說在包內的類和包外的類都可以訪問這些公開的類；

private屬性和方法：這些方法是類私有的，也就是說只能被類內部所訪問；

private類：這些類的訪問權限是私有的，也就是說只能被包內部所訪問。

顧名思義，classpath指的是類路徑，也就是jvm在搜尋class二進制文件時搜尋的目錄，在這個目錄中如果找到需要的class文件則去執行，我們可以通過執行前為java命令設置－classpath參數或者直接設置CLASSPATH系統環境變量的形式去定義這個類路徑，jvm就會去這個指定的路徑下搜尋需要的class文件。
這個例子說明這個問題：
我們可以在系統環境變量配置文件中這樣配置java的CLASSPATH：

export CLASSPATH=".:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar"

這樣的配置文件等同于在java命令中的 -classpath參數：

java -classpath .:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar Test

這樣配置CLASSPATH環境變量或使用-classpath參數之后，jvm在尋找程序中使用的不包含在當前類中的類時就會去這些路徑下尋找，比如說程序中使用了不包含在當前類中的com.rocking.People類(People類通過importcom.rocking.＊引入的)，那么就會依照類路徑中指示的路徑去尋找：
壓縮入$JAVA_HOME/lib/dt.jar中的com/rocking/People.class（jdk提供的系統級jar包）
壓縮入$JAVA_HOME/lib/tools.jar的com/rocking/People.class
./com/rocking/People.class（當前路徑.拼接上class的全路徑名）

package com.rocking;

public class People{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

import com.rocking.People;

public class Test {
    public static void main(String[] args) {
        People people = new People();       
    }
}

最重要的一點是，我們上面的討論都是在jvm尋找class文件的過程中，而非javac編譯器尋找待編譯的java source文件的過程中，在編譯中，我們必須通過package定義當前類所在的包（或者不明確定義直接使用default package），需要導入外部類時import相應包，只有這樣才能通過編譯。類路徑只是讓jvm能夠通過配置好的全路徑名找到所需的外部類。

理論上我們將域屬性設置為private的目的是為了不讓程序能夠輕易地訪問和修改到這個對象私有的屬性，而只能通過該類定義的public的getter和setter方法去訪問和修改。但是這并不是完全可靠的，程序仍然可以通過一些靈巧的辦法在某些合適的情況下獲取和更改這些私有的屬性值。

setter的不可靠性，其實只要能夠確定這個私有屬性的引用，是完全可以直接做更改的，當然前提是獲取到這個引用，比如通過getter拿到這個屬性的引用。這是一個例子：

class Secret{
    private StringBuffer secret = new StringBuffer("A Secret");
    public StringBuffer getSecret() {
        return secret;
    }
    public void setSecret(StringBuffer secret) {
        this.secret = secret;
    }
}
public class TestClass {
    public static void main(String[] args) {
        Secret secret = new Secret();
        StringBuffer saidSecret = secret.getSecret();
        saidSecret.append(":broken");
        System.out.println(secret.getSecret());
    }
}

當然。這個例子其實是個特例，因為我們獲取到的私有屬性的引用是StringBuffer類型，是可修改內容的引用，但是如果是String類型的secret，那么我們就沒辦法這樣繞過setter去修改了，因為String類型的引用是不允許修改原值的。

我們都知道的是private屬性是私有的，那么到底是對象私有的還是類私有的呢？答案是后者，我們可以在類定義的內部訪問私有屬性，即使這個屬性是其他對象的，只要是同類的即可，雖然我們很少這么使用，但是這卻深刻地說明java中的訪問權限在類的范疇上。下面說明了這樣一個問題：

class Secret {
    private String secret;
    public String getSecret() {
        return secret;
    }
    public void setSecret(String secret) {
        this.secret = secret;
    }
    public void readOtherSecret(Secret otherSecret) {
        System.out.println(otherSecret.secret);
    }
}
public class TestClass {
    public static void main(String[] args) {
        Secret secret1 = new Secret();
        secret1.setSecret("secret A");
        Secret secret2 = new Secret();
        secret2.setSecret("secret B");
        secret1.readOtherSecret(secret2);
        secret2.readOtherSecret(secret1);
    }
}

static的本意是靜態的，在java里面這個靜態的意思是指存在于靜態的類中的，而非程序開跑之后運行時的動態對象的，所以static的域屬性也好，方法也好，都是指那些存在于類中的域屬性和方法，雖然該類對應的對象中也存在static域屬性和方法的拷貝，但是屬于類的，對于它們的影響將會影響到整個類，換言之這些影響將會產生在所有的類對象中。
static的方法只能訪問static的域屬性，這個是怎么來的呢？其實就是因為static屬性是屬于整個類的，所以static的方法就不應該影響特定的對象的屬性，在實現上說這個方法的隱式參數是不含有非static的方法的指向當前對象的this引用的，因此不能在static方法中訪問非static屬性。

在C++中被反復向初學者討論的一個問題就是swap函數的效果，如果參數是值傳遞的，則最終傳入的兩個值是不會被交換的，如果是指針（引用）傳遞的，那么最終傳入的兩個引用是會被交換的，那么java中的方法參數傳遞是哪種情況呢？答案是前者，即值傳遞，又叫做拷貝實參傳遞，即運行在方法中的形式參數是傳遞給方法的真實參數的拷貝，而非直接傳入實際參數的指針。
下面的例子說明了這個問題：

class Some{
    private String someThing;
    public String getSomeThing() {
        return someThing;
    }
    public void setSomeThing(String someThing) {
        this.someThing = someThing;
    }
    public Some(String someThing) {
        super();
        this.someThing = someThing;
    }
}
public class TestClass {
    public static void swap(Some some1,Some some2){
        Some temp = some1;
        some2 = some1;
        some1 = temp;
    }
    public static void main(String[] args) {
        Some some1 = new Some("1");
        Some some2 = new Some("2");
        swap(some1, some2);
        System.out.println(some1.getSomeThing());
        System.out.println(some2.getSomeThing());
    }
}

我們都知道的是對象的初始化會引發類的初始化，初始化實現的方法也很多，最一般的初始化方法用于對象創建時對域屬性的初始化，稍微少見的類的靜態代碼塊用于對static靜態域屬性進行初始化，而初始化代碼塊則用于對象的域屬性（包括static域屬性）進行初始化，那么一般而言，初始化的順序是怎樣的呢？
首先執行靜態代碼塊初始化static類靜態域屬性用于在整個類及其對象共享；
其次執行初始化代碼塊初始化域屬性以完成對對象的個性化的域屬性的初始化；
最后執行對象的初始化方法以完成進一步的域屬性的初始化。

class Some{
    private String someThing;
    private static String staticSomeThing;
    static
    {
        staticSomeThing = "static";
        System.out.println("static block triggered");
    }
    {
        someThing = "some";
        System.out.println("init block triggered");
    }
    public String getSomeThing() {
        return someThing;
    }
    public void setSomeThing(String someThing) {
        this.someThing = someThing;
    }
    public Some(String someThing) {
        this.someThing = someThing;
        System.out.println("init method triggered");
    }
}
public class TestClass {
    public static void main(String[] args) {
        Some some1 = new Some("1");
    }
}

未完成。。。