JAVA中四种访问修饰符的区别总结_java访问修饰符的区别

在Java中有四个访问修饰符，分别是：
1：public；
2：protected；
3：缺省（default）
4：private。
这四种的访问修饰符的访问权限等级从上到下依次增加。
接下来将用代码依次的展示这四种访问修饰符，在----本类（自己本身），子类，同包，不同包的这四种情况下的访问权限。
注：这四种访问权限在本类中都可以自由的被调用访问。

一：public

1：验证在子类中能否被继承，能否在其他类中被直接使用。

//主包中的父类
package 访问修饰符主包;
public class Person {
	public String name;
}
//主包中的子类
package 访问修饰符主包;
public class Student extends Person {
}
//测试类
package 访问修饰符主包;
public class TestStudent {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "小李子";//验证父类中的public属性继承过来之后是否可以（直接）使用
		System.out.println(stu.name);//输出张三，验证成功 
		}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

**分析：**验证得出被public修饰的属性可以直接被子类继承过来并且在其他类当中被直接使用。

2：验证在不同包中的不同类中是否可以被直接引用

//在主包中的父类
package 访问修饰符主包;
public class Person {
	public String name;
}
//在主包中的子类
package 访问修饰符主包;
public class Student extends Person {
}
//在次包中的测试类
package 访问修饰符次包;
import 访问修饰符主包.Person;
public class Test2 {
	public static void main(String[] args) {
		Person person = new Person();
		person.name = "张三";//验证在不同包中的不同类，public属性是否可以被直接使用。
		System.out.println(person.name);//输出张三，验证成功。
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

总结分析验证得出，被public修饰的属性，可以被自己本身使用，可以被继承的子类使用，也可以被跨包的类使用，public就是一个公开的访问修饰符，他所代表的属性是公开的面向外界的。
**

二：protected

1：验证在包内被protected修饰的属性，继承之后还能否被自如的使用。

//主包的父类
package 访问修饰符主包;
public class Person {
	protected String name;
}
//主包中的子类
package 访问修饰符主包;
public class Student extends Person {
}
//主包中的测试类
package 访问修饰符主包;
public class TestStudent {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "小李子";//验证继承过来的属性====即父类中的protected属性能否在其他类中被（直接）使用
		System.out.println(stu.name);//输出小李子，验证成功
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

分析验证得出，被protected修饰的属性在包内是和public一样的，可以随便访问的。

2：验证不同包中的非子类使用被protected修饰的属性的使用效果。

//主包的父类
package 访问修饰符主包;
public class Person {
	protected String name;
}
//主包中的子类
package 访问修饰符主包;
public class Student extends Person {
}
//次包中的测试类
package 访问修饰符次包;
import 访问修饰符主包.Person;
public class Test2 {
	public static void main(String[] args) {
		Person person = new Person();
		person.name = "张三";//**注意：在这里name会报错，显示将主包中的name属性改为public！！！！！**
		System.out.println(person.name);//无法正常编译，
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

3：验证不同包中的子类使用被protected修饰的属性的使用效果。

//主包的父类
package 访问修饰符主包;
public class Person {
	protected String name;
}
//次包中的子类
package 访问修饰符次包;
import 访问修饰符主包.Person;
public class Student extends Person {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "小李子";//验证继承过来的非本包属性====即父类中的protected属性
		System.out.println(stu.name);//输出小李子，验证成功，证明可以在非本包的子类中使用。
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

分析上述验证证实，对于被protected修饰的属性，在非本包中的子类中也是可以使用的。但是，需要注意的是：次包中的Student类继承了主包中的name属性之后，他虽然继承过来了但是他本质还是属于非本包属性，所以是不能被非本包的非子类使用的。故在次包中设置的测试类是没有办法直接使用被protected修饰的属性的。
总结分析：被protected修饰的属性可以在本包中被自由使用，但是在非本包中只有他的子类（而且只能是子类本身）可以进行使用。非本包的非子类是不能使用的。

**

三：缺省（default）

**
1：验证本包内对缺省访问修饰符修饰的属性使用的效果。

//主包中的父类
package 访问修饰符主包;
public class Person {
	 String name;
}
//主包中的子类
package 访问修饰符主包;
public class Student extends Person {
}
//主包中的测试类
package 访问修饰符主包;
public class TestStudent {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "小李子";//验证继承过来的缺省修饰属性能否在同一个包中被任意使用
		System.out.println(stu.name);//输出小李子，验证成功
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

分析：由上述代码验证得出，当属性的访问修饰符缺省的时候，他在本包中的访问权限效果是同protected和public的，即是可以自由访问使用的。

2：验证缺省访问修饰符在非本包的类中的使用情况。

//主包中的父类
package 访问修饰符主包;
public class Person {
	 String name;
}
//次包中的子类
package 访问修饰符次包;
import 访问修饰符主包.Person;
public class Student extends Person {
	public static void main(String[] args) {
		Student stu = new Student();
		stu.name = "小李子";//验证继承过来的非本包属性====即父类中的缺省修饰属性！！！显示报错。
		System.out.println(stu.name);//无法正常输出，所以无法使用。
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

总结分析：缺省修饰符的属性只能在本包中使用，他当然可以在子类中使用，但是如果这个子类跨了包，那就拜拜了，效果就和private一样了。所以，在本包中吊炸天，出了包就歇菜。

**

四：private

**
1：验证本包中的访问效果

package 访问修饰符主包;
public class Person {
	private String name;
	public static void main(String[] args) {
		Person person = new Person();
		person.name = "张三";//验证在本类中的访问效果
		System.out.println(person.name);//输出张三
	}
}
1
2
3
4
5
6
7
8
9

总结分析：private属性和public属性其实是两个极端，都比较好记，private属性只能在本类中进行使用，在其他地方根本没有办法进行直接访问。
2020-2-2补充：
使用private修饰的属性和方法只能在本类访问，外界只能是通过间接的形式进行访问。就算是子类继承，也是隐式继承，子类中也不能直接访问这些属性和方法。因此就更谈不上方法的覆写和属性的覆盖了。

五：总结

几个节点。第一：本类；第二：子类；第三：本包
1，public：公开的，就属他最能，没有他够不到的地方。
2，protected：受保护的，在自己包里面跟public一样能，出了本包之后，只能由他儿子去横。而且只能是他儿子自己横，还不能找代言人。
3，缺省（default）：每个世界都有每个世界的规则，修饰符世界中规定的新生儿的活动范围是在本包中。他可以在本类中，也可以在子类中。但是出包，歇菜—。
4，private（私有的）：这简直就是一个被囚禁的罪犯，你就是想和他有点交流，想给他送点东西（set），或者是听他说说饭菜是否可口（get）都得通过特定的接口去访问特定的信息（属性）。

完结：这个世界我来了，我希望了解这个世界的规则，去看一看这个世界到底有多么的缤纷，是否像她，说的那样----美好。。。。。