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方法    ,隻能通路自己的方法,在這裡不能直接通路外部類的方法,外部方法對它不可見                    
    }

}