Java內部類{[普通內部類][靜態內部類]}

package Learn.com.seven;
/**
 * 
 * @author tqw
 *            本例主要學習內部類的使用
 *    Java的內部類分成兩部分來講:
 *        1:內部類
 *        2:靜態內部類
 *
 */
public class ParcellA {//外部類
    
    private int pMember;//聲明一個私有成員
    private static int pstMember;//聲明一個私有靜態成員
    private final int pfMember=9;//常量值
    private final static int pfsMember=0;//常量靜態成員
    
    /**
     * 
     * @author tqw
     *    -#     普通內部類可以訪問外部類的所有成員和方法,
     *    -#  如何在其他的類訪問此內部類呢
     *  -#  必須使用外部類的對象來創建內部類對象
     *  -#  ParcellA parcel = new ParcellA(); 見Entry.java
     *      ParcellA.Contents content = parcel.new Contents();
     */
    public class Contents{//嵌套定義一個內部類
        private int i = 11;
        
        public int value(){//給內部類，定義的一個方法
            System.out.println(pMember);//所有成員
            System.out.println(pstMember);
            System.out.println(pfMember);
            System.out.println(pfsMember);
            outClassMethod();//可以訪問外部類的普通方法
            outClassStaticMehtod();//及靜態方法
            return i;
        }    
        /**
         * @see 但是若Contesnts是靜態的，則可以聲明靜態成員和靜態方法
         */
//        private static int j=0;//非靜態內部類，不能聲明[靜態成員]
//        private static int  out(){//非靜態內部類，不能聲明[靜態方法]        
//        }
    
    }
    /**
     * 
     * @author tqw
     *    - 定義一個嵌套內部類
     *      -# 不能訪問外部內的【非靜態成員】,只能訪問外部類的【靜態成員】。同理也不能訪問外部類的非靜態方法
     *      -# 
     */
    public static class InnerStaticClass{
        private static int memberOfStatic;//可以定義靜態成員        
        private static int Out(){//可以定義靜態方法
            //outClassMethod();//不能訪問外部類的非靜態方法
            //System.out.println(pMember);//由於ParcellA,是靜態內部類，所以不能訪問外部內的非靜態成員
              //因為靜態類，是在加載類時，就初始化了。而非靜態成員，是在創建對象時才初始化，分配內存
              //因此，在靜態類初始化時訪問外部類的非靜態成員時，非靜態成員還不存在，所以不能訪問
            System.out.println(pstMember);//可以訪問靜態成員
            System.out.println(pfsMember);//可以訪問常量成員.由於final int是不可變的成員，即在程序運行中它的值不可以修改。因此
                          //final成員的值，就可以在加載類時就確定下來。所以在靜態內部類訪問它時，它是已知的，所以就 
                          //可以訪問
            System.out.println(pfsMember);//同上原因，所以可以訪問        
            outClassStaticMehtod();//可以訪問靜態方法            
            return memberOfStatic;
        }    
        
        public void Myout(){
            Out();
        }
    }
    /**
     * 
     * @author tqw
     *    
     */
    class Destination{//定義另一個內部類,注意默認訪問權限為包訪問權限，不能在另一個包訪問
        private String label;
        Destination(String WhereTo){//內部類的構造方法
            label =WhereTo;
        }
        String ReadLabel(){//給內部類，定義的一個方法
            return label;
        }
    }
    
    
    public void outClassMethod(){
        System.out.println("outClass Non_Static Method");
    }
    public static void outClassStaticMehtod(){
        System.out.println("outClass Static Method");
    }
}

package Learn.com.test;

import Learn.com.seven.ParcellA;

public class Entry {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ParcellA parcel = new ParcellA();
        //由於Contests這個內部類，是public權限，所以可以訪問，
        //但注意必須是用外部類ParcellA的對象來parcel.new 來創建內部類的對象.
        //並且聲明內部類的對象時，需要使用ParcellA.Contents 這種"外部類.內部類"的方式
        
        ParcellA.Contents content = parcel.new Contents();
        content.value();
                
        
        //由於Destination,是包訪問權限，所以下面的訪問錯誤 
        //ParcellA.Destination desten = parcel.new Destination("china");
        
        //注意，由於InnerStaticClass是ParcellA的靜態內部類，所以可以直接用它來創建對象
        //對於這種用法，在android中的布局中用到，比如
        //LinearLayout.LayoutParams params =  new LinearLayout.LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT);
        //LinearLayout.LayoutParams 類就是LinearLayout中的靜態內部類，可以通過android的LinearLayout.java源碼查看        
        ParcellA.InnerStaticClass obj = new ParcellA.InnerStaticClass();
        obj.Myout();//可以調用public方法    ,只能訪問自己的方法,在這里不能直接訪問外部類的方法,外部方法對它不可見                    
    }

}