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 }