类部类总结

package  test.jdk;   

/**   
 * 内部类的收集与整理   
 *    
 * @author 赵学庆 www.java2000.net   
 */    
public   class  InnerTest {   
  private  String instAtt =  "实例变量" ;   

  private   static  String staticAtt =  "静态变量" ;   

  public   void  test() {   
    int  methodAtt =  1 ;   
    final   int  methodFinalAtt =  2 ;   
    // 非静态方法里的内部类    
    class  staticMethodInnerClass {   
      @Override    
      public  String toString() {   
        // 非静态方法里无法访问实例的外部变量    
        System.out.println("非静态方法的内部类可以访问外部类的实例变量："  + instAtt);   
        System.out.println("非静态方法的内部类可以访问外部类的静态变量："  + staticAtt);   
        // 非静态方法里无法访问方法的非final的变量    
        // System.out.println(methodAtt);    
        System.out.println("非静态方法的内部类可以访问方法的final变量："  + methodFinalAtt);   
        return   "my nickname is white" ;   
      }   
    }   
    new  staticMethodInnerClass().toString();   
    new  Object() {   
      @Override    
      public  String toString() {   
        System.out.println("非静态方法的匿名内部类可以访问外部类的实例变量："  + instAtt);   
        System.out.println("非静态方法的匿名内部类可以访问外部类的静态变量："  + staticAtt);   
        // 静态方法里匿名内部类无法访问方法的非final的变量     
        // System.out.println(methodAtt);    
        System.out.println("非静态方法的匿名内部类可以访问方法的final变量："  + methodFinalAtt);   
        return   "我是匿名内部类" ;   
      }   
    }.toString();   
  }   

  public   static   void  main(String blackbat[]) {   
    int  methodAtt =  1 ;   
    final   int  methodFinalAtt =  2 ;   
    // 静态方法里的内部类    
    class  staticMethodInnerClass {   
      @Override    
      public  String toString() {   
        // 静态方法里无法访问实例的外部变量    
        // System.out.println(instAtt);    
        System.out.println("静态方法的内部类可以访问外部类的静态变量："  + staticAtt);   
        // 静态方法里无法访问方法的非final的变量    
        // System.out.println(methodAtt);    
        System.out.println("静态方法的内部类可以访问方法的final变量："  + methodFinalAtt);   
        return   "my nickname is white" ;   
      }   
    }   
    new  staticMethodInnerClass().toString();   
    new  Object() {   
      @Override    
      public  String toString() {   
        // 静态方法的匿名内部类不能访问外部类的非静态变量    
        // System.out.println("非静态方法的匿名内部类可以访问外部类的非静态变量：" + instAtt);    
         System.out.println("非静态方法的匿名内部类可以访问外部类的静态变量："  + staticAtt);   
        // 静态方法里匿名内部类无法访问方法的非final的变量    
        // System.out.println(methodAtt);    
         System.out.println("非静态方法的匿名内部类可以访问方法的final变量："  + methodFinalAtt);   
        return   "我是匿名内部类" ;   
      }   
    }.toString();   
    new  InnerTest().test();   
    // 建立静态内部类(static Inner Class)的对象    
    ImOutClass.StaticInnerClass staticIC = new  ImOutClass.StaticInnerClass();   
    staticIC.access();   
    /*   
     * 建立非静态内部类(non-static Inner Class)的对象. <br>注意这种建立对象的格式 首先创建外部类的对象 然后使用对象.new 来创建。   
     */    
    ImOutClass outC = new  ImOutClass();   
    ImOutClass.InstInnerClass inC = outC.new  InstInnerClass();   
    inC.access();   
  }   
}   

class  ImOutClass {   
  private   static  String staticAtt =  " 外部类的类变量 " ;   

  private  String instAtt =  " 外部类的实例变量 " ;   

  private   static  String xx =  "外部静态变量" ;   

  // private String xx = "外部类的实例变量";    
  // 外部类的非静态方法    
  public   void  instanMethod() {   
    System.out.println(" 和外部类实例方法 " );   
  }   

  // 外部类的静态方法    
  public   static   void  staticMethod() {   
    System.out.println(" 和外部类静态方法 " );   
  }   

  // 静态内部类(static Inner Class)     
  public   static   class  StaticInnerClass {   
    public  StaticInnerClass() {   
      System.out.println(" 我是静态内部类 " );   
    }   

    public   void  access() {   
      System.out.println(" 我可以访问 "  + staticAtt);   
      staticMethod();   
      System.out.println(" 我可以访问外部的静态变量 "  + xx);   
      // 非静态的方法 instanMethod() 无法从静态的地方使用    
      // instanMethod();     
    }   
  }   

  // 非静态内部类(non-static Inner Class)    
  public   class  InstInnerClass {   
    public  InstInnerClass() {   
      System.out.println(" 我是成员级内部类，非静态内部类 " );   
    }   

    public   void  access() {   
      System.out.println(" 我可以访问 "  + instAtt);   
      instanMethod();   
      staticMethod();   
      System.out.println(" 我可以访问外部的静态变量 "  + xx);   
    }   
  }   
}  

 运行结果为 
 静态方法的内部类可以访问外部类的静态变量：静态变量 
 静态方法的内部类可以访问方法的final变量：2 
 非静态方法的匿名内部类可以访问外部类的静态变量：静态变量 
 非静态方法的匿名内部类可以访问方法的final变量：2 
 非静态方法的内部类可以访问外部类的实例变量：实例变量 
 非静态方法的内部类可以访问外部类的静态变量：静态变量 
 非静态方法的内部类可以访问方法的final变量：2 
 非静态方法的匿名内部类可以访问外部类的实例变量：实例变量 
 非静态方法的匿名内部类可以访问外部类的静态变量：静态变量 
 非静态方法的匿名内部类可以访问方法的final变量：2 
  我是静态内部类 
  我可以访问 外部类的类变量 
  和外部类静态方法 
  我可以访问外部的静态变量 外部静态变量 
  我是成员级内部类，非静态内部类 
  我可以访问 外部类的实例变量 
  和外部类实例方法 
  和外部类静态方法 
  我可以访问外部的静态变量 外部静态变量 

转载：www.java2000.net网