java内部类的总结

类别:Java 点击:0 评论:0 推荐:

// 2004-9-18
内部类总结:

1内部类的嵌套可以理解成类的链关系,在构造一个内部类(非static)的实例的时候,会将直接外层类的实例
作为参数传进构造函数,而外层类的实例也是用其外层类的实例构造,所以是一种链状关系,内部的类可以使用所有
外层的类的实例,而外层的类不能使用内层的类, 应用a.this(最外层类实例) ,a.b.c.this(链中某个外层的实例)。

class TheOuter{
  class kk {
    class gg {
    int tt = 100;
    }
  }
 
  class aa {
    class bb {
      int jj = 10;
      class cc {
        { int ff = TheOuter.aa.bb.this.jj;
          // 无法直接访问到gg不在链关系内 
          System.out.println(ff);
        }
      }
    }
  }
}

2 创建一个内部类 new aa().new bb().new()cc 实际上是调用 外层类实例.new 本层构造函数()
  如果内部类是static的不需要外层类的实例 多个static嵌套的内部类的实例 aa.bb.cc test = new aa.bb.cc();

3
class a0 {
  class b0 {
  }
}

class vvv{
  class ff extends a0.b0 {// ff这里不是内部类也行
    ff(a0 kk){
      kk.super();
    }
  }
}
继承自内部类要调用父类的外层类的super()

4
class dd {
  void print(){
 System.out.println("dd.println is there");
  }
  class kk {
   kk(int i){}
 class cc {
   void pp() {
     System.out.println("****");
   }
   void ddpp() {
     dd.this.print();
   }
 }
  }
}

class aa {
  public static void main (String agrs[]) {
   dd.kk.cc test = new dd().new kk(10).new cc();
   test.ddpp();
  }
}
在类内部可以是使用外层类,但是如果生成一个实例的句柄就没有提供访问上层类的功能。


5 this 是指本类的实例

6 缺省的new
class cc {
  {
    new test();
  } 
  class kk {
    {
      System.out.println("there kk"); 
    }
  }
 
  class test {
   {
     new kk();
   } 
    class kk {
      {
        System.out.println("there test_kk");
      }
    }
  }
}
可以直接使用new,new的范围可以是 之际外层.this.new 和this.new 但是如果内层与外层出现同名类以内部优先

7
//当有链关系的时候要注意类不要重名
class vv {
  class bb {} //! 
  class kk {
    //class vv{} 这样就会出错
    class bb {} //!这样就不会出错
  }
}

8
class a0 {
  class b0 {
  }
}

class vvv{
  class ff extends a0.b0 {// 不是内部类也行
    ff(a0 kk){
      kk.super();
    }
  }
}
继承自内部类要调用父类的外层类的super()

9 匿名内部类
interface oo {
  //oo(int g) {}
  int k = 10;
  void pt();
}

class pp {
  pp(int g) {
  }
  int get() {
 return 100;
  }
}
 
class me {
  /*
  interface oo {
 void pt();
  }
  */
  class kk{
 oo testmed() {
   final int i = 10;
   int g = 100;
   return new oo() {  
  int kk;
  {
    // 使用外面的东西要声名成final
    // 继承接口内部优先
    // 匿名内部类没有构造函数,只能使用块,初始化
    kk = i + k ;
  }  
  public void pt() {
    System.out.println(kk);
  }
   };
 }
 pp testmed0() {
   return new pp(10){ // 继承自类
  public int get() {
    return super.get() * 10;
  }
   };
 }
  }
}
匿名内部类可以继承自接口也可以继承自类,继承自类的构造函数中 可以有参数。

10
class bf {
  interface kk {}
  class aa {
    // 接口能嵌套在接口中(不受限制),或者嵌套在顶层,下面就不行
    //interface gg {}
  }
}

本文地址:http://com.8s8s.com/it/it15374.htm