【权限修饰符】public、protected、default、private修饰下的访问权限区别

	同一个类中	同一个包中	不同包，子类	不同包，非子类
public	√	√	√	√
protected	√	√	√
default	√	√
private	√

 

---

下面分别通过程序演示其区别：

1.同一个类下的比较

/*
测试同一个类中，不同修饰符的访问权限区别
 */

public class Test1 {

    public String publicField = "public字段能访问";
    protected String protectedField = "protected字段能访问";
    String defaultField = "default字段能访问";
    private String privateField = "private字段能访问";


    public void publicTest()
    {
        System.out.println("public方法能访问");
    }

    protected void protectedTest()
    {
        System.out.println("protected方法能访问");
    }

    void defaultTest()
    {
        System.out.println("default方法能访问");
    }

    private void privateTest()
    {
        System.out.println("private方法能访问");
    }

    public static void main(String[] args) {

        Test1 t1 = new Test1();
        t1.publicTest();
        t1.protectedTest();
        t1.defaultTest();
        t1.privateTest();
        System.out.println(t1.publicField+" "+t1.protectedField+" "+t1.defaultField+" "+t1.privateField);
    }
}

运行结果：

可以看出，在同一个类中，所有的权限修饰符修饰的方法和字段都能被访问。

---

2.同一个包，不同类中的比较：

/*
测试同一个包中，不同类下，不同修饰符的访问权限区别
 */

class Demo1{
    
    public String publicField = "public字段能访问";
    protected String protectedField = "protected字段能访问";
    String defaultField = "default字段能访问";
    private String privateField = "private字段能访问";


    public void publicTest()
    {
        System.out.println("public方法能访问");
    }

    protected void protectedTest()
    {
        System.out.println("protected方法能访问");
    }

    void defaultTest()
    {
        System.out.println("default方法能访问");
    }

    private void privateTest()
    {
        System.out.println("private方法能访问");
    }
    
}

public class Test1 {

    public static void main(String[] args) {

        Demo1 d1 = new Demo1();
        d1.publicTest();
        d1.protectedTest();
        d1.defaultTest();
        d1.privateTest();
        System.out.println(d1.publicField+" "+d1.protectedField+" "+d1.defaultField+" "+d1.privateField);
    }
}

运行结果：

可以看出，在同一个包下不同类间的访问，不能访问由private修饰的方法和字段。

---

3.不同包下，子类访问父类的比较：

package p01;
/*
测试不同包下，子类访问父类，不同修饰符的访问权限区别
 */

public class Demo2{//父类

    public String publicField = "public字段能访问";
    protected String protectedField = "protected字段能访问";
    String defaultField = "default字段能访问";
    private String privateField = "private字段能访问";


    public void publicTest()
    {
        System.out.println("public方法能访问");
    }

    protected void protectedTest()
    {
        System.out.println("protected方法能访问");
    }

    void defaultTest()
    {
        System.out.println("default方法能访问");
    }

    private void privateTest()
    {
        System.out.println("private方法能访问");
    }

}

package p02;
import p01.Demo2;


public class Test2 extends Demo2{//子类

    public static void main(String[] args) {

        Test2 t2 = new Test2();
        t2.publicTest();
        t2.protectedTest();
        t2.defaultTest();
        t2.privateTest();
        System.out.println(t2.publicField+" "+t2.protectedField+" "+t2.defaultField+" "+t2.privateField);
    }
}

运行结果：

可以看到，在不同包下，子类对父类的访问，只能访问由public和protected修饰的方法和字段

---

 4.不同包，非继承关系下的访问比较：

package p01;
/*
测试不同包下，非继承关系，不同修饰符的访问权限区别
 */

public class Demo3{

    public String publicField = "public字段能访问";
    protected String protectedField = "protected字段能访问";
    String defaultField = "default字段能访问";
    private String privateField = "private字段能访问";


    public void publicTest()
    {
        System.out.println("public方法能访问");
    }

    protected void protectedTest()
    {
        System.out.println("protected方法能访问");
    }

    void defaultTest()
    {
        System.out.println("default方法能访问");
    }

    private void privateTest()
    {
        System.out.println("private方法能访问");
    }

}

package p02;
import p01.Demo3;


public class Test3 {

    public static void main(String[] args) {

        Demo3 d3 = new Demo3();
        d3.publicTest();
        d3.protectedTest();
        d3.defaultTest();
        d3.privateTest();
        System.out.println(d3.publicField+" "+d3.protectedField+" "+d3.defaultField+" "+d3.privateField);
    }
}

运行结果：

可以看出，在不同包下，非继承关系的类间访问，只能访问public修饰的方法和字段，且需要创建其类的对象调用。