Java访问权限控制-带你详细了解protected关键字（图）

摘要：

　　在一个类的内部，其成员（包括成员变量和成员方法）能否被其他类所访问，取决于该成员的修饰词；而一个类能否被其他类所访问，取决于该类的修饰词。Java的类成员访问权限修饰词有四类：private，无（默认情况下，包访问权限），protected 和 public，而其中只有包访问权限和public才能修饰一个类（内部类除外）。特别地，很多的介绍Java的书籍对protected介绍的比较笼统，常常会对大家造成误解。因此，本文重点揭示了 protected 关键字的内涵和用法，并介绍了一些其他的修饰符。

版权声明：

本文原创作者：书呆子Rico
作者博客地址：http://www.php.cn/

一. Package

　　关于包的使用，我们只需注意一点：在一个项目中，不可以有相同的两个包名，也就是说，我们的包名不能和项目中其他的包名重复，这里不但包括自定义包名也包括项目所引用的类库的包名。看下面例子：

package java.lang;public class MyObject {
    public static void main(String[] args) throws CloneNotSupportedException {
        Object o = new Object();
        System.out.println(o.hashCode());
    }
}

　　我们给自己的程序的包名是 java.lang，事实上，我们知道 java.lang 是JDK使用的包名。程序可以正常编译，但当我们运行程序时会有包冲突警告并抛出 “java.lang.SecurityException: Prohibited package name: java.lang” 异常，如下图所示。

　　此外，我们需要注意：如果我们在程序中使用了Package语句，那么它必须是文件中除注释外第一句程序代码，否则不能通过编译。

二. Java访问权限概述

　　 在一个类的内部，其成员（包括成员变量和成员方法）能否被其他类所访问，取决于该成员的修饰词。Java的类成员访问权限修饰词有四类：private，无（默认情况下，包访问权限），protected 和 public。其权限控制如下表所示：

　　特别要注意的是，对于Java中的 类（不是其内部成员，两者要区分开），其访问权限修饰词仅有 public 和 “无”（即包访问权）两种，而没有 private 和 protected（有一个特例，只有内部类可以是private或protected的，关于内部类进一步了解请见我的博客《Java 内部类综述》）。因此，对于非内部类，我们只能赋予其包访问权限或是 public 。如果你不希望其他任何人对该类拥有访问权，你可以把所有的构造器都指定为 private，从而阻止任何人创建该类的对象。这个时候，该类的对象就只能在其 static 成员内部进行创建，这种情形有点像单例模式，例如像下面的例子那样：

 class Test {       // private Constructor!
       private Test() {}       // Allow creation via static method:
       public static Test getTest() {           return new Test();
       }
    }

　　在上面所提到的四种修饰词中，除 protected 外，都很好理解和掌握，我们在此进行简述：

• public ：被public修饰的类成员能被所有的类直接访问；

• private：被public修饰的类成员只能在定义它的类中被访问，其他类都访问不到。特别地，我们一般建议将成员变量设为private的，并为外界提供 getter/setter 去对成员变量进行访问，这种做法充分体现了Java面向对象的四大特性(封装，多态，继承，抽象)中的封装思想；

• 包访问权限：包访问权限就是Java中的默认的权限，具有包访问权限的类成员只能被同一包中的类访问。

  　　由于 protected 关键字的真正内涵不太容易理解，我们将在下一节专门介绍 protected 关键字。

三. protected 关键字的真正内涵

　　很多的有关介绍Java语言的书籍 (包括《Java编程思想》)，都对protected介绍的比较的简单，基本都是一句话，就是:被protected修饰的成员对于本包和其子类可见。这种说法有点太过含糊，常常会对大家造成误解。对于protected的成员，要分子类和超类是否在同一个包中两种情况看待，现以 protected方法的调用为例进行说明，protected的成员变量类似。

　　实质上，protected方法的调用是否合法(编译是否通过)关键是要看被调用的protected方法从根源上看所在的类对应的包与调用代码所在的类对应的包是否相同，若相同，则合法；否则，不合法。当然，无论如何，子类是可以访问继承而来的属于它自己的受保护方法的。

　　我们可以看下面例子进行了解。

1). 第一种情形：子类与基类不在同一个包中

//示例一package p1;public class Father1 {
    protected void f() {}   
    // 父类Father1中的protected方法}package p1;
    public class Son1 extends Father {}package p11;
    public class Son11 extends Father{}package p1;
    public class Test1 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK，protected方法f()来自于Father1类，与 Test1类 在同一包p1中
        son1.clone(); // Compile Error，protected方法clone()来自于Object类，与 Test1类不在同一包中

        Son11 son = new Son11();
        son11.f(); // Compile OK，虽然Son11类在包p11中，但protected方法f()来自于Father1类，与 Test1类在同一包p1中
        son11.clone(); // Compile Error，protected方法clone()来自于Object类，与 Test1类不在同一包中
    }
}

　　在上面的示例中，类Father1、Son1 和 Test1 在同一个包p1下，类Son11在包p11下。但是我们知道，无论Son1类还是Son11类，它们的protected方法f()在根源上都来自于p1包中的类Father1，而由于Test1也在p1包中，因此f()方法对Test1类可见，编译通过。但由于Son1类和Son11类中的clone()方法在根源上均来自于java.lang包下的类Object，与 Test1类不在同一包中，因此clone()方法对Test1类不可见，编译不通过。

//示例二package p2;
class MyObject2 {protected Object clone() throws CloneNotSupportedException {       
return super.clone();
    }
}package p22;public class Test2 extends MyObject2 {
    public static void main(String args[]) {
       MyObject2 obj = new MyObject2();
       obj.clone(); // Compile Error，protected方法clone()来自于MyObject2类，与 Test2类 不在同一包p1中

       Test2 tobj = new Test2();
       tobj.clone();// Complie OK，虽然 protected方法clone()来自于MyObject2类，与 Test2类 不在同一包p1中，但Test2类作为MyObject2类的子类，是可以访问继承而来的属于它自己的受保护方法的。
    }
}

　　在上面的示例中，类MyObject2 和 类Test2 分别在包 p2 和 p22 下。因此，在类Test2中通过MyObject2的引用调用MyObject2的protected方法clone()时，由于类MyObject2 和 类Test2 不在同一包中而编译不通过。但是我们知道，虽然 类Test2 的protected方法clone()在根源上也来源于 类MyObject2，但是Test2类作为MyObject2类的子类，是可以访问继承而来的属于它自己的受保护方法的。

//示例三package p3;
class MyObject3 extends Test3 {
}package p33;public class Test3 {
  public static void main(String args[]) {
    MyObject3 obj = new MyObject3();
    obj.clone(); // Compile OK，protected方法clone()来自于Test3类，而现在正是在Test3类中访问该方法
  }
}

　　在上面的示例中，类MyObject3 和 类Test3 分别在包 p3 和 p33 下。但是由于 MyObject3类的protected方法clone()在根源上来自于类Test3中，而现在正是在Test3类中访问该方法，因此编译通过，原理与示例一类似。

//示例四package p4;
class MyObject4 extends Test4 {  
protected Object clone() throws CloneNotSupportedException {    
return super.clone();
  }
}package p44;public class Test4 {
  public static void main(String args[]) {
    MyObject4 obj = new MyObject4();
    obj.clone(); // Compile Error，protected方法clone()来自于MyObject4类，而Test4类与MyObject4类不在同一个包中
  }
}

　　该示例与示例三很类似，唯一不同的是 类MyObject4 重写了从 类Test4 中继承过来的protected方法clone()。这样，MyObject4 的 protected方法clone()在根源上来自于类本身而非Test4类。而类MyObject4 和 类Test4 又不在同一包下，因此编译不通过。

2). 第二种情形：子类与基类在同一个包中

//示例五package p5;

class MyObject5 {    protected Object clone() throws CloneNotSupportedException {       return super.clone();
    }
}public class Test5 {
    public static void main(String[] args) throws CloneNotSupportedException {
       MyObject5 obj = new MyObject5();
       obj.clone(); // Compile OK，protected方法clone()来自于MyObject5类，而Test5类与MyObject5类又在同一个包中
    }
}

　　该示例与示例四很类似，唯一不同的是 类MyObject5 与 类Test5在同一个包p5中。正因为二者在同一包中，因此编译通过。

//示例六package p6;

class MyObject6 extends Test6{}public class Test6 {
  public static void main(String[] args) {
    MyObject6 obj = new MyObject6();
    obj.clone();        // Compile OK
  }
}

　　在本示例中，由于类MyObject中的protected方法clone()从根源上来自于Test6类，而现在正是在 Test6 中调用protected方法clone()，因此编译通过。

//示例七package p7;

class MyObject7 extends Test7 {    public static void main(String[] args) {
        Test7 test = new Test7();
        test.clone(); // Compile Error.
  }
}public class Test {}

　　在本示例中，虽然类MyObject7与Test7类在同一个包p7中，但是由于 类Test7 的protected方法clone()从根源上来自于 java.lang.Object类，而其又与MyObject7不在同一个包中，因此编译不通过。

四. 其他的修饰符

static：修饰变量和内部类(不能修饰常规类)，其中所修饰变量称为类变量或静态变量。静态变量是和类存在一起的,每个实例共享这个静态变量，在类加载时初始化。

final：被声明为final的变量必须在声明时给定初值（当然，空白 final 情形除外），而且被修饰的变量不能修改值。当修饰类时，该类不能派生出子类；修饰方法时，该方法不能被子类覆盖。若读者想对 final 有一个更深刻的了解，请移步我的博文 《Java 继承、多态与类的复用》。

abstract：修饰类和方法。当修饰类时，该类不能创建对象；修饰方法时，为抽象方法。类只要有一个abstract方法，类就必须定义为abstract，但abstract类不一定非要有abstract方法不可。

五. 总结

　　在一个类的内部，其成员（包括成员变量和成员方法）能否被其他类所访问，取决于该成员的修饰词；而一个类能否被其他类所访问，取决于该类的修饰词。Java的类成员访问权限修饰词有四类：private，无（默认情况下，包访问权限），protected 和 public，而其中只有包访问权限和public才能修饰一个类（内部类除外）。特别地，本文重点揭示了 protected 关键字的内涵和用法，并介绍了一些其他的修饰符。

六. 说明

　　在综述本章的过程中，我们涉及到了很多知识点，其中有一些我们已经在其他博文中专门提到过，因此没有作更多详细的阐述，这里给出对应的链接：

以上就是Java访问权限控制-带你详细了解protected关键字（图）的详细内容，更多请关注php教程其它相关文章！