1.Java有三种访问权限修饰符，分别为public、protected、private，还有一种为缺省权限修饰符的情况，记为default。其中，可以由public和default来修饰类；这四种修饰符都可以修饰成员变量和成员方法。每一种修饰符对应不同的访问范围，下面以下图为例详细说明。

图1

  • private只可以覆盖圆1，即只有本类可以访问；
  • default可以覆盖到圆3，即本类、同包子类、同包其他类都可以访问，简单说就是与本类同包的所有类都可以访问；
  • protected可以覆盖到圆4，即本类、同包子类、同包其他类、其他包中的子类都可以访问，简单说就是与本类同包的类及其他包中的子类都可以访问；
  • public可以覆盖到圆5，即本类、同包子类、同包其他类、其他包子类、其他包其他类都可以访问，简单说就是所有类都可以访问；

注：在与父类不同包的子类中，如果通过子类对象访问和调用父类中由protected修饰的变量和方法，确实可以；但如果通过父类的对象访问和调用的话，则不可以访问protected修饰的变量和方法，具体见下文的(6)和(7)。具体原因还未了解。

2.下面以简单的程序验证上述结论。

前提：

  • 包human中定义了类Person，Student，DustMan；其中，Student是Person的子类，DustMan不是Person的子类。
  • 包teacher中定义了类Teacher，GateMan；其中，Teacher是Person的子类，GateMan不是Person的子类。
  • Person中定义了四个成员变量和四个成员方法，分别以public，protected，缺省，private修饰，详见下面代码：
  1.         String name;
  2. 	public String education;
  3. 	private String hobby;
  4. 	protected String residence;
  5.  
  6. 	public void testModifierPublic() {
  7. 		System.out.println("Public");
  8. 	}
  9.  
  10. 	protected void testModifierProtected() {
  11. 		System.out.println("Protected");
  12. 	}
  13.  
  14. 	void testModifierDefault() {
  15. 		System.out.println("Default");
  16. 	}
  17.  
  18. 	private void testModifierPrivate() {
  19. 		System.out.println("Private");
  20. 	}

　　

(1),在Person类中定义Person类对象pOwn，分别访问和调用这些成员变量和成员方法，详见下面的代码：

  1. 	public static void main(String[] args) {
  2. 		Person pOwn = new Person("xi",20,"female","bachelor","recite","NJ");
  3.  
  4. 		System.out.println("public education: " + pOwn.education);
  5. 		System.out.println("protected residence: " + pOwn.residence);
  6. 		System.out.println("default name: " + pOwn.name);
  7. 		System.out.println("private hobby: "+ pOwn.hobby);
  8. 		pOwn.testModifierPublic();
  9. 		pOwn.testModifierProtected();
  10. 		pOwn.testModifierDefault();
  11. 		pOwn.testModifierPrivate();
  12. 	}

输出结果为：

  1. public education: bachelor
  2. protected residence: NJ
  3. default name: xi
  4. private hobby: recite
  5. Public
  6. Protected
  7. Default
  8. Private

结果分析：Person类对象可以在本类中访问和调用由public、protected、default、private修饰的成员变量和成员方法。

(2).在Student类中分别定义Student类对象sSamePackChild和Person类对象pSamePackChild，并分别访问和调用这些成员变量和成员方法，详见下面的代码：

  1. 	public static void main(String[] args) {
  2. 		Student sSamePackChild = new Student("xi",20,"female","bachelor","recite","NJ");
  3. 		Person pSamePackChild = new Person("xi",20,"female","bachelor","recite","NJ");
  4.  
  5. 		System.out.println("public education: " + sSamePackChild.education);
  6. 		System.out.println("protected residence: " + sSamePackChild.residence);
  7. 		System.out.println("default name: " + sSamePackChild.name);
  8. 		System.out.println("private hobby: "+ sSamePackChild.hobby);
  9. 		sSamePackChild.testModifierPublic();
  10. 		sSamePackChild.testModifierProtected();
  11. 		sSamePackChild.testModifierDefault();
  12. 		sSamePackChild.testModifierPrivate();
  13.  
  14. 		System.out.println("public education: " + pSamePackChild.education);
  15. 		System.out.println("protected residence: " + pSamePackChild.residence);
  16. 		System.out.println("default name: " + pSamePackChild.name);
  17. 		System.out.println("private hobby: "+ pSamePackChild.hobby);
  18. 		pSamePackChild.testModifierPublic();
  19. 		pSamePackChild.testModifierProtected();
  20. 		pSamePackChild.testModifierDefault();
  21. 		pSamePackChild.testModifierPrivate();
  22. 	}

输出结果为：

  1.         Exception in thread "main" java.lang.Error: Unresolved compilation problems:
  2. 	The field Person.hobby is not visible
  3. 	The method testModifierPrivate() from the type Person is not visible
  4. 	The field Person.hobby is not visible
  5. 	The method testModifierPrivate() from the type Person is not visible
  6.  
  7. 	at human.Student.main(Student.java:108)

结果分析：出现编译错误，提示private修饰的hobby和testModifierPrivate()不可见。

(3).根据(2)提示的错误，注释掉相关的行，再次执行，详见代码：

  1. 	public static void main(String[] args) {
  2. 		Student sSamePackChild = new Student("xi",20,"female","bachelor","recite","NJ");
  3. 		Person pSamePackChild = new Person("xi",20,"female","bachelor","recite","NJ");
  4.  
  5. 		System.out.println("public education: " + sSamePackChild.education);
  6. 		System.out.println("protected residence: " + sSamePackChild.residence);
  7. 		System.out.println("default name: " + sSamePackChild.name);
  8. //		System.out.println("private hobby: "+ sSamePackChild.hobby);
  9. 		sSamePackChild.testModifierPublic();
  10. 		sSamePackChild.testModifierProtected();
  11. 		sSamePackChild.testModifierDefault();
  12. //		sSamePackChild.testModifierPrivate();
  13.  
  14. 		System.out.println("public education: " + pSamePackChild.education);
  15. 		System.out.println("protected residence: " + pSamePackChild.residence);
  16. 		System.out.println("default name: " + pSamePackChild.name);
  17. //		System.out.println("private hobby: "+ pSamePackChild.hobby);
  18. 		pSamePackChild.testModifierPublic();
  19. 		pSamePackChild.testModifierProtected();
  20. 		pSamePackChild.testModifierDefault();
  21. //		pSamePackChild.testModifierPrivate();
  22. 	}

输出结果为：

  1. public education: bachelor
  2. protected residence: NJ
  3. default name: xi
  4. Public
  5. Protected
  6. Default
  7. public education: bachelor
  8. protected residence: NJ
  9. default name: xi
  10. Public
  11. Protected
  12. Default

结果分析：

注释掉private修饰的行后，成功执行；

Person类对象可以在与父类同包的子类Student中访问和调用由public、protected、default修饰的成员变量和成员方法，不能访问由private修饰的变量和方法；

在子类中定义的Student类对象也拥有同样的访问权限。

(4).在DustMan类中定义Person类对象pSamePackNonChild，分别访问和调用这些成员变量和成员方法，详见下面的代码：

  1. package human;
  2.  
  3. public class DustMan {
  4. 	public static void main(String[] args) {
  5. 		Person pSamePackNonChild = new Person("xi",20,"female","bachelor","recite","NJ");
  6.  
  7. 		System.out.println("public education: " + pSamePackNonChild.education);
  8. 		System.out.println("protected residence: " + pSamePackNonChild.residence);
  9. 		System.out.println("default name: " + pSamePackNonChild.name);
  10. 		System.out.println("private hobby: "+ pSamePackNonChild.hobby);
  11. 		pSamePackNonChild.testModifierPublic();
  12. 		pSamePackNonChild.testModifierProtected();
  13. 		pSamePackNonChild.testModifierDefault();
  14. 		pSamePackNonChild.testModifierPrivate();
  15. 	}
  16. }

输出结果为：

  1.         Exception in thread "main" java.lang.Error: Unresolved compilation problems:
  2. 	The field Person.hobby is not visible
  3. 	The method testModifierPrivate() from the type Person is not visible
  4.  
  5. 	at human.DustMan.main(DustMan.java:19)

结果分析：出现编译错误，提示private修饰的hobby和testModifierPrivate()不可见。

(5).根据(4)提示的错误，注释掉相关的行，再次执行，详见代码：

  1. package human;
  2.  
  3. public class DustMan {
  4. 	public static void main(String[] args) {
  5. 		Person pSamePackNonChild = new Person("xi",20,"female","bachelor","recite","NJ");
  6.  
  7. 		System.out.println("public education: " + pSamePackNonChild.education);
  8. 		System.out.println("protected residence: " + pSamePackNonChild.residence);
  9. 		System.out.println("default name: " + pSamePackNonChild.name);
  10. //		System.out.println("private hobby: "+ pSamePackNonChild.hobby);
  11. 		pSamePackNonChild.testModifierPublic();
  12. 		pSamePackNonChild.testModifierProtected();
  13. 		pSamePackNonChild.testModifierDefault();
  14. //		pSamePackNonChild.testModifierPrivate();
  15. 	}
  16. }

输出结果为：

  1. public education: bachelor
  2. protected residence: NJ
  3. default name: xi
  4. Public
  5. Protected
  6. Default

结果分析：

注释掉private修饰的行后，成功执行；

Person类对象可以在与Person同包的非子类中访问和调用由public、protected、default修饰的成员变量和成员方法，不能访问由private修饰的变量和方法。

(6).在Teacher类中定义Teacher类对象tDiffPackChild和Person类对象pDiffPackChild，并分别访问和调用这些成员变量和成员方法，详见下面的代码：

  1. package teacher;
  2. import human.Person;
  3.  
  4. public class Teacher extends human.Person {
  5. 	String duty;
  6.  
  7. 	public Teacher() {
  8.  
  9. 	}
  10.  
  11. 	public Teacher(String d) {
  12. 		super();
  13. 		this.duty = d;
  14. 	}
  15.  
  16. 	public Teacher(String n, int a, String g, String e, String h, String r) {
  17. 		super(n,a,g,e,h,r);
  18. 	}
  19.  
  20. 	public static void main(String[] args) {
  21. 		Teacher tDiffPackChild = new Teacher("xi",20,"female","bachelor","recite","NJ");
  22. 		Person pDiffPackChild = new Person("xi",20,"female","bachelor","recite","NJ");
  23.  
  24. 		System.out.println("public education: " + tDiffPackChild.education);
  25. 		System.out.println("protected residence: " + tDiffPackChild.residence);
  26. 		System.out.println("default name: " + tDiffPackChild.name);
  27. 		System.out.println("private hobby: "+ tDiffPackChild.hobby);
  28. 		tDiffPackChild.testModifierPublic();
  29. 		tDiffPackChild.testModifierProtected();
  30. 		tDiffPackChild.testModifierDefault();
  31. 		tDiffPackChild.testModifierPrivate();
  32.  
  33. 		System.out.println("public education: " + pDiffPackChild.education);
  34. 		System.out.println("protected residence: " + pDiffPackChild.residence);
  35. 		System.out.println("default name: " + pDiffPackChild.name);
  36. 		System.out.println("private hobby: "+ pDiffPackChild.hobby);
  37. 		pDiffPackChild.testModifierPublic();
  38. 		pDiffPackChild.testModifierProtected();
  39. 		pDiffPackChild.testModifierDefault();
  40. 		pDiffPackChild.testModifierPrivate();
  41. 	}
  42. }

输出结果为：

  1.         Exception in thread "main" java.lang.Error: Unresolved compilation problems:
  2. 	The field Person.name is not visible
  3. 	The field Person.hobby is not visible
  4. 	The method testModifierDefault() from the type Person is not visible
  5. 	The method testModifierPrivate() from the type Person is not visible
  6. 	The field Person.residence is not visible
  7. 	The field Person.name is not visible
  8. 	The field Person.hobby is not visible
  9. 	The method testModifierProtected() from the type Person is not visible
  10. 	The method testModifierDefault() from the type Person is not visible
  11. 	The method testModifierPrivate() from the type Person is not visible
  12.  
  13. 	at teacher.Teacher.main(Teacher.java:39)

结果分析：

出现编译错误，对于定义的Teacher类对象tDiffPackChild而言，对其的变量访问和方法调用提示，default修饰的name和testModifierDefault()、private修饰的hobby和testModifierPrivate()不可见；

对于定义的Person类对象pDiffPackChild而言，对其的变量访问和方法调用提示，protected修饰的residence和testModifierProtected()、default修饰的name和testModifierDefault()、private修饰的hobby和testModifierPrivate()不可见。

(7).根据(6)提示的错误，注释掉相关的行，再次执行，详见代码：

  1. package teacher;
  2. import human.Person;
  3.  
  4. public class Teacher extends human.Person {
  5. 	String duty;
  6.  
  7. 	public Teacher() {
  8.  
  9. 	}
  10.  
  11. 	public Teacher(String d) {
  12. 		super();
  13. 		this.duty = d;
  14. 	}
  15.  
  16. 	public Teacher(String n, int a, String g, String e, String h, String r) {
  17. 		super(n,a,g,e,h,r);
  18. 	}
  19.  
  20. 	public static void main(String[] args) {
  21. 		Teacher tDiffPackChild = new Teacher("xi",20,"female","bachelor","recite","NJ");
  22. 		Person pDiffPackChild = new Person("xi",20,"female","bachelor","recite","NJ");
  23.  
  24. 		System.out.println("public education: " + tDiffPackChild.education);
  25. 		System.out.println("protected residence: " + tDiffPackChild.residence);
  26. //		System.out.println("default name: " + tDiffPackChild.name);
  27. //		System.out.println("private hobby: "+ tDiffPackChild.hobby);
  28. 		tDiffPackChild.testModifierPublic();
  29. 		tDiffPackChild.testModifierProtected();
  30. //		tDiffPackChild.testModifierDefault();
  31. //		tDiffPackChild.testModifierPrivate();
  32.  
  33. 		System.out.println("public education: " + pDiffPackChild.education);
  34. //		System.out.println("protected residence: " + pDiffPackChild.residence);
  35. //		System.out.println("default name: " + pDiffPackChild.name);
  36. //		System.out.println("private hobby: "+ pDiffPackChild.hobby);
  37. 		pDiffPackChild.testModifierPublic();
  38. //		pDiffPackChild.testModifierProtected();
  39. //		pDiffPackChild.testModifierDefault();
  40. //		pDiffPackChild.testModifierPrivate();
  41. 	}
  42. }

输出结果为：

  1. public education: bachelor
  2. protected residence: NJ
  3. Public
  4. Protected
  5. public education: bachelor
  6. Public

结果分析：

注释掉相关的行后，成功执行；

如果在与Person不同包的子类Teacher中定义了Teacher类对象，则通过该对象可以访问和调用Person中public和protected修饰的成员变量和成员方法，default、private修饰的成员变量和成员方法都不可以访问或调用；

如果定义了Person类对象，则通过该对象只可以访问和调用Person中public修饰的成员变量和成员方法，protected、default、private修饰的成员变量和成员方法都不可以访问或调用。

疑问：不明白为什么会有这样的差异。

(8).在GateMan类中定义定义Person类对象pDiffPackNonChild，分别访问和调用这些成员变量和成员方法，详见下面的代码：

  1. package teacher;
  2.  
  3. import human.Person;
  4.  
  5. public final class GateMan {
  6. 	int gateNumber;
  7.  
  8. 	public GateMan() {
  9.  
  10. 	}
  11.  
  12. 	public GateMan(int g) {
  13. 		this.gateNumber = g;
  14. 	}
  15.  
  16. 	public static void main(String[] args) {
  17. 		Person pDiffPackNonChild = new Person("xi",20,"female","bachelor","recite","NJ");
  18.  
  19. 		System.out.println("public education: " + pDiffPackNonChild.education);
  20. 		System.out.println("protected residence: " + pDiffPackNonChild.residence);
  21. 		System.out.println("default name: " + pDiffPackNonChild.name);
  22. 		System.out.println("private hobby: "+ pDiffPackNonChild.hobby);
  23. 		pDiffPackNonChild.testModifierPublic();
  24. 		pDiffPackNonChild.testModifierProtected();
  25. 		pDiffPackNonChild.testModifierDefault();
  26. 		pDiffPackNonChild.testModifierPrivate();
  27. 	}
  28. }

输出结果为：

  1.         Exception in thread "main" java.lang.Error: Unresolved compilation problems:
  2. 	The field Person.residence is not visible
  3. 	The field Person.name is not visible
  4. 	The field Person.hobby is not visible
  5. 	The method testModifierProtected() from the type Person is not visible
  6. 	The method testModifierDefault() from the type Person is not visible
  7. 	The method testModifierPrivate() from the type Person is not visible
  8.  
  9. 	at teacher.GateMan.main(GateMan.java:29)

结果分析：出现编译错误，提示protected修饰的residence和testModifierProtected()、default修饰的name和testModifierDefault()、private修饰的hobby和testModifierPrivate()不可见。

(9).根据(8)提示的错误，注释掉相关的行，再次执行，详见代码：

  1. package teacher;
  2.  
  3. import human.Person;
  4.  
  5. public final class GateMan {
  6. 	int gateNumber;
  7.  
  8. 	public GateMan() {
  9.  
  10. 	}
  11.  
  12. 	public GateMan(int g) {
  13. 		this.gateNumber = g;
  14. 	}
  15.  
  16. 	public static void main(String[] args) {
  17. 		Person pDiffPackNonChild = new Person("xi",20,"female","bachelor","recite","NJ");
  18.  
  19. 		System.out.println("public education: " + pDiffPackNonChild.education);
  20. //		System.out.println("protected residence: " + pDiffPackNonChild.residence);
  21. //		System.out.println("default name: " + pDiffPackNonChild.name);
  22. //		System.out.println("private hobby: "+ pDiffPackNonChild.hobby);
  23. 		pDiffPackNonChild.testModifierPublic();
  24. //		pDiffPackNonChild.testModifierProtected();
  25. //		pDiffPackNonChild.testModifierDefault();
  26. //		pDiffPackNonChild.testModifierPrivate();
  27. 	}
  28. }

输出结果为：

  1. public education: bachelor
  2. Public

结果分析：

注释掉protected、default、private修饰的行后，成功执行；

Person类对象可以在与Person不同包的非子类中访问和调用由public修饰的成员变量和成员方法，不能访问由protected、default、private修饰的变量和方法。

(10).把Person类定义为缺省访问权限修饰的类，即class Person{,,,,}。在teacher包里的Teacher类和GateMan类都出现编译错误，如下所示：

  1.         Exception in thread "main" java.lang.IllegalAccessError: class teacher.Teacher cannot access its superclass human.Person
  2. 	at java.lang.ClassLoader.defineClass1(Native Method)
  3. 	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
  4. 	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
  5. 	at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
  6. 	at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
  7. 	at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
  8. 	at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
  9. 	at java.security.AccessController.doPrivileged(Native Method)
  10. 	at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
  11. 	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
  12. 	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)
  13. 	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
  14. 	at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)

结果分析：说明缺省访问权限修饰符的类只能由本包中的类访问，其他包中的类都不可以访问。

Java学习笔记10---访问权限修饰符如何控制成员变量、成员方法及类的访问范围的更多相关文章

  1. 包和访问权限修饰符，.单例设计模式，.Object类常用方法，.内部类

    1.包和访问权限修饰符 1.1 包 为什么要导包? 将字节码文件(.class)文件进行分类存放 --->包 其实就是文件夹 import java.util.Arrays; 包的划分规则 方案 ...

  2. 【java学习笔记2】访问控制修饰符 public、protected、默认、private

    先写了一个User()类: package chapter01; public class User { // 私有的 private int id; // 受保护的 protected int ag ...

  3. Java中的四种权限修饰符及六种非访问修饰符（简识）

    一.是哪四种访问权限修饰符呢? public > protected > [default] > private (公共的 ) (受保护的) (默认的) (私有的) 二.简单认识四种 ...

  4. java访问权限修饰符

    作用域 当前类 同一package 子孙类 其他package public √ √ √ √ protected √ √ √ × friendly √ √ × × private √ × × × ja ...

  5. Java访问权限修饰符public protected friendly private用法总结（转载好文Mark）

    首先声明:Java中,friendly这个修饰符并没有显式的声明,在成员变量和方法前什么修饰符也不用,默认的就是friendly.为了条理清晰,分三种不同情况来总结. 一 访问权限修饰符修饰成员变量和 ...

  6. Java 访问权限修饰符以及protected修饰符的理解

    2017-11-04 22:28:39 访问权限修饰符的权限 访问修饰符protected的权限理解 在Core Java中有这样一段话“在Object类中,clone方法被声明为protected, ...

  7. java四种访问权限修饰符

    java中四个访问权限修饰符: public(公开的).protected(受保护的).default(默认的).private(私有的). 它们决定了紧跟其后被定义的东西的使用范围. 适用范围< ...

  8. Java语言中的访问权限修饰符

    一个Java应用有很多类,但是有些类,并不希望被其他类使用.每个类中都有数据成员和方法成员,但是并不是每个数据和方法,都允许在其他类中调用.如何能做到访问控制呢?就需要使用访问权限修饰符. Java语 ...

  9. Java的访问权限修饰符

    default或者friendly表示默认的访问权限修饰符.

随机推荐

  1. 错误代码： 1054 Unknown column &#39;t.createUsrId&#39; in &#39;group statement&#39;

    1.错误描写叙述 1 queries executed, 0 success, 1 errors, 0 warnings 查询:select count(t.id),t.`createUserId` ...

  2. OSChinaclient源代码学习（1）--Android与Server的交互

    这里主要针对"综合"这个选项卡下的"资讯"模块为样例.对核心代码进行解读. 准备工作:參考我的另外一篇博客 http://blog.csdn.net/csp27 ...

  3. hibernate5(9)注解映射[1]多对一单向关联

    在博客站点中,我们可能须要从某一篇文章找到其所关联的作者.这就须要从文章方建立起对用户的关联,即是多对一的映射关系. 如今先看一个配置实例:我们的文章实体类 package com.zeng.mode ...

  4. 【cogs 597】【dp】交错匹配

    597. 交错匹配 ★☆ 输入文件:crossa.in 输出文件:crossa.out 简单对照 时间限制:1 s 内存限制:128 MB [问题描写叙述] 有两行自然数. UP[1..N] . DO ...

  5. ASP.NET Core 使用 Redis 客户端

    Mac OS 安装 Redis(用于连 Redis 服务器,方便查看数据):https://redis.io/topics/quickstart wget http://download.redis. ...

  6. make工程管理器

    1.概述 大型程序中,人们希望工具自动识别修改的文件,而且不需要输入冗长的命令,就可以进行编译链接等操作,于是make工程管理器应运而生. make可以自动识别文件时间戳,只处理修改的文件: make ...

  7. 转：Natas Wargame Level28 Writeup(EBC加密破解)

    From:http://alkalinesecurity.com/blog/ctf-writeups/natas-28-getting-it-wrong/ Now that I knew it was ...

  8. 2.python数据类型

    1 Number(数字) 2   字符串类型(string)   字符串内置方法 # string.capitalize() 把字符串的第一个字符大写 # string.center(width) 返 ...

  9. Eclipse多行同时进行编辑，可编辑或修改相同内容

    使用Shift+Alt+A可以进入Eclipse多行编辑的功能,选中的一部分区域从光标开始处同时进行修改或者插入功能. 再次按下Shift+Alt+A可已退出该编辑模式.

  10. Java I/O---添加属性和有用的接口—FilterlnputStream&FilterOutputStream

    0.装饰器模式 Java I/O类库需要多种不同功能的组合,这正是使用装饰器模式的理由所在.这也是Java I/O类库里存在filter(过滤器)类的原因所在,抽象类filter是所有装饰器类的基类. ...