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();
    }
}