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