Java 内部类的一些总结

            内部类
   
 1.成员内部类____
     内部类中不可以出现static修饰,
     能访问内部类的方式为外部类的对象,
     内部类可以变相的看成是外部类的成员(我个人是这样认为的)
     因为在main中想要访问,只能先创建对象,通过对象进行访问.
     
     内部类也是类,也可以使用this访问当前对象.
     访问外部类当前对象的方式为_外部类名.this.Object
 定义方式:
 public class outerClass{
 
 //可以在外部方法中实例化一个内部类,以此获取内部类信息.
 
 //当然,在main方法中还是需要先创建外部类对象.
 
 //最终一条简洁的语句应该为:
 //outerClass.interClass in = new outerClass().new interClass();
  public static void main(String a[]){
   outerClass on = new outerClass();
   on.setinterClass();
  }
  
  /**
  通过外部方法访问内部类信息
  /
  public void setinterClass(){
  interClass in = new interClass();
  in.see();
  }
  
  /**
  创建一个内部类
  /
  class interClass{
   public void see(){
    System.out.println("interClass");
   }
  }
 }
 
 2.方法内部类____
     把类定义在内部类的方法中.(我把它当作是个局部变量)
     1).只能在内部类的方法中实例化.
     2).方法内部类不能使用非final成员.
     方法中的变量位于栈中,方法执行完,栈被删除,成员成为历史(与方法共存亡),
     方法内部创建的成员对象可能还存在,比如它被引用到其它某些代码中存储到成员变量内,
     不能保证成员和对象的存活期一样成,不能使用.
     3).修饰方法只有final和abstract
  
  public class outerClass{
   public void Go(){
    class interClass{
     public void run(){
      System.out.println("interClass");
     }
     new interClass().run();
    }
   }
   
   public outerClass(){
    new outerClass().
   }
  }
  
 
 3.匿名内部类____
     没有名字的内部类
     1)继承式的内部类
      输出的内容为 This’s in the main()
     引用的变量不是t对象,是t匿名子类对象._
     创建继承式内部类的关键是重写父类的方法.
     父类不能引用本身没有的方法,创建新的方法是多余的.(我把它当作重写的一种方式)
     
     2)接口式的内部类
      实现了一个接口的匿名内部类,而且只能实现一个接口.(我把它当作继承接口的一种方式)
      
     3)参数式的内部类
  
  *1_
  public class thisExtendsinterClass{
   public void run(){
    System.out.println("This's thisExtendsinterClass");
   }
   
   public static void main(String a[]){
    thisExtendsinterClass t = new thisExtendsinterClass(){
     @Override
     public void run(){
      System.out.println("This’s in the main()");
     }
    };
    t.run();
   }
  }
  
  *2_
  public interface thisInterfaceClass{
   void run();
  }
  
  public class text{
   public static void main(String a[]){
    thisInterfaceClass t = new thisInterfaceClass(){
     public void run(){
      System.out.println("Welcome to use thisInterfaceClass");
     }
    };
   }
  }
  
  *3_
  public interface thisInterfaceParametClass{
   void run();
  }
  
  class gettIPC {
   public void gettIPCObject(thisInterfaceParametClass Obj){
   }
   
   public static void run(){
    gettIPC g = new gettIPC();
    g.gettIPCObject(new thisInterfaceParametClass(){
     public void run(){
      System.out.println("Welcome to use thisInterfaceParametClass");
     }
    });
   }
  }
  
 4.静态嵌套类____(就不在举实例了,我把它当作是个静态属性)
     从技术上讲,静态嵌套类不属于内部类.
     因为内部类与外部类共享一种特殊关系,更确切地说是对实例的共享关系.
     而静态嵌套类则没有上述关系.
     它只是位置在另一个类的内部,因此也被称为顶级嵌套类.
     
     
     静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问它.
     静态嵌套类不能访问外部类的成员和方法.
     outerClass.interClass StaticInterClass = new outerClass.interClass();