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方法    ,只能访问自己的方法,在这里不能直接访问外部类的方法,外部方法对它不可见                    
    }

}