Java关键字: protected

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

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

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

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

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); } @Override public String toString() { return "man"; } }

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

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); } @Override public String toString() { return "woman"; } }

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

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成员。

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); //无法访问 } @Override public 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); //无法访问 } @Override public String toString() { return "woman"; } }

5. 不同包，间接子类

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

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); } @Override public 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 visible Person p = new Person(); // p.height = 20; //无法访问 // p.speak(woman); //无法访问 } @Override public 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>是一个道理。