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. 同包下，间接子类，可以访问父类的 protected 成员

class Wife extends Woman {
	
	void tt() {
		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>是一个道理。