java构造器 权限_一文搞懂Java的 构造方法 和 访问权限

目录

零、前言

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);

}

}

总结起来一句话！构造方法就是在我们实例化类的时候，给类的指定变量赋值、执行指定方法。

二、Java的访问权限

在讲内部类之前，必须要理解Java的访问权限。

Java语言采用访问控制修饰符，来控制类、成员方法、成员变量的访问权限，共分为以下四个级别：

(1)public 公开，对外部访问不做限制。

(2)protected保护，只对子类和同一个包下的类公开。

(3)默认级保护，不加修饰符，只对同一个包下的类公开。

(4)private私有保护，只有自己才能访问，不对外公开。

其中：以上访问级别只适用于类和类的成员，不适用于局部变量。

成员变量、成员方法、构造方法都可以使用上面的四种访问级别。

先把结论写出来，后面一一证明。

Java四种访问权限的范围

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 (私有)会比较多。