权限修饰符的访问范围

权限修饰符的访问范围 下面我们进行测试：

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类的构造器可以是如下所示：

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("默认构造器");
    }
}

（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）{}）