java 对象访问权限_Java 访问限制符 在同一包中或在不同包中：使用类创建对象的权限 & 对象访问成员变量与方法的权限 & 继承的权限 & 深入理解protected权限...

一、实例成员与类成员

1. 当类的字节码被加载到内存， 类中类变量、类方法即被分配了相应内存空间、入口地址(所有对象共享)。

2. 当该类创建对象后，类中实例变量被分配内存(不同对象的实例变量互不相同，即分配了不同的内存空间)；

类中实例方法被分配入口地址(创建第一个对象时分配；方法的入口地址被所有的对象共享；所有对象都不存在时，方法的入口地址才被取消)。

3. 在同一类中，类中的实例方法总是可以操作该类中的实例变量和类变量；类方法总是可以操作该类中的类变量。(与访问限制符没有关系)

二、使用类创建对象的权限 & 对象访问成员变量与方法的权限

1. 在同一包中：

可以在任何另外一个类中使用public类与友好类创建对象;

创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。

2. 不在同一包中：import语句

可以在任何另外一个类中使用public类创建对象;

创建的对象能够通过“.”运算符操作自己类中public的成员变量与方法。

三、继承的权限

1. 子类与父类在同一包中，子类继承父类中不是private的成员变量与方法。

2. 子类与父类不在同一包中时，子类只继承父类中的protected和public访问权限的成员变量与方法。

四、深入理解protected权限

*注意！！！

对于protected的成员变量与方法，

可以被同一包中的其它类(包括子类)访问，同时也能被不同包中的子类访问；

当不在同一个包，不存在继承时，对于其他包中的类而言是不能访问的。

* 总结：

1. 子类可以通过继承获得不同包父类的protected权限成员变量和成员方法，在子类中可以直接访问

2. 在子类中可以通过子类的对象访问父类的protected成员变量和方法

3. 在子类中反而不能通过父类的对象访问父类的protected成员变量和方法

4.在子类中不能通过其他子类的对象访问父类的protected成员变量和方法

5.在与子类同包的其他类中不能通过子类的对象访问父类的protected成员变量和方法

关于protected权限的子类访问方式

https://blog.csdn.net/blacktal/article/details/81198579

1 packagelab5_2_a;2

3 public classParent {4 private int f1 = 11;5 int f2 = 12;6 protected int f3 = 13;7 public int f4 = 14;8 private voidfm1() {9 System.out.println("in fm1()");10 }11 voidfm2() {12 System.out.println("in fm2()");13 }14 protected voidfm3() {15 System.out.println("in fm3()");16 }17 public voidfm4() {18 System.out.println("in fm4()");19 }20

21 public static voidmain(String[] args){22 /*当类的字节码被加载到内存，23 * 类中类变量、类方法即被分配了相应内存空间、入口地址(所有对象共享)。24 */

25 //在同一类中，类中的实例方法总是可以操作该类中的实例变量和类变量；类方法总是可以操作该类中的类变量。

26 Parent p = newParent();27 /*Parent类创建对象，类中实例变量被分配内存(不同对象的实例变量互不相同，即分配了不同的内存空间)；28 * 类中实例方法被分配入口地址29 * (创建第一个对象时分配；方法的入口地址被所有的对象共享；所有对象都不存在时，方法的入口地址才被取消)。30 */

31

32 p.fm1();33 p.fm2();34 p.fm3();35 p.fm4();36 }37 }

1 packagelab5_2_a;2

3 public class Child extendsParent {4 private voidcm1() {5 System.out.println("in cm1()");6 }7 voidcm2() {8 System.out.println("in cm2()");9 }10 protected voidcm3() {11 System.out.println("in cm3()");12 }13 public voidcm4() {14 System.out.println("in cm4()");15 }16

17 public static voidmain(String[] args){18 Child c = newChild();19 c.cm1();20 c.cm2();21 c.cm3();22 c.cm4();23 //继承：子类与父类在同一包中，子类继承父类中不是private的成员变量与方法24 //c.fm1();

25 c.fm2();26 c.fm3();27 c.fm4();28 }29 }

packagelab5_2_a;public classInherit {public static voidmain(String[] args){

Parent p= newParent();/*访问权限(在同一包中)：

* 可以在任何另外一个类中使用public类与友好类创建对象;

* 创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。*/

//p.fm1();

p.fm2();

p.fm3();

p.fm4();

Child c= newChild();/*访问权限(在同一包中)：

* 可以在任何另外一个类中使用public类与友好类创建对象;

* 创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。*/

//c.cm1();

c.cm2();

c.cm3();

c.cm4();//c.fm1();

c.fm2();

c.fm3();

c.fm4();

}

}

1 packagelab5_2_b;2

3 importlab5_2_a.Child;4

5 public class GrandChild extendsChild {6 public static voidmain(String[] args){7 GrandChild g = newGrandChild();8 //继承：子类与父类不在同一包中时，子类只继承父类中的protected和public访问权限的成员变量与方法9 //g.cm1();10 //g.cm2();

11 g.cm3();12 g.cm4();13 //继承：子类与父类不在同一包中时，子类只继承父类中的protected和public访问权限的成员变量与方法14 //g.fm1();15 //g.fm2();

16 g.fm3();17 g.fm4();18 }19 }

1 packagelab5_2_b;2

3 public class GreatGrandChild extendsGrandChild {4 public static voidmain(String[] args){5 GreatGrandChild g = newGreatGrandChild();6 //继承：子类与父类在同一包中，子类继承父类中不是private的成员变量与方法7 //g.cm1();8 //g.cm2();

9 g.cm3();10 g.cm4();11 //继承：子类与父类在同一包中，子类继承父类中不是private的成员变量与方法12 //g.fm1();13 //g.fm2();

14 g.fm3();15 g.fm4();16 }17 }

1 packagelab5_2_b;2

3 import lab5_2_a.*;4

5 public classInherit {6 public static voidmain(String[] args){7 Parent p = newParent();8 /*访问权限(不在同一包中)：import语句9 * 可以在任何另外一个类中使用public类创建对象;10 * 创建的对象能够通过“.”运算符操作自己类中public的成员变量与方法。11 */

12 //p.fm1();13 //p.fm2();14 //p.fm3();

15 p.fm4();16

17 Child c = newChild();18 /*访问权限(不在同一包中)：import语句19 * 可以在任何另外一个类中使用public类创建对象;20 * 创建的对象能够通过“.”运算符操作自己类中public的成员变量与方法。21 */

22 //c.cm1();23 //c.cm2();24 //c.cm3();

25 c.cm4();26 //c.fm1();27 //c.fm2();28 //c.fm3();

29 c.fm4();30

31 GrandChild g = newGrandChild();32 /*访问权限(在同一包中)：33 * 可以在任何另外一个类中使用public类与友好类创建对象;34 * 创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。35 */

36 //g.cm1();37 //g.cm2();38

39 //g.cm3();

40 /*注意！！！41 * 对于protected的成员变量与方法，42 可以被同一包中的其它类(包括子类)访问，同时也能被不同包中的子类访问；43 当不在同一个包，不存在继承时，对于其他包中的类而言是private(不能访问的)。44 * 总结：45 1. 子类可以通过继承获得不同包父类的protected权限成员变量和成员方法，在子类中可以直接访问46 2. 在子类中可以通过子类的对象访问父类的protected成员变量和方法47

48 3. 在子类中反而不能通过父类的对象访问父类的protected成员变量和方法49 4.在子类中不能通过其他子类的对象访问父类的protected成员变量和方法50 5.在与子类同包的其他类中不能通过子类的对象访问父类的protected成员变量和方法51 */

52

53 g.cm4();54 //g.fm1();55 //g.fm2();56

57 //g.fm3();

58 /*注意！！！对于protected的成员变量与方法，59 * 可以被同一包中的其它类(包括子类)访问，同时也能被不同包中的子类访问；60 * 当不在同一个包，不存在继承时，对于其他包中的类而言是private(不能访问的)61 * 总结：62 1. 子类可以通过继承获得不同包父类的protected权限成员变量和成员方法，在子类中可以直接访问63 2. 在子类中可以通过子类的对象访问父类的protected成员变量和方法64

65 3. 在子类中反而不能通过父类的对象访问父类的protected成员变量和方法66 4.在子类中不能通过其他子类的对象访问父类的protected成员变量和方法67 5.在与子类同包的其他类中不能通过子类的对象访问父类的protected成员变量和方法68 */

69

70 g.fm4();71 }72 }