Java内部类{[普通内部类][静态内部类]}

 1 package Learn.com.seven;
 2 /**
 3  * 
 4  * @author tqw
 5  *            本例主要学习内部类的使用
 6  *    Java的内部类分成两部分来讲:
 7  *        1:内部类
 8  *        2:静态内部类
 9  *
10  */
11 public class ParcellA {//外部类
12     
13     private int pMember;//声明一个私有成员
14     private static int pstMember;//声明一个私有静态成员
15     private final int pfMember=9;//常量值
16     private final static int pfsMember=0;//常量静态成员
17     
18     /**
19      * 
20      * @author tqw
21      *    -#     普通内部类可以访问外部类的所有成员和方法,
22      *    -#  如何在其他的类访问此内部类呢
23      *  -#  必须使用外部类的对象来创建内部类对象
24      *  -#  ParcellA parcel = new ParcellA(); 见Entry.java
25      *      ParcellA.Contents content = parcel.new Contents();
26      */
27     public class Contents{//嵌套定义一个内部类
28         private int i = 11;
29         
30         public int value(){//给内部类，定义的一个方法
31             System.out.println(pMember);//所有成员
32             System.out.println(pstMember);
33             System.out.println(pfMember);
34             System.out.println(pfsMember);
35             outClassMethod();//可以访问外部类的普通方法
36             outClassStaticMehtod();//及静态方法
37             return i;
38         }    
39         /**
40          * @see 但是若Contesnts是静态的，则可以声明静态成员和静态方法
41          */
42 //        private static int j=0;//非静态内部类，不能声明[静态成员]
43 //        private static int  out(){//非静态内部类，不能声明[静态方法]        
44 //        }
45     
46     }
47     /**
48      * 
49      * @author tqw
50      *    - 定义一个嵌套内部类
51      *      -# 不能访问外部内的【非静态成员】,只能访问外部类的【静态成员】。同理也不能访问外部类的非静态方法
52      *      -# 
53      */
54     public static class InnerStaticClass{
55         private static int memberOfStatic;//可以定义静态成员        
56         private static int Out(){//可以定义静态方法
57             //outClassMethod();//不能访问外部类的非静态方法
58             //System.out.println(pMember);//由于ParcellA,是静态内部类，所以不能访问外部内的非静态成员
59               //因为静态类，是在加载类时，就初始化了。而非静态成员，是在创建对象时才初始化，分配内存
60               //因此，在静态类初始化时访问外部类的非静态成员时，非静态成员还不存在，所以不能访问
61             System.out.println(pstMember);//可以访问静态成员
62             System.out.println(pfsMember);//可以访问常量成员.由于final int是不可变的成员，即在程序运行中它的值不可以修改。因此
63                           //final成员的值，就可以在加载类时就确定下来。所以在静态内部类访问它时，它是已知的，所以就 
64                           //可以访问
65             System.out.println(pfsMember);//同上原因，所以可以访问        
66             outClassStaticMehtod();//可以访问静态方法            
67             return memberOfStatic;
68         }    
69         
70         public void Myout(){
71             Out();
72         }
73     }
74     /**
75      * 
76      * @author tqw
77      *    
78      */
79     class Destination{//定义另一个内部类,注意默认访问权限为包访问权限，不能在另一个包访问
80         private String label;
81         Destination(String WhereTo){//内部类的构造方法
82             label =WhereTo;
83         }
84         String ReadLabel(){//给内部类，定义的一个方法
85             return label;
86         }
87     }
88     
89     
90     public void outClassMethod(){
91         System.out.println("outClass Non_Static Method");
92     }
93     public static void outClassStaticMehtod(){
94         System.out.println("outClass Static Method");
95     }
96 }

 1 package Learn.com.test;
 2 
 3 import Learn.com.seven.ParcellA;
 4 
 5 public class Entry {
 6 
 7     /**
 8      * @param args
 9      */
10     public static void main(String[] args) {
11         ParcellA parcel = new ParcellA();
12         //由于Contests这个内部类，是public权限，所以可以访问，
13         //但注意必须是用外部类ParcellA的对象来parcel.new 来创建内部类的对象.
14         //并且声明内部类的对象时，需要使用ParcellA.Contents 这种"外部类.内部类"的方式
15         
16         ParcellA.Contents content = parcel.new Contents();
17         content.value();
18                 
19         
20         //由于Destination,是包访问权限，所以下面的访问错误 
21         //ParcellA.Destination desten = parcel.new Destination("china");
22         
23         //注意，由于InnerStaticClass是ParcellA的静态内部类，所以可以直接用它来创建对象
24         //对于这种用法，在android中的布局中用到，比如
25         //LinearLayout.LayoutParams params =  new LinearLayout.LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT);
26         //LinearLayout.LayoutParams 类就是LinearLayout中的静态内部类，可以通过android的LinearLayout.java源码查看        
27         ParcellA.InnerStaticClass obj = new ParcellA.InnerStaticClass();
28         obj.Myout();//可以调用public方法    ,只能访问自己的方法,在这里不能直接访问外部类的方法,外部方法对它不可见                    
29     }
30 
31 }