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

 package lab5_2_a;

 public class Parent {
     private int f1 = 11;
     int f2 = 12;
     protected int f3 = 13;
     public int f4 = 14;
     private void fm1() {
         System.out.println("in fm1()");
     }
     void fm2() {
         System.out.println("in fm2()");
     }
     protected void fm3() {
         System.out.println("in fm3()");
     }
     public void fm4() {
         System.out.println("in fm4()");
     }

     public static void main(String[] args){
         /*当类的字节码被加载到内存，
          * 类中类变量、类方法即被分配了相应内存空间、入口地址（所有对象共享）。
          */
         //在同一类中，类中的实例方法总是可以操作该类中的实例变量和类变量；类方法总是可以操作该类中的类变量。
         Parent p = new Parent();
         /*Parent类创建对象，类中实例变量被分配内存（不同对象的实例变量互不相同，即分配了不同的内存空间）；
          * 类中实例方法被分配入口地址
          * （创建第一个对象时分配；方法的入口地址被所有的对象共享；所有对象都不存在时，方法的入口地址才被取消）。
          */

         p.fm1();
         p.fm2();
         p.fm3();
         p.fm4();
     }
 }

 package lab5_2_a;

 public class Child extends Parent {
     private void cm1() {
         System.out.println("in cm1()");
     }
     void cm2() {
         System.out.println("in cm2()");
     }
     protected void cm3() {
         System.out.println("in cm3()");
     }
     public void cm4() {
         System.out.println("in cm4()");
     }

     public static void main(String[] args){
         Child c = new Child();
         c.cm1();
         c.cm2();
         c.cm3();
         c.cm4();
         //继承：子类与父类在同一包中，子类继承父类中不是private的成员变量与方法
         //c.fm1();
         c.fm2();
         c.fm3();
         c.fm4();
     }
 }

package lab5_2_a;

public class Inherit {
    public static void main(String[] args){
        Parent p = new Parent();
        /* 访问权限(在同一包中)：
         *  可以在任何另外一个类中使用public类与友好类创建对象;
         *  创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。
         */
        //p.fm1();
        p.fm2();
        p.fm3();
        p.fm4();

        Child c = new Child();
        /* 访问权限(在同一包中)：
         *  可以在任何另外一个类中使用public类与友好类创建对象;
         *  创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。
         */
        //c.cm1();
        c.cm2();
        c.cm3();
        c.cm4();
        //c.fm1();
        c.fm2();
        c.fm3();
        c.fm4();
    }
}

 package lab5_2_b;

 import lab5_2_a.Child;

 public class GrandChild extends Child {
     public static void main(String[] args){
         GrandChild g = new GrandChild();
         //继承：子类与父类不在同一包中时，子类只继承父类中的protected和public访问权限的成员变量与方法
         //g.cm1();
         //g.cm2();
         g.cm3();
         g.cm4();
         //继承：子类与父类不在同一包中时，子类只继承父类中的protected和public访问权限的成员变量与方法
         //g.fm1();
         //g.fm2();
         g.fm3();
         g.fm4();
     }
 }

 package lab5_2_b;

 public class GreatGrandChild extends GrandChild {
     public static void main(String[] args){
         GreatGrandChild g = new GreatGrandChild();
         //继承：子类与父类在同一包中，子类继承父类中不是private的成员变量与方法
         //g.cm1();
         //g.cm2();
         g.cm3();
         g.cm4();
         //继承：子类与父类在同一包中，子类继承父类中不是private的成员变量与方法
         //g.fm1();
         //g.fm2();
         g.fm3();
         g.fm4();
     }
 }

 package lab5_2_b;

 import lab5_2_a.*;

 public class Inherit {
     public static void main(String[] args){
         Parent p = new Parent();
         /* 访问权限(不在同一包中)：import语句
          *  可以在任何另外一个类中使用public类创建对象;
          *  创建的对象能够通过“.”运算符操作自己类中public的成员变量与方法。
          */
         //p.fm1();
         //p.fm2();
         //p.fm3();
         p.fm4();

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

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

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

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

         g.cm4();
         //g.fm1();
         //g.fm2();

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

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

         g.fm4();
     }
 }