[JAVA]对Java的4种访问控制级别的演示

在Java中有4种访问控制级别，分别是Public，Protected，Default，Private；
这四种的访问修饰符的访问权限等级从前到后依次增加。
接下来将用代码依次的展示这四种访问修饰符，在本类（自己本身），子类，同包，不同包的这四种情况下的访问权限。 (学了这么久了，好不容易挤出时间整理一次)

Public (公共访问级别)

在同一包下测试，我们以Package1为例

// Person.java
//主包中的父类
package Package1;
public class Person
{
   public String name;
}

// Student.java
//主包中的子类
package Package1;
public class Student extends Person { }

// TEST.java
//主包中的测试类
package Package1;
public class TEST { 
    public static void main(String[] args) 
    {					
    	Student stu = new Student();		
    	stu.name = "嘿嘿嘿嘿，对吗对吗？";
    	// 验证父类中的public属性继承过来之后是否可以（直接）使用		
    	System.out.println(stu.name);
    	// 输出:嘿嘿嘿嘿，对吗对吗？，验证成功	
    } 
}

在两个不同的包里进行测试

// Person.java
//主包中的父类
package Package1;
public class Person{
   public String name;
}

// Student.java
//主包中的子类
package Package1;
public class Student extends Person { }

//在次包中的测试类
package Package2;
import Package1.Student;
public class TEST { 
    public static void main(String[] args) 
    {					
    	Student stu = new Student();		
    	stu.name = "嘿嘿嘿嘿，对吗对吗？";
    	// 验证父类中的public属性继承过来之后是否可以（直接）使用		
    	System.out.println(stu.name);
    	// 输出:嘿嘿嘿嘿，对吗对吗？，验证成功	
    } 
}

在三个不同的包里进行测试

//在包Package1下的的父类
package Package1;
public class Person {
   public String name;
}

//在包Package2下的的子类
package Package2;
import Package1.Person;
public class Student extends Person {}

//在包Package3下的测试类
package Package3;
import Package2.Student;
public class TEST { 
    public static void main(String[] args) 
    {     
     Student stu = new Student();  
     stu.name = "嘿嘿嘿嘿，对吗对吗？";
     // 验证父类中的public属性继承过来之后是否可以（直接）使用  
     System.out.println(stu.name);
     // 输出:嘿嘿嘿嘿，对吗对吗？，验证成功 
    } 
}

Public : 是公共的，被public所修饰的成员可以在任何类中都能被访问到

NOTICE: public 能用来修饰类，在一个 java 源文件中只能有一个类被声明为 public ，而且一旦有一个类为 public ，那这个 java源文件的文件名就必须要和这个被 public 所修饰的类的类名相同，否则编译不能通过。
By the way，一个类作为外部类的时候只能被 public 或者默认访问修饰符所修饰，但是一个类如果作为内部类的时候，则可以被四种访问修饰符所修饰，因为一个类作为内部类的时候，就作为外部类的一个成员属性了，因此可以有四种访问修饰符修饰，这是内部类和外部类的一个区别。

Protected (子类访问级别)

如果一个类的成员被 protected 访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问。

在同一包下测试，我们以Package1为例

// Person.java
//主包中的父类
package Package1;
public class Person
{
   protected String name;
}

// Student.java
//主包中的子类
package Package1;
public class Student extends Person { }

// TEST.java
//主包中的测试类
package Package1;
public class TEST { 
    public static void main(String[] args) 
    {					
    	Student stu = new Student();		
    	stu.name = "哎，我太难了";
    	// 验证父类中的protected属性继承过来之后是否可以（直接）使用		
    	System.out.println(stu.name);
    	// 输出:哎,我太难了，验证成功。	
    } 
}

在两个包下测试

// Person.java
//主包中的父类
package Package1;
public class Person{
   protected String name;
}

// Student.java
//主包中的子类
package Package1;
public class Student extends Person { }

//在次包中的测试类
package Package2;
import Package1.Student;
public class TEST { 
    public static void main(String[] args) 
    {					
    	Student stu = new Student();		
    	stu.name = "哎，我太难了";
    	// 验证父类中的protected属性继承过来之后是否可以（直接）使用		
    	System.out.println(stu.name);
    	// 报错: The field Person.name is not visible
    } 
}

这段代码得出在不同包中的非子类（其他类）中是无法直接使用被 protected 修饰的属性的成员。

测试在不同包中的子类使用被 Protected 修饰的属性的使用效果

//主包中的父类
package Package1;
public class Person
{
   protected String name;
}

//次包中的子类
package Package2;
import Package1.Person;
public class Student extends Person 
{ 
	public static void main(String[] args) 
    {					
    	Student stu = new Student();		
    	stu.name = "哎，我太难了";
    	// 验证父类中的protected属性继承过来之后是否可以（直接）使用		
    	System.out.println(stu.name);
    	// 输出:哎,我太难了，验证成功。	
    } 
}

故由该代码可知对于被 protected 修饰的属性，在非本包中的子类中也是可以使用的。But ，需要注意的是：次包中的Student类继承了主包中的name属性之后，他虽然继承过来了但是他本质还是属于非本包属性，所以是不能被非本包的非子类使用的。故在次包中设置的测试类是没有办法直接使用被 protected 修饰的属性的。

Default (包访问级别)

如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别，这个类或类的的成员只能被本包中的其他类访问。

测试在同一包中的类和类的成员使用被 Default (缺省) 修饰的属性的使用效果

//主包中的父类
// Person.java
package Package1;
class Person
{
   String name;
}

// Student.java
//主包中的子类
package Package1;
class Student extends Person { }

// TEST.java
// 主包中的测试类
package Package1;
public class TEST 
{
	public static void main(String[] args) 
    {					
    	Student stu = new Student();		
    	stu.name = "海龙同学是我好姐妹";
    	// 验证父类中的 default 属性继承过来之后是否可以（直接）使用		
    	System.out.println(stu.name);
    	// 输出:海龙同学是我好姐妹。验证成功。	
    } 
}

测试在不同包中的类的成员使用被 Default (缺省) 修饰的属性的使用效果

//主包中的父类
package Package1;
public class Person
{
   String name;
}

//次包中的子类
package Package2;
import Package1.Person;
public class Student extends Person 
{ 
	public static void main(String[] args) 
    {					
    	Student stu = new Student();		
    	stu.name = "海龙同学是我好姐妹";
    	// 验证父类中的 default 属性继承过来之后是否可以（直接）使用		
    	System.out.println(stu.name);
    	// 报错: The field Person.name is not visible
    } 
}

Privated (当前访问级别)

如果类的成员成员被 privated 访问控制符来修饰，则这个成员只能被 该类的其他成员访问 ，其他类无法直接访问。类的良好封装性就是通过 privated 关键字来实现的。

package Package1;
public class Person 
{
    private String name;
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "海龙哥是我好姐妹";
        //验证在本类中的访问效果
        System.out.println(person.name);
        //输出:海龙哥是我好姐妹，验证成功
    }
}

以下简单的用表格来直观的展现四种访问级别

(终于玩完了，四节数据结构实验课和晚上睡觉觉的时间，还真是不容易呢)