為什么要有訪問權(quán)限控制？

重構(gòu)（Refactor）即對現(xiàn)有代碼進行重新構(gòu)造、書寫，從而使得代碼更具有可讀性、更容易被用戶理解，同時也更具可維護性，這已是現(xiàn)代程序設計中很重要的一個環(huán)節(jié)。然而，重構(gòu)卻并非易事，尤其是對于類庫設計者而言，因為他們所書寫的代碼往往被眾多客戶端程序員使用，而這些使用者是不希望類庫發(fā)生變化的，于他們而言，類庫越穩(wěn)定越好。矛盾就此誕生。
為了解決這一矛盾，Java 提供了訪問權(quán)限控制機制。通過為不同的類、成員設置不同的訪問權(quán)限，以控制客戶端程序員對不同權(quán)限代碼的控制權(quán)，從而間接實現(xiàn)將變動的事物與不變的事物進行區(qū)分的目的。
由此可知，進行訪問權(quán)限控制主要有兩方面原因：

• 第一是為了使用戶（通常指客戶端程序員）不要觸碰那些他們不該觸碰的部分，這部分對于類內(nèi)部的操作是必要的，但是它并不屬于客戶端程序員所需接口的一部分。因此，將這一類方法和域設為private的，對于客戶端程序員而言是一種服務，因為這樣的話，他們可以比較清楚地了解到在類庫中哪一部分對他們而言是重要的，需要了解的，哪一部分是不需要進行研究，可以忽略的，這樣可以簡化他們的工作；
• 第二是為了讓類庫的設計者能夠?qū)⑻峁┙o客戶使用的代碼與用于類內(nèi)部工作的代碼區(qū)分開來，從而能夠?qū)︻悆?nèi)部代碼進行修改而不用擔心這樣會對客戶端程序員產(chǎn)生重大影響。比如某個類庫設計者開始設計了一個類庫，提供了一些很有實用價值的類給其他程序員使用以簡化他們的工作，但是后面又發(fā)現(xiàn)通過對代碼進行重構(gòu)，改寫某些方法，可以使得該類庫的性能大大提升。此時就會發(fā)現(xiàn)將接口與實現(xiàn)相分離是多么的重要，這樣該類庫設計者就可以對內(nèi)部結(jié)構(gòu)進行修改而不影響外部使用者對已有接口的使用了。Java 訪問權(quán)限控制就可以確保不會有任何客戶端程序員會依賴于某一個類的底層實現(xiàn)細節(jié)。

如何進行訪問權(quán)限控制？

Java訪問權(quán)限控制機制提供了大小不同的四種訪問權(quán)限修飾詞，分別代表對于類、成員、方法（為方便起見，以下將類、成員和方法這些能被訪問權(quán)限修飾詞修飾的部分統(tǒng)稱為成員）的不同訪問權(quán)限。這四種權(quán)限由大至小依次為：public、protected、package和private。

• public：接口訪問權(quán)限，該訪問權(quán)限意味著任何包中的任何類都可以對該成員進行訪問；
• protected：繼承訪問權(quán)限，擁有繼承訪問權(quán)限的成員可以被同一包中的其他類訪問、也可以被該類的子類訪問（無論是否處于同一個包中），但是不能被不同包中的非子類訪問；
• package：包訪問權(quán)限，也是默認訪問權(quán)限，當未給成員賦予任何訪問權(quán)限修飾詞時，該成員即為包訪問權(quán)限，擁有該訪問權(quán)限的成員只能被同一包中的類訪問；不同包中的類無訪問權(quán)（即便是子類也不行）；
• private：私有權(quán)限，該權(quán)限意味著除了包含該成員的類以外，其余的類均不能夠訪問該成員。
  下面通過一個表格說明這四類訪問權(quán)限的作用域，會更加簡潔明了。

包：庫單元

Java 語言中，包可以看做是一個庫單元，一個包內(nèi)會包含一組類，這組類在單一的名字空間之下被組織在一起，通常是為了完成同一類功能。

當編寫一個Java源代碼文件時，此文件通常被稱之為一個編譯單元（即一個.java的文件），每個編譯單元都只能有** 0~1 **個public類，但允許存在多個非public的類。經(jīng)過編譯，每個類均會有一個與之相對應的 .class 文件，Java可運行程序就是一組可以打包并壓縮為一個 Java文檔文件（jar文件）的 .class文件。Java解釋器負責這些文件的查找、裝載和解釋。

Java 解釋器的運行過程如下：首先，找出環(huán)境變量CLASSPATH（可以通過操作系統(tǒng)來設置，有時也可通過安裝程序來設置）CLASSPATH包含一個或多個目錄，用作查找.class文件的根目錄，從根目錄開始，解釋器獲取包的名稱并將每個句點替換成反斜杠，以從CLASSPATH根中產(chǎn)生一個路徑名稱。得到的路徑會與CLASSPATH中各個不同的項相連接，解釋器就在這些目錄中查找與你所要創(chuàng)建的類名稱相關(guān)的.class文件。解釋器還會去查找某些涉及Java解釋器所在位置的標準目錄。

小技巧：通過 import 改變行為
Java沒有C的條件編譯功能，該功能能夠可以使你不必更改任何程序代碼就能夠切換開關(guān)并產(chǎn)生不同的行為。Java去掉此功能的原因可能是因為C在大多數(shù)情況下使用此功能來解決跨平臺問題，即程序代碼的不同部分是根據(jù)不同的平臺來編譯的。由于Java自身可以自動跨越不同的平臺，因此該功能于Java而言作用不大。但是條件編譯也還有一些其他方面的功能，如調(diào)試。調(diào)試功能在開發(fā)過程中是開啟的，而在發(fā)布的產(chǎn)品中是禁用的。不過在Java中可以通過修改被導入的package來實現(xiàn)這一目的，也就是說留有兩個package，一個包含調(diào)試時的代碼，一個包含發(fā)布時的代碼，這樣通過import不同的包便可以實現(xiàn)切換。

總結(jié)

• Java語言通過訪問權(quán)限控制機制實現(xiàn)將將變動的事物與不變的事物進行區(qū)分的目的；
• Java中的訪問權(quán)限由寬至緊依次為：public、protected、package和private；
• Java非內(nèi)部類只能擁有public或package兩種權(quán)限，不能被設為protected或private，不能設為private很好理解，因為如果將類設為private的，那么該類就只能被自己訪問，這樣的類毫無意義，至于為什么不能設為protected，不是很清楚；但是內(nèi)部類四種權(quán)限均可以使用；
• 取得對某一成員的訪問控制權(quán)的方法：
  1. 將該成員設為 public ，這樣任何類均可以訪問該成員；
  2. 不設該成員的訪問權(quán)限，并將需要訪問該成員的類置于同一個包中；
  3. 通過繼承來訪問，同一包中的子類可以訪問父類的public、protected和package成員，非同一包中的子類可以訪問父類的public和protected成員；

4. 通過提供訪問器和變異器（即get/set方法）修改類的成員變量；

實驗基地

任何理論只有落于實處才能真正為人所理解，編程語言就更是如此啦，說了那么一大堆，還不如幾行代碼來的實在。本實驗基地就通過幾個類演示 Java 的訪問權(quán)限控制機制。

• 有兩個包：AccessTest和AccessTest2
• ClassAccess 和 AccessA位于同一個 Java文件中，均包含四種訪問權(quán)限的方法
• 通過AccessMain 、AccessMain2 和 Child 三個類可以檢驗四種不同訪問權(quán)限在同一個包中、不同包中和不同包子類中的可訪問性

package AccessTest;
import static util.OutUtil.print;

public class ClassAccess {

    public ClassAccess() {
        print("public AccessA");
    }

    public void publicMethod(){
        print("public method in ClassAccess");
    }

    void packageMethod(){
        print("package method in ClassAccess");
    }

    protected void protectedMethod(){
        print("protected method in ClassAccess");
    }

    private void privateMethod(){
        print("private method in ClassAccess");
    }
}

class AccessA{

    public class classA{}
    protected class classB{}
    class classC{}
    private class classD{}

    public AccessA() {
        print("public AccessA");
    }

    public void publicMethod(){
        print("public method in AccessA");
    }

    void packageMethod(){
        print("package method in AccessA");
    }

    protected void protectedMethod(){
        print("protected method in AccessA");
    }

    private void privateMethod(){
        print("private method in AccessA");
    }
}

// 用 protected 或 private 修飾類時會提示
// modifier 'protected'或 'private' not allowed here
//private class AccessB{
//    public AccessB() {
//        print("public AccessB");
//    }
//}

package AccessTest;

public class AccessMain {
    public static void main(String[] args) {
        ClassAccess test1 = new ClassAccess();
        test1.publicMethod();
        test1.protectedMethod();
        test1.packageMethod();
       // test1.privateMethod();  privateMethod() has 'private' access

        AccessA test2 = new AccessA();
        test2.publicMethod();
        test2.protectedMethod();
        test2.packageMethod();
        // test2.privateMethod();  privateMethod() has 'private' access
    }
}

package AccessTest2;
import AccessTest.ClassAccess;

public class AccessMain2 {
    public static void main(String[] args) {
        ClassAccess test3 = new ClassAccess();
        test3.publicMethod();
//      test3.protectedMethod();    // protectedMethod() has 'protected' access
//      test3.packageMethod();
// packageMethod() is not public, cannot be accessed from outside package
//      test3.privateMethod();  privateMethod() has 'private' access
    }
}

package AccessTest2;
import AccessTest.ClassAccess;

public class Child extends ClassAccess {

    void testf(){
        super.publicMethod();
        super.protectedMethod();
//      super.packageMethod();
// packageMethod() is not public, cannot be accessed from outside package
//      super.privateMethod();  // privateMethod() has private access
    }
}