java面向对象中四种权限（private，protected，public，友好型）详解

转自http://blog.csdn.net/a1237871112/article/details/50926975

　　及http://blog.csdn.net/blackmanren/article/details/9249381

俗话说没有规矩就没有方圆，java作为一门严谨的面向对象的高级编程语言，自然对权限整个重要的问题有严格的控制。

Java一共有四种权限，private (私有)，public（公有）。Protected（受保护）还有友好型。

在java里，这些语句都可以修饰类中的成员变量和方法，但是只有public和友好型可以修饰类。

• 1. 不用priavate，public，protected修饰的成员变量和方法被称为友好变量和友好方法
• 2. 当在另外一个类B中，用该类A创建了一个对象后，如果类A和类B在同一个包中，那么该对象能访问自己的友好变量和友好方法
• 3. 在class前面加public的类称为public类，class前面不能加protected和private，不加public的类称为友好类。
• 4. public类默认的构造方法是public，友好类默认的构造方法是友好的。

举个例子：

接下来就详细解释一下这几种权限的差别(博客最后有表格）按权限由低到高：（高权限有低权限所有特性）

Private：

类中的所有private方法和private 成员变量只能在类中访问而不能在其他类中访问。

例如：

1. package Main;
2. public class Private {
3. private int a;
4. private int b;
5. Protected (){
6. this.a=1;
7. this.b=2;//a和b只能在Private类中调用
8. }
9. private void set(){
10. System.out.println(""+a+""+b+"\n");
11. }
12. void Print(){
13. this.set();//只能在这里用；
14. }
15. }

友好型和protected：

如果在另一个类中声明其他的一个类，如果这两个在一个包中那么另一个类能访问这个其他类的友好型变量不同包不能访问：

如果在另一个B类中声明其他的一个类A，如果这两个在一个包中那么另一个类B也能能访问这个其他类A的protected变量（或方法），如果不在一个包，那么如果类A有一个父类C如果，如果父类C中有一个protected变量（或方法），只要B，C在一个包中，B就能使用A中从父类继承的protected方法。如果A是B的子类，如果AB不在一个包中，那么A可以使用B中protected方法。

例如：

1. package Main;
2. import Protected.*;
3. public class Main {
4. public static void main(String args[]){
5. Protected jkl=new Protected();
6. jkl.Print();//调用jkl父类的protect方法
7. Frindly prot =new Frindly();
8. System.out.println(prot.a);//在Main类中调用友好型的变量
9. prot.set();//在Main类中调用友好型的方法
10. }
11. }
12. package Main;
13. public class Frindly {
14. int a,b,c,d;
15. Frindly(){
16. a=b=c=d=1;
17. }
18. void set (){
19. System.out.print(""+a+" "+b+"\n");
20. }
21. }
22. package Main;
23. public class Protectedfather{
24. protected int a;
25. private int b;
26. protected Protectedfather (){
27. this.a=1;
28. this.b=2;//a和b只能在Protected中调用
29. }
30. private void set(){
31. System.out.println(""+a+""+b+"\n");
32. }
33. protected void Print(){
34. this.set();//只能在这里用；
35. }
36. }
37. package Protected;
38. import Main.*;
39. public class Protected extends Protectedfather{
40. public Protected(){
41. super();//在另一个包中调用里父类中的protect构造方法
42. super.a=12;//调用父类的protect变量
43. }
44. }

Public：

如果类中的方法或者变量是public，那么就可以在别的类中调用，没有限制（用在夸包）。A带掉用别的包中的B类

1. package Main;
2. import Public.*;
3. public class Main {
4. public static void main(String args[]){
5. int a;
6. Public p=new Public();//调用public类中的public方法
7. a=p.a;//调用Public类中的public变量
8. p.set();
9. }
10. }
11. package Public;
12. public class Public {
13. public int a=12;
14. public void set (){
15. System.out.println("OK\n");
16. }
17. }

总结表格：：

	同一类	同包	不同包
	子类	非子类	子类	非子类
Private	是	否	否	否	否
友好型	是	是	是	否	否
Protected	是	是	是	是	否
Public	是	是	是	是	是