简单谈谈java中匿名内部类构造函数

先看看下面的代码能不能编译通过：

public static void main(string[] args) {
list l1 = new arraylist();
list l2 = new arraylist(){};
list l3 = new arraylist(){{}};
system.out.println(l1.getclass() == l2.getclass() );
system.out.println(l2.getclass() == l3.getclass() );
system.out.println(l1.getclass() == l3.getclass() );
}

答案是能通过编译，输出3个false。l1很容易理解，就是声明了一个

arraylist对象，那么l2、l3是什么呢？

l2是一个匿名类内部类对象，继承arraylist；

l3语句有些古怪，带了两个大括号，其实我们这样写就会明白了，这也是一个匿名内部类的定义，它的代码类似如下：

class sub extends arraylist {
{
//初始化代码块
}
}
list l3 = new sub();

看到了吧，就是多了一个初始化代码块而已，起到构造函数的功能。当然一个类中的构造代码块可以有多个，下面的代码是可以编译的：

list l4 = new arraylist(){{}{}{}};

匿名内部类虽然可以用一个初始化代码块来充当构造函数，但其构造函数还是进行了特殊的处理，它在初始化时直接调用父类的同参构造函数，然后在调用自己的代码块，例如：

list l5 = new arraylist(5){
{
system.out.println("我是匿名内部类");
}
};

等价于：

class sub extends arraylist{
{
system.out.println("我是匿名内部类");
}
sub(int num){
super(num);
}
}
list l5 = new sub(5);

我们来看段示例代码

package testtest; 
 
public class main { 
 
  public static void main(string[] args) { 
    innertest inner = new innertest(); 
    test t = inner.get(3); 
    system.out.println(t.geti()); 
  } 
} 
 
class test { 
 
  private int i; 
 
  public test(int i) { 
    this.i = i; 
  } 
 
  public int geti() { 
    return i; 
  } 
} 
 
class innertest { 
 
  public test get(int x) { 
    return new test(x) { 
 
      @override 
      public int geti() { 
        return super.geti() * 10; 
      } 
    }; 
  } 
} 

编译之后得到４个class文件：test.class，innertest.class，innertest$1.class以及main.class。容易看出来，main.class是测试类的class文件，test.class是超类test的class文件，innertest.class是innertest 的class文件，最值得关注的就是匿名内部类的class文件innertest$1.class。