Java关键字: protected

 

Java关键字: protected

在开发中，经常遇见protected关键字。特别是一些回调方法中，今天小结一下。

下面先展示一下关于Java中访问权限的修饰符之间的关系，如下图所示：

做几个测试，说明protected关键字。

1.同一个包不同类中，可以访问protected成员，无继承关系

Java代码

1. package mark.test;   
2. public class Person {   
3.     protected int height;   
4.        
5.     protected void speak(Object obj) {   
6.         System.out.println("I'm " + obj + "!");   
7.     }   
8. }   
9. /**  
10.  * 同一个包不同类中，可以访问protected成员  
11.  * 无继承关系  
12.  */  
13. class Man {   
14.        
15.     public static void main(String[] args) {   
16.         Person p = new Person();   
17.         Man man = new Man();   
18.         p.height = 10;   
19.         p.speak(man);   
20.     }   
21.        
22.     @Override  
23.     public String toString() {   
24.         return "man";   
25.     }   
26. }  

package mark.test;public class Person {protected int height;protected void speak(Object obj) {System.out.println("I'm " + obj + "!");}}/** * 同一个包不同类中，可以访问protected成员 * 无继承关系 */class Man {public static void main(String[] args) {Person p = new Person();Man man = new Man();p.height = 10;p.speak(man);}@Overridepublic String toString() {return "man";}}

2. 同一个包不同类中，可以访问protected成员，具有继承关系

Java代码

1. package mark.test;   
2. public class Person {   
3.     protected int height;   
4.        
5.     protected void speak(Object obj) {   
6.         System.out.println("I'm " + obj + "!");   
7.     }   
8. }   
9. /**  
10.  * 同一个包不同类中，可以访问protected成员  
11.  * 具有继承关系  
12.  */  
13. class Woman extends Person {   
14.        
15.     public static void main(String[] args) {   
16.         Woman w = new Woman();   
17.         w.speak(w);   
18.     }   
19.        
20.     @Override  
21.     public String toString() {   
22.         return "woman";   
23.     }   
24. }  

package mark.test;public class Person {protected int height;protected void speak(Object obj) {System.out.println("I'm " + obj + "!");}}/** * 同一个包不同类中，可以访问protected成员 * 具有继承关系 */class Woman extends Person {public static void main(String[] args) {Woman w = new Woman();w.speak(w);}@Overridepublic String toString() {return "woman";}}

3. 同包下，间接子类，也可以访问

Java代码

1. package mark.test;   
2. public class Person {   
3.     protected int height;   
4.        
5.     protected void speak(Object obj) {   
6.         System.out.println("I'm " + obj + "!");   
7.     }   
8. }   
9. /**  
10.  * 该子类Wife无法访问父类Person的protected成员  
11.  *  
12.  * Wife是Person的间接子类  
13.  */  
14. class Wife extends Woman {   
15.     Wife wife = new Wife();   
16.     //wife.speak(wife);//出错   
17.     Woman woman = new Woman();   
18.     //woman.speak(woman);//出错   
19.     Person p = new Person();   
20. //  p.height = 20; //无法访问   
21. //  p.speak(man); //无法访问   
22. }  

package mark.test;public class Person {protected int height;protected void speak(Object obj) {System.out.println("I'm " + obj + "!");}}/** * 该子类Wife无法访问父类Person的protected成员 * * Wife是Person的间接子类 */class Wife extends Woman {Wife wife = new Wife();//wife.speak(wife);//出错Woman woman = new Woman();//woman.speak(woman);//出错Person p = new Person();//p.height = 20; //无法访问//p.speak(man); //无法访问}

4. 不同包，继承与不继承

不同包下的，即使具有继承关系的子类中，该父类对象也不可以访问自己的protected成员。

Java代码

1. package mark.zhang;   
2. import mark.test.Person;   
3. /**  
4.  * 不同包下的类不可以访问父类的protected成员  
5.  *   
6.  * 不具有继承关系  
7.  */  
8. public class Man {   
9.        
10.     public static void main(String[] args) {   
11.         Person p = new Person();   
12. //      p.height = 20; //无法访问   
13. //      p.speak(man); //无法访问   
14.     }   
15.        
16.     @Override  
17.     public String toString() {   
18.         return "man";   
19.     }   
20. }   
21. /**  
22.  * 不同包下的子类可以访问父类的protected成员  
23.  *   
24.  * 具有继承关系  
25.  */  
26. class Woman extends Person {   
27.        
28.     public static void main(String[] args) {   
29.         Woman w = new Woman();   
30.         w.height = 100;   
31.         w.speak(w);   
32.         Person p = new Person();   
33. //      p.height = 20; //无法访问   
34. //      p.speak(man); //无法访问   
35.     }   
36.        
37.     @Override  
38.     public String toString() {   
39.         return "woman";   
40.     }   
41. }  

package mark.zhang;import mark.test.Person;/** * 不同包下的类不可以访问父类的protected成员 * * 不具有继承关系 */public class Man {public static void main(String[] args) {Person p = new Person();//p.height = 20; //无法访问//p.speak(man); //无法访问}@Overridepublic String toString() {return "man";}}/** * 不同包下的子类可以访问父类的protected成员 * * 具有继承关系 */class Woman extends Person {public static void main(String[] args) {Woman w = new Woman();w.height = 100;w.speak(w);Person p = new Person();//p.height = 20; //无法访问//p.speak(man); //无法访问}@Overridepublic String toString() {return "woman";}}

5. 不同包，间接子类

父类的protected方法对于不同包下的间接子类是不可见的，即不可以访问！

Java代码

1. package mark.zhang;   
2. public class Person {   
3.     protected int height;   
4.        
5.     protected void speak(Object obj) {   
6.         System.out.println("I'm " + obj + "!");   
7.     }   
8. }   
9. package mark.zhang;   
10. /**  
11.  * 同一个包不同类中，可以访问protected成员  
12.  * 具有继承关系  
13.  */  
14. public class Woman extends Person {   
15.        
16.     public static void main(String[] args) {   
17.         Woman w = new Woman();   
18.         w.speak(w);   
19.     }   
20.        
21.     @Override  
22.     public String toString() {   
23.         return "woman";   
24.     }   
25. }   
26. package mark.test;   
27. import mark.zhang.Person;   
28. import mark.zhang.Woman;   
29. /**  
30.  * 该子类Wife不可以访问父类Person的protected成员  
31.  *  
32.  * Wife是Person的间接子类  
33.  */  
34. class Wife extends Woman {   
35.     public static void main(String[] args) {   
36.         Wife wife = new Wife();   
37.         wife.speak(wife);//出错   
38.         Woman woman = new Woman();   
39.         // woman.speak(woman);//出错,The method speak(Object) from the type Person is not visible  
40.         Person p = new Person();   
41.         // p.height = 20; //无法访问   
42.         // p.speak(woman); //无法访问   
43.     }   
44.        
45.     @Override  
46.     public String toString() {   
47.         return "wife";   
48.     }   
49. }  

package mark.zhang;public class Person {protected int height;protected void speak(Object obj) {System.out.println("I'm " + obj + "!");}}package mark.zhang;/** * 同一个包不同类中，可以访问protected成员 * 具有继承关系 */public class Woman extends Person {public static void main(String[] args) {Woman w = new Woman();w.speak(w);}@Overridepublic String toString() {return "woman";}}package mark.test;import mark.zhang.Person;import mark.zhang.Woman;/** * 该子类Wife不可以访问父类Person的protected成员 * * Wife是Person的间接子类 */class Wife extends Woman {public static void main(String[] args) {Wife wife = new Wife();wife.speak(wife);//出错Woman woman = new Woman();// woman.speak(woman);//出错,The method speak(Object) from the type Person is not visiblePerson p = new Person();// p.height = 20; //无法访问// p.speak(woman); //无法访问}@Overridepublic String toString() {return "wife";}}

ok，测试结束！！！

总结：

<1> 同包同类中，可以自由访问protected成员

<2>同包不同类中，无任何继承关系，可以自由访问protected成员

<3>同包不同类中，具有继承关系，任何子类或者子类的子类都可以访问protected成员

<4> 不同包不同类中，不具有继承关系，不可以访问其它类protected成员

<5>不同包不同类中，具有继承关系，子类可以访问父类protected成员。但是父类对象不可以访问自己的protected成员，否则报这样的错误：The method speak(Object) from the type Person is not visible

<6>不同包不同类中，具有继承关系，间接子类中除该类对象自己外，它的直接父类，以及间接父类都不可以访问自己的protected成员。其实，这与<5>是一个道理。