访问限定修饰符 private、protected、public和默认的作用范围对比

目录

一、简介

 二、代码证明访问限定修饰符作用范围

 1、同包同类

 2、同包不同类

 3、不同包子类

 4、不同包非子类

三、总结访问限定修饰符的作用范围

---

一、简介

default：默认情况，class 不加任何修饰符，又称 No Modifier ；

private：私有的，修饰 class ，主要作用于封装；

protected：受保护的，修饰 class ，主要作用于继承；

public：公用的，修饰 class ，主要作用于封装；

 二、代码证明访问限定修饰符作用范围

 1、同包同类

//只有<Code1>包和<Modifier>类；满足同包同类的作用范围；

<package Code1;>
public class Modifier {
    //default
    int defNum;
    void defMet(){
        System.out.println("def:" + this.defNum + " > default可以进行同包同类访问；");
    }

    //private
    private int priNum;
    private void priMet(){
        System.out.println("pri:" + this.priNum + " > private可以进行同包同类访问；");
    }

    //protected
    protected int proNum;
    protected void proMet() {
        System.out.println("pro:" + this.proNum + " > protected可以进行同包同类访问；");
    }

    //public
    public int pubNum;
    public void pubMet() {
        System.out.println("pub:" + this.pubNum + " > public可以进行同包同类访问；");
    }

    public static void main(String[] args) {

        //default；
        Modifier def = new Modifier();
        def.defNum = 1;
        def.defMet(); //输出：def:1 > default可以进行同包同类访问；

        //private；
        Modifier pri = new Modifier();
        pri.priNum = 2;
        pri.priMet(); //输出：pri:2 > private可以进行同包同类访问；

        //protected;
        Modifier pro = new Modifier();
        pro.proNum = 3;
        pro.proMet(); //输出：pro:3 > protected可以进行同包同类访问；

        //public;
        Modifier pub = new Modifier();
        pub.pubNum = 4;
        pub.pubMet(); //输出：pub:4 > public可以进行同包同类访问；
    }
}

//输出结果：

def:1 > default可以进行同包同类访问；

pri:2 > private可以进行同包同类访问；

pro:3 > protected可以进行同包同类访问；

pub:4 > public可以进行同包同类访问；

 小结：在同包同类访问中， private、default、protected、public全部都是可行的；

 2、同包不同类

//只有<Code1>包；有<Modifier>和<TestMain>两个类；满足同包不同类的作用范围；

<package Code1;> 
class Modifier {
    //default
    int defNum;
    void defMet(){
        System.out.println("def:" + this.defNum + " > default可以进行同包不同类访问；");
    }

    //private
    private int priNum;
    private void priMet(){
        System.out.println("pri:" + this.priNum + " > private可以进行同包不同类访问；");
    }

    //protected
    protected int proNum;
    protected void proMet() {
        System.out.println("pro:" + this.proNum + " > protected可以进行同包不同类访问；");
    }

    //public
    public int pubNum;
    public void pubMet() {
        System.out.println("pub:" + this.pubNum + " > public可以进行同包不同类访问；");
    }
}

public class TestMain {
    public static void main(String[] args) {

        //default；
        Modifier def = new Modifier();
        def.defNum = 1;
        def.defMet(); //输出：def:1 > default可以进行同包不同类访问；

        //private；
        Modifier pri = new Modifier();
        //pri.priNum = 2; //报错；
        //pri.priMet(); //报错；

        //protected;
        Modifier pro = new Modifier();
        pro.proNum = 3;
        pro.proMet(); //输出：pro:3 > protected可以进行同包不同类访问；

        //public;
        Modifier pub = new Modifier();
        pub.pubNum = 4;
        pub.pubMet(); //输出：pub:4 > public可以进行同包不同类访问；
    }
}

//输出结果：

def:1 > default可以进行同包不同类访问；

pro:3 > protected可以进行同包不同类访问；

pub:4 > public可以进行同包不同类访问；

 小结：在同包不同类访问中，只有private是不可行的；default、protected、public是可行的；

 3、不同包子类

//在<Code1>包中设<Superclass>父类，在<Code2>包中设<Subclass>子类；满足不同包子类的作用范围；
//<Code3>包中<TestMain>类只用于测试结果；

<package Code1;>
public class Superclass {
    //default
    int defNum = 1;

    //private
    private int priNum = 2;

    //protected
    protected int proNum = 3;

    //public
    public int pubNum = 4;
}
<package Code2;>
<import Code1.Superclass;>
public class Subclass extends Superclass {
    public void method() {
        //default
        //System.out.println("def:" + super.defNum + " > default可以进行不同包子类访问；"); //报错；

        //private
        //System.out.println("pri:" + super.priNum + " > private可以进行不同包子类访问；"); //报错；

        //protected
        System.out.println("pro:" + super.proNum + " > protected可以进行不同包子类访问；");

        //public
        System.out.println("pub:" + super.pubNum + " > public可以进行不同包子类访问；");
    }
}
<package Code3;>
<import Code2.Subclass;>
public class TestMain {
    public static void main(String[] args) {
        Subclass sub = new Subclass();
        sub.method();
    }
}

//执行结果：

pro:3 > protected可以进行不同包子类访问；

pub:4 > public可以进行不同包子类访问；

 小结：在不同包的子类访问中，default、private是不可行的；protected、public是可行的；

 4、不同包非子类

//在<Code1>包设<Modifier>类(非子类)；在<Code2>包设<TestMain>类用于测试；满足不同包非子类作用范围；

< package Code1; >
public class Modifier {
    //default
    int defNum;
    void defMet(){
        System.out.println("def:" + this.defNum + " > default可以进行不同包非子类访问；");
    }

    //private
    private int priNum;
    private void priMet(){
        System.out.println("pri:" + this.priNum + " > private可以进行不同包非子类访问；");
    }

    //protected
    protected int proNum;
    protected void proMet() {
        System.out.println("pro:" + this.proNum + " > protected可以进行不同包非子类访问；");
    }

    //public
    public int pubNum; 
    public void pubMet() {
        System.out.println("pub:" + this.pubNum + " > public可以进行不同包非子类访问；");
    }
}
< package Code2; >
< import Code1.Modifier; >
public class TestMain {
    public static void main(String[] args) {

        //default；
        Modifier def = new Modifier();
        //def.defNum = 1; //报错；
        //def.defMet(); //报错；

        //private；
        Modifier pri = new Modifier();
        //pri.priNum = 2; //报错；
        //pri.priMet(); //报错；

        //protected;
        Modifier pro = new Modifier();
        //pro.proNum = 3; //报错；
        //pro.proMet(); //报错；

        //public;
        Modifier pub = new Modifier();
        pub.pubNum = 4;
        pub.pubMet(); //输出：pub:4 > public可以进行不同包非子类访问；

    }
}

//输出结果：

pub:4 > public可以进行不同包非子类访问；

 小结：在不同包的非子类访问中，default、private、protected是不可行的；只有public是可行的；

三、总结访问限定修饰符的作用范围

访问限定修饰符作用范围表

作用范围	private	default	protected	public
1、同包同类	✔	✔	✔	✔
2、同包不同类		✔	✔	✔
3、不同包子类			✔	✔
4、不同包非子类				✔

（ 哈哈哈~~ 文章结束！） 

（ 看到这里，如果有为各位帅哥美女提供一点点灵感，请点一个小小的赞哦，比心💖💖💖 ）