Java 四种不同的权限修饰

      private 私有属性  只在同一个包下 同一个类中可以调用 
 　　  同一个包下，不同的类中，可以调用 缺省，保护(protected),公共（public）可以调用，
 　　　不同的包下的类中，继承关系，可以调用 保护（protected），公共（public）
      不同的类的包下（非继承），可以调用 公共（public）

 1 package com.bytezero.permission;
 2 /*
 3  *
 4  * 四种不同的权限修饰
5  *
 6  */
 7 public class Order
 8 {
 9     private int orderPrivate;
10     int orderDefault;
11     protected int orderProtected;
12     public int orderPublic;
13
14
15
16     private void methodPrivate()
17     {
18         orderPrivate = 1;
19         orderDefault = 2;
20         orderProtected = 3;
21         orderPublic = 4;
22     }
23
24     void methodDefault()
25     {
26         orderPrivate = 1;
27         orderDefault = 2;
28         orderProtected = 3;
29         orderPublic = 4;
30
31     }
32     protected void methodProtected()
33     {
34         orderPrivate = 1;
35         orderDefault = 2;
36         orderProtected = 3;
37         orderPublic = 4;
38     }
39     public void methodPublic()
40     {
41         orderPrivate = 1;
42         orderDefault = 2;
43         orderProtected = 3;
44         orderPublic = 4;
45     }
46
47
48
49 }

 1 package com.bytezero.permission;
 2
 3 public class OrderTest
 4 {
 5     public static void main(String[] args) {
 6         Order order = new Order();
 7
 8         order.orderDefault = 1;
 9         order.orderProtected =2;
10         order.orderPublic = 3;
11
12         order.methodDefault();
13         order.methodProtected();
14         order.methodPublic();
15
16
17         //同一个包中的其他类，不可以调用Order类中的私有的属性，方法
18 //        order.orderPrivate = 4;
19 //        order.methodPrivate();
20 //
21     }
22 }

 1 package com.bytezero.permission2;
 2
 3 import com.bytezero.permission.Order;
 4
 5 public class OrderTest
 6 {
 7     public static void main(String[] args) {
 8
 9         Order order = new Order();
10         order.orderPublic = 1;
11
12         //不同包下的普通类（非子类），要使用order类，不可以调用声明为private,
13         //缺省，protected权限的属性，方法。
14
15 //        order.methodPublic();
16 //
17 //        order.orderPrivate = 2;
18 //        order.orderDefault = 3;
19 //        order.orderProtected = 4;
20 //
21 //
22 //        order.methodDefault();
23 //        order.methodProtected();
24 //        order.methodProtected();
25
26
27
28
29     }
30
31
32     public void show(Order order)
33     {
34
35
36         order.orderPublic = 1;
37
38         //不同包下的普通类（非子类），要使用order类，不可以调用声明为private,
39         //缺省，protected权限的属性，方法。
40
41 //        order.methodPublic();
42 //
43 //        order.orderPrivate = 2;
44 //        order.orderDefault = 3;
45 //        order.orderProtected = 4;
46 //
47 //
48 //        order.methodDefault();
49 //        order.methodProtected();
50 //        order.methodProtected();
51
52         order.orderPublic = 1;
53
54         //不同包下的普通类（非子类），要使用order类，不可以调用声明为private,
55         //缺省，protected权限的属性，方法。
56
57 //        order.methodPublic();
58 //
59 //        order.orderPrivate = 2;
60 //        order.orderDefault = 3;
61 //        order.orderProtected = 4;
62 //
63 //
64 //        order.methodDefault();
65 //        order.methodProtected();
66 //        order.methodProtected();
67
68     }
69
70
71
72
73
74
75
76
77 }

 1 package com.bytezero.permission2;
 2
 3 import com.bytezero.permission.Order;
 4
 5 public class SubOrde extends Order {
 6
 7     public void method()
 8     {
 9         orderProtected = 1;
10         orderPublic = 22;
11
12         methodProtected();
13         methodPublic();
14
15
16         //在不同包的子类中，不能调用Order类中声明private和缺省权限属性和方法
17 //        orderDefault = 3;
18 //        orderPrivate = 4;
19 //
20 //        methodDefault();
21 //        methodPrivate();
22
23
24     }
25
26 }