本文原创首发CSDN，本文链接https://blog.csdn.net/qq_41464123/article/details/107461710 ，作者博客https://blog.csdn.net/qq_41464123 ，转载请带上本链接，谢谢配合。
目录
零、前言
Java是一门当今最火的编程语言之一，拥有很多现成可用的库，在我们编程生涯中，有着无比重要的地位。
Java中有个概念叫做访问权限。它们是什么呢？今天我来详细讲解。
本文所有代码已经上传CSDN下载模块，下载地址，也可以在文章下方的评论区找我要，谢谢！
一、构造方法
1.1 简易版类的实例化
在内部类中，会涉及到访问权限的概念；而在访问权限中，会涉及到构造方法的概念，所以我们先来学习什么是构造方法。
我们先来编写一个最简单的类 —— 人，并且不用Java的封装。
public class People {
String name;
int age;
}人有两个属性，分别是名字name和年龄age。
接着编写一个主函数，实例化这个类，并且输出它的属性。
public class Main {
public static void main(String[] args) {
People people = new People();
people.name = "ZWZ";
people.age = 18;
System.out.println("姓名 = " + people.name + ", 年龄 = " + people.age);
}
}输出结果如下图所示：
很好，那么我们如果要实例化五个类呢？很简单，我们写五遍就好了
public class Main {
public static void main(String[] args) {
People people1 = new People();
people1.name = "ZWZ01";
people1.age = 18;
People people2 = new People();
people2.name = "ZWZ02";
people2.age = 18;
People people3 = new People();
people3.name = "ZWZ03";
people3.age = 18;
People people4 = new People();
people4.name = "ZWZ04";
people4.age = 18;
People people5 = new People();
people5.name = "ZWZ05";
people5.age = 18;
System.out.println("姓名 = " + people1.name + ", 年龄 = " + people1.age);
System.out.println("姓名 = " + people2.name + ", 年龄 = " + people2.age);
System.out.println("姓名 = " + people3.name + ", 年龄 = " + people3.age);
System.out.println("姓名 = " + people4.name + ", 年龄 = " + people4.age);
System.out.println("姓名 = " + people5.name + ", 年龄 = " + people5.age);
}
}
1.2 使用构造方法实例化类
那么聪明的你又没有想过，能不能简化对类的实例化操作呢？
当然可以！这就需要用到构造方法。
我们现在People.java类中添加构造方法，构造函数访问权限默认即可
public class People {
String name;
int age;
People(String name,int age){
this.name = name;
this.age = age;
}
}这个时候，People类自带的无参构造方法就失效了。
PS：当你没有为类写构造方法时，系统会默认给你安排一个无参的构造方法，当你自己写了构造方法之后，系统自带的就会消失。
接着我们在主函数实例化类的时候，传入参数就可以了，代码是不是简单了很多？
public class Main {
public static void main(String[] args) {
People people1 = new People("ZWZ01",18);
People people2 = new People("ZWZ01",18);
People people3 = new People("ZWZ01",18);
People people4 = new People("ZWZ01",18);
People people5 = new People("ZWZ01",18);
System.out.println("姓名 = " + people1.name + ", 年龄 = " + people1.age);
System.out.println("姓名 = " + people2.name + ", 年龄 = " + people2.age);
System.out.println("姓名 = " + people3.name + ", 年龄 = " + people3.age);
System.out.println("姓名 = " + people4.name + ", 年龄 = " + people4.age);
System.out.println("姓名 = " + people5.name + ", 年龄 = " + people5.age);
}
}这就是构造方法。
当然你也可以把输出信息放在构造方法内部，那也完全可以，就像这样：
public class People {
String name;
int age;
People(String name,int age){
this.name = name;
this.age = age;
System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
}
}主函数就直接做实例化操作即可。
public class Main {
public static void main(String[] args) {
People people1 = new People("ZWZ01",18);
People people2 = new People("ZWZ01",18);
People people3 = new People("ZWZ01",18);
People people4 = new People("ZWZ01",18);
People people5 = new People("ZWZ01",18);
}
}总结起来一句话！构造方法就是在我们实例化类的时候，给类的指定变量赋值、执行指定方法。
本文原创首发CSDN，本文链接https://blog.csdn.net/qq_41464123/article/details/107461710 ，作者博客https://blog.csdn.net/qq_41464123 ，转载请带上本链接，谢谢配合。
二、Java的访问权限
在讲内部类之前，必须要理解Java的访问权限。
Java语言采用访问控制修饰符，来控制类、成员方法、成员变量的访问权限，共分为以下四个级别：
（1）public 公开，对外部访问不做限制。
（2）protected保护，只对子类和同一个包下的类公开。
（3）默认级保护，不加修饰符，只对同一个包下的类公开。
（4）private私有保护，只有自己才能访问，不对外公开。
其中：以上访问级别只适用于类和类的成员，不适用于局部变量。
成员变量、成员方法、构造方法都可以使用上面的四种访问级别。
先把结论写出来，后面一一证明。
| private | 默认 | protected | public | |
|---|---|---|---|---|
| 同一类的成员 | √ | √ | √ | √ |
| 同一个包的其他类(包括子类) | × | √ | √ | √ |
| 不同包的子类 | × | × | √ | √ |
| 不同包的非子类 | × | × | × | √ |
在第一块已经讲解了Java的构造方法，我们就以构造方法为例，讲解Java的访问权限
2.1 public 公开
首先是public 公开，我们将People类的构造方法的访问权限定义为public
public class People {
String name;
int age;
public People(String name,int age){
this.name = name;
this.age = age;
System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
}
}用自己包下的测试函数，跑一波
public class Main {
public static void main(String[] args) {
People people = new People("ZWZ01",18);
}
}
发现没毛病，可以正常实例化People类。
总结：使用public修饰访问权限，所有类都可以访问到此构造方法。
2.2 protected保护
我们在cn.ypc（下面简称A包）的People的构造方法，改成 protected 类型
package cn.ypc;
public class People {
String name;
int age;
protected People(String name,int age){
this.name = name;
this.age = age;
System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
}
}
测试A包下的主函数
package cn.ypc;
public class Main {
public static void main(String[] args) {
People people = new People("ZWZ01",18);
}
}
发现可以正常实例化
接着测试cn.yy包（以下简称B包）下的测试函数
IDE报错了，以我的英语水平都能看出来，按照中文式翻译方法
The constructor People(String, int) is not visible
这个 结构体(类) People(String, int) 是 不 可见的
聪明的读者明白了吧？B包的测试函数无法读取A包People的构造方法。
同理，如果是People的子类，能不能访问到 protected权限的构造方法呢？
我们在A包下，创建一个Student学生类，继承自People父类。代码如下所示
package cn.ypc;
public class Student extends People{
protected Student(String name, int age) {
super(name, age);
}
}接着在A包的测试类中，进行对Student学生类的实例化。
package cn.ypc;
public class Main {
public static void main(String[] args) {
Student student = new Student("ZWZ01",18);
}
}
可以正常输出！
总结：只对子类，或者同一包下的类公开构造方法。（注意子类并不一定在一个包下）
2.3 系统默认
现在People类创建在A包下，我们在B包下创建一个People的子类——Student类。
翻译一下，就是 People 类没有默认的构造方法，必须要自己定义一个构造方法
当我们自动填写父类的构造方法的时候，IDE又报错了，类似之前的错误，也是构造方法找不到的问题。
所以，可以得出结论：在系统默认的访问权限下，对同一个包公开，对不同包不公开。
总结：系统默认情况下，只对同一包下的类公开构造方法。
系统默认与protected不同的是，如果其子类不在同一包下，那么这个子类就不能访问父类的构造方法。
2.4 private私有保护
如果我们把A包的People类构造方法改为private私有
package cn.ypc;
public class People {
String name;
int age;
private People(String name,int age){
this.name = name;
this.age = age;
System.out.println("姓名 = " + this.name + ", 年龄 = " + this.age);
}
}
看！首先是本包下的子类引用父类的构造方法，就报错了，说是找不到构造方法
接着是本包下的测试类调用People的构造方法，也不行！
那么如果是别的包下的测试类，那也一样找不到构造方法。
总结：如果被private修饰，那么这个构造方法只能被自己所用，不能被其他类所调用。
三、总结
1.构造方法：就是在我们实例化类的时候，给类的指定变量赋值、执行指定方法。
2.public：使用public修饰访问权限，所有类都可以访问到此构造方法。
3.protected：只对子类，或者同一包下的类公开构造方法。（注意子类并不一定在一个包下）
4.系统默认：与protected不同的是，如果其子类不在同一包下，那么这个子类就不能访问父类的构造方法。
5.private：如果被private修饰，那么这个构造方法只能被自己所用，不能被其他类所调用。
Java的成员变量、成员方法、构造方法的访问级别可以是上面的任意一个，一般使用 public （公开）和 private （私有）会比较多。