为什么要有访问权限控制？

重构（Refactor）即对现有代码进行重新构造、书写，从而使得代码更具有可读性、更容易被用户理解，同时也更具可维护性，这已是现代程序设计中很重要的一个环节。然而，重构却并非易事，尤其是对于类库设计者而言，因为他们所书写的代码往往被众多客户端程序员使用，而这些使用者是不希望类库发生变化的，于他们而言，类库越稳定越好。矛盾就此诞生。
为了解决这一矛盾，Java 提供了访问权限控制机制。通过为不同的类、成员设置不同的访问权限，以控制客户端程序员对不同权限代码的控制权，从而间接实现将变动的事物与不变的事物进行区分的目的。
由此可知，进行访问权限控制主要有两方面原因：

• 第一是为了使用户（通常指客户端程序员）不要触碰那些他们不该触碰的部分，这部分对于类内部的操作是必要的，但是它并不属于客户端程序员所需接口的一部分。因此，将这一类方法和域设为private的，对于客户端程序员而言是一种服务，因为这样的话，他们可以比较清楚地了解到在类库中哪一部分对他们而言是重要的，需要了解的，哪一部分是不需要进行研究，可以忽略的，这样可以简化他们的工作；
• 第二是为了让类库的设计者能够将提供给客户使用的代码与用于类内部工作的代码区分开来，从而能够对类内部代码进行修改而不用担心这样会对客户端程序员产生重大影响。比如某个类库设计者开始设计了一个类库，提供了一些很有实用价值的类给其他程序员使用以简化他们的工作，但是后面又发现通过对代码进行重构，改写某些方法，可以使得该类库的性能大大提升。此时就会发现将接口与实现相分离是多么的重要，这样该类库设计者就可以对内部结构进行修改而不影响外部使用者对已有接口的使用了。Java 访问权限控制就可以确保不会有任何客户端程序员会依赖于某一个类的底层实现细节。

如何进行访问权限控制？

Java访问权限控制机制提供了大小不同的四种访问权限修饰词，分别代表对于类、成员、方法（为方便起见，以下将类、成员和方法这些能被访问权限修饰词修饰的部分统称为成员）的不同访问权限。这四种权限由大至小依次为：public、protected、package和private。

• public：接口访问权限，该访问权限意味着任何包中的任何类都可以对该成员进行访问；
• protected：继承访问权限，拥有继承访问权限的成员可以被同一包中的其他类访问、也可以被该类的子类访问（无论是否处于同一个包中），但是不能被不同包中的非子类访问；
• package：包访问权限，也是默认访问权限，当未给成员赋予任何访问权限修饰词时，该成员即为包访问权限，拥有该访问权限的成员只能被同一包中的类访问；不同包中的类无访问权（即便是子类也不行）；
• private：私有权限，该权限意味着除了包含该成员的类以外，其余的类均不能够访问该成员。
  下面通过一个表格说明这四类访问权限的作用域，会更加简洁明了。

包：库单元

Java 语言中，包可以看做是一个库单元，一个包内会包含一组类，这组类在单一的名字空间之下被组织在一起，通常是为了完成同一类功能。

当编写一个Java源代码文件时，此文件通常被称之为一个编译单元（即一个.java的文件），每个编译单元都只能有** 0~1 **个public类，但允许存在多个非public的类。经过编译，每个类均会有一个与之相对应的 .class 文件，Java可运行程序就是一组可以打包并压缩为一个 Java文档文件（jar文件）的 .class文件。Java解释器负责这些文件的查找、装载和解释。

Java 解释器的运行过程如下：首先，找出环境变量CLASSPATH（可以通过操作系统来设置，有时也可通过安装程序来设置）CLASSPATH包含一个或多个目录，用作查找.class文件的根目录，从根目录开始，解释器获取包的名称并将每个句点替换成反斜杠，以从CLASSPATH根中产生一个路径名称。得到的路径会与CLASSPATH中各个不同的项相连接，解释器就在这些目录中查找与你所要创建的类名称相关的.class文件。解释器还会去查找某些涉及Java解释器所在位置的标准目录。

小技巧：通过 import 改变行为
Java没有C的条件编译功能，该功能能够可以使你不必更改任何程序代码就能够切换开关并产生不同的行为。Java去掉此功能的原因可能是因为C在大多数情况下使用此功能来解决跨平台问题，即程序代码的不同部分是根据不同的平台来编译的。由于Java自身可以自动跨越不同的平台，因此该功能于Java而言作用不大。但是条件编译也还有一些其他方面的功能，如调试。调试功能在开发过程中是开启的，而在发布的产品中是禁用的。不过在Java中可以通过修改被导入的package来实现这一目的，也就是说留有两个package，一个包含调试时的代码，一个包含发布时的代码，这样通过import不同的包便可以实现切换。

总结

• Java语言通过访问权限控制机制实现将将变动的事物与不变的事物进行区分的目的；
• Java中的访问权限由宽至紧依次为：public、protected、package和private；
• Java非内部类只能拥有public或package两种权限，不能被设为protected或private，不能设为private很好理解，因为如果将类设为private的，那么该类就只能被自己访问，这样的类毫无意义，至于为什么不能设为protected，不是很清楚；但是内部类四种权限均可以使用；
• 取得对某一成员的访问控制权的方法：
  1. 将该成员设为 public ，这样任何类均可以访问该成员；
  2. 不设该成员的访问权限，并将需要访问该成员的类置于同一个包中；
  3. 通过继承来访问，同一包中的子类可以访问父类的public、protected和package成员，非同一包中的子类可以访问父类的public和protected成员；

4. 通过提供访问器和变异器（即get/set方法）修改类的成员变量；

实验基地

任何理论只有落于实处才能真正为人所理解，编程语言就更是如此啦，说了那么一大堆，还不如几行代码来的实在。本实验基地就通过几个类演示 Java 的访问权限控制机制。

• 有两个包：AccessTest和AccessTest2
• ClassAccess 和 AccessA位于同一个 Java文件中，均包含四种访问权限的方法
• 通过AccessMain 、AccessMain2 和 Child 三个类可以检验四种不同访问权限在同一个包中、不同包中和不同包子类中的可访问性

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
    }
}