很多介绍Java语言的书籍(包括《Java编程思想》)都对protected介绍的比较的简单，基本都是一句话，就是: 被 protected 修饰的成员对于本包和其子类可见。这种说法有点太过含糊，常常会对大家造成误解。实际上，protected的可见性在于两点：
基类的 protected 成员是包内可见的，并且对子类可见；
若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。
我们可以通过以下几个关于protected方法可见性的例子来进一步掌握protected关键字。在碰到涉及protected成员的调用时，首先要确定出该protected成员来自何方，其可见性范围是什么，然后就可以判断出当前用法是否可行了，看下面七个例子：
实例 1
1 package p1;
2 public class Father1 {
3 protected void f() {} // 父类Father1中的protected方法
4 }
5
6 package p1;
7 public class Son1 extends Father1 {}
8
9 package p11;
10 public class Son11 extends Father1{}
11
12 package p1;
13 public class Test1 {
14 public static void main(String[] args) {
15 Son1 son1 = new Son1();
16 son1.f(); // Compile OK ----（1）
17 son1.clone(); // Compile Error ----（2）
18
19 Son11 son = new Son11();
20 son11.f(); // Compile OK ----（3）
21 son11.clone(); // Compile Error ----（4）
22 }
23 }
对于上面的示例，首先看(1)(3)，其中的f()方法从类Father1继承而来，其可见性是包p1及其子类Son1和Son11，而由于调用f()方法的类Test1所在的包也是p1，因此（1）(3)处编译通过。其次看(2)(4)，其中的clone()方法的可见性是java.lang包及其所有子类，对于语句"son1.clone();"和"son11.clone();"，二者的clone()在类Son1、Son11中是可见的，但对Test1是不可见的，因此（2）(4)处编译不通过。
实例 2
1 package p2;
2 class MyObject2 {
3 protected Object clone() throws CloneNotSupportedException{
4 return super.clone();
5 }
6 }
7
8 package p22;
9 public class Test2 extends MyObject2 {
10 public static void main(String args[]) {
11 MyObject2 obj = new MyObject2();
12 obj.clone(); // Compile Error ----（1）
13
14 Test2 tobj = new Test2();
15 tobj.clone(); // Complie OK ----（2）
16 }
17 }
对于(1)而言，clone()方法来自于类MyObject2本身，因此其可见性为包p2及MyObject2的子类，虽然Test2是MyObject2的子类，但在Test2中不能访问基类MyObject2的protected方法clone()，因此编译不通过;对于(2)而言，由于在Test2中访问的是其本身实例的从基类MyObject2继承来的的clone()，因此编译通过。
实例 3
1 package p3;
2 class MyObject3 extends Test3 {
3 }
4
5 package p33;
6 public class Test3 {
7 public static void main(String args[]) {
8 MyObject3 obj = new MyObject3();
9 obj.clone(); // Compile OK ------（1）
10 }
11 }
对于(1)而言，clone()方法来自于类Test3，因此其可见性为包p33及其子类MyObject3，而（1）正是在p33的类Test3中调用，属于同一包，编译通过。
实例 4
1 package p4;
2 class MyObject4 extends Test4 {
3 protected Object clone() throws CloneNotSupportedException {
4 return super.clone();
5 }
6 }
7
8 package p44;
9 public class Test4 {
10 public static void main(String args[]) {
11 MyObject4 obj = new MyObject4();
12 obj.clone(); // Compile Error -----（1）
13 }
14 }
对于(1)而言，clone()方法来自于类MyObject4，因此其可见性为包p4及其子类(此处没有子类)，而类Test4却在包p44中，因此不满足可见性，编译不通过。
实例 5
1 package p5;
2
3 class MyObject5 {
4 protected Object clone() throws CloneNotSupportedException{
5 return super.clone();
6 }
7 }
8 public class Test5 {
9 public static void main(String[] args) throws CloneNotSupportedException {
10 MyObject5 obj = new MyObject5();
11 obj.clone(); // Compile OK ----(1)
12 }
13 }
对于(1)而言，clone()方法来自于类MyObject5，因此其可见性为包p5及其子类(此处没有子类)，而类Test5也在包p5中，因此满足可见性，编译通过。
实例 6
1 package p6;
2
3 class MyObject6 extends Test6{}
4 public class Test6 {
5 public static void main(String[] args) {
6 MyObject6 obj = new MyObject6();
7 obj.clone(); // Compile OK -------（1）
8 }
9 }
对于(1)而言，clone()方法来自于类Test6，因此其可见性为包p6及其子类MyObject6，而类Test6也在包p6中，因此满足可见性，编译通过。
实例 7
1 package p7;
2
3 class MyObject7 extends Test7 {
4 public static void main(String[] args) {
5 Test7 test = new Test7();
6 test.clone(); // Compile Error ----- (1)
7 }
8 }
9
10 public class Test7 {
11 }
对于(1)而言，clone()方法来自于类Object，因此该clone()方法可见性为包java.lang及其子类Test7，由于类MyObject7不在此范围内，因此不满足可见性，编译不通过。