Java中的权限修饰符的访问范围详解一、修饰类二、修饰成员三、修饰构造器

68 阅读 0 评论 45 点赞

我是靠谱客的博主悦耳月亮，最近开发中收集的这篇文章主要介绍Java中的权限修饰符的访问范围详解一、修饰类二、修饰成员三、修饰构造器，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Java中共有四个权限修饰符，分别是private, default（表示不写）, protected, public，访问权限范围由小到大。下面我们分别介绍权限修饰符修饰类、修饰成员修饰构造器的情况。

一、修饰类

修饰类只有两个权限修饰符：public和default

public:全局访问

default:表示不写修饰符的情况，只能在同包中访问

下面我们进行测试：

1.创建两个包，取名为com.syc.test和com.syc.input，然后在com.syc.test下创建Test类、Woman类，com.syc.input下创建People类

2.编写代码。people.java文件的内容如下：

package com.syc.input;

public class People {
}
class Man{
    
}

Test类的内容如下：

package com.syc.test;

import com.syc.input.People;

public class Test {
    public static void main(String[] args){
        new People();//跨包时需要导包
//        new Man();//错误，表示default修饰的类不能跨包访问
        new Woman();

    }
}

Woman类的内容如下：

package com.syc.test;

class Woman {
}

3.测试并总结：我们用Test类中的main方法进行测试，发现创建People对象是可以直接new出来的（Public全局访问），但是Man对象却无法创建，而Woman对象也是可以new出来（default只能在同包中访问）。

二、修饰成员

权限修饰符修饰成员的访问范围如下图所示：

我们按照权限由小到大的顺序来测试修饰符修饰成员的情况。

1.测试private

我们新创建一个项目，然后创建包com.syc.test，在其中新建一个类People

编写People的代码如下：

package com.syc.test;

public class People {
    //访问权限由小到大定义成员变量
    private int a = 10;
    int b = 20;
    protected int c = 30;
    public int d = 40;

    //访问权限由小到大定义成员方法
    private void fun1(){

    }

    void fun2(){

    }

    protected void fun3(){

    }

    public void fun4(){

    }

    public static void main(String[] args) {
        //本类当中访问成员变量和成员方法，先创建这个类的对象
        People p = new People();
        System.out.println(p.a);//私有的权限最低的都能访问，其他权限高的一定能访问
        p.fun1();
    }
}

可以看到在本类中，权限最小的都能访问到，其他三个就必定能够访问了。

2.测试default

我们继续在com.syc.test包中创建新的类Test，然后对成员变量进行测试，发现在使用p.只弹出了bcd，可见私有成员a无法脱离其所属类进行访问。

Test类的代码如下：

package com.syc.test;

public class Test {
    public static void main(String[] args) {
        People p = new People();
//        System.out.println(p.a);//提示错误，private修饰的成员不能在其类外访问到
        System.out.println(p.b);
        p.fun2();
    }
}

当我们跨包时，只能查看到public所修饰的成员（此时没有继承）：

3.测试protected

protected修饰的成员能在本类，同包，子类中被访问。

我们在com.syc.input中新建Student类，使这个类继承自People，然后我们可以看到能访问到父类的protected 成员c。

public就不用说了，全局能访问，如上上图（未继承时）能访问到public成员d。

三、修饰构造器

权限修饰符修饰构造器的访问范围与修饰成员时候访问范围相同。

1.测试private

和测试成员一样，我们新建一个项目，然后创建com.syc.test包，在其中添加People类，然后添加四个构造器（需要添加不同类型的参数来对构造器重载），并在本类中用main方法进行测试，发现四个构造器均能使用。

package com.syc.Test;

public class People {
    private People(){

    }

    People(int a){

    }

    protected People(char c){

    }

    public People(String s){

    }

    public static void main(String[] args) {
        new People();
        new People(1);
        new People('c');
        new People("syc");
    }
}

2.测试default

我们在com.syc.Test包下新建Test类，发现不能访问无参的私有构造器（private People(){}）。

3.测试protected

protected修饰构造器时访问范围同修饰成员相同，都是本类，同包和其子类，但不同的是子类继承父类，构造器不能被继承。

（1）同包下测试：

我们在com.syc.Test包下，新建Teacher类，继承自People类，如图所示，会提示错误：在com.syc.Test.People中没有默认的构造器，要我们创建构造器来匹配父类。为什么会有这个提示呢？因为在我们的父类People中“没有默认构造器”。（无参构造器被私有化，外部类无法访问，其他三个构造器又不能被子类继承）

解决方法有两个：

方法一：将无参构造器公有化，即将 private People(){ }这个构造器改为public People(){ }，此时我们在new Teacher()的时候，会先调用父类的无参构造器，然后调用子类的无参构造器。做如下修改：

People类

package com.syc.Test;

public class People {
    public People(){
        System.out.println("公有构造器");
    }

    People(int a){

    }
...

Teacher类

package com.syc.Test;

public class Teacher extends People {
    Teacher(){
        System.out.println("默认构造器");
    }
}

测试类中我们测试new Teacher();的结果如下：

说明：在调用子类的默认构造器的时候会先调用父类的默认构造器（没有用super关键字指定构造器情况），相当于在Teacher()构造器的第一行有一行隐形的super();语句。

方法二：不修改无参构造器的权限修饰符，我们创建子类的构造器，此时我们可以看到，能创建的构造器有三个。

此时，Teacher类的构造器可以是如下所示：

package com.syc.Test;

public class Teacher extends People {

    Teacher(int a) {
        super(a);
    }

    protected Teacher(char c) {
        super(c);
    }

    public Teacher(String s) {
        super(s);
    }
}

（2）跨包下测试：

若我们创建一个新包com.syc.input，并在其中创建Student类，使其继承People类，那么此时能创建的子类构造器只有两个（父类中用protected与public修饰的构造器）

这个Student类的构造器便是下面这样的：

package com.syc.input;

import com.syc.Test.People;

public class Student extends People {
    protected Student(char c) {
        super(c);
    }

    public Student(String s) {
        super(s);
    }
}

4.测试public

我们新建一个包com.syc.input，也创建一个类Test，此时在main方法中测试，发现只能访问public方法修饰的构造器（public People(String s）{}）