java的内部类可以玩出好多花样。介绍都挺多，我就不废话了。专门记一下困惑了我好半天的匿名内部类。

总结一下：

1.匿名内部类通常是为了省事(直接获取一个类实例，这个类实例只在此处用一次，就省得再给它起个名字重新定义了)。所以原则是尽量简单。如果用了这个方法，给读代码的人带来很大困惑，那就得不偿失了

2.匿名内部类不能有构造方法

3.匿名内部类不能定义静态变量、方法和类

4.匿名内部类通常为了实现某个接口或抽象类(实现接口只能实现一个)

5.匿名内部类还可以有继承式用法(和外部类同名，表示继承这个外部类，可以覆写方法，但新增方法通常意义不大)

示例代码：(我觉得已经够乱的了，当然你还可以写的更乱)public class Out1 {

private String x;

public int a=3;

public Out1(String x){

this.x=x;

System.out.println(this.a);

}

@Override

public String toString(){

return "x="+x;

}

public void pp(){

System.out.println("pp");

}

class InnerFn{

public Out2 rOut2(){

return new Out2(11){

public String outkkk(){

return "kkk";

}

public void prf(){

System.out.println(outkkk());

}

};

//此处{}段，定义了一个内部类。匿名内部类可以实现一个接口或继承一个类(不能有构造函数)，

//自己加的方法只能用于内部类局部

}

public Out1 rOut1(){

return new Out1("mmm"){

public int bb=5;

public void ff(){

System.out.println("ff");

}

//无法定义构造方法，只能加返回值变成普通方法

public void Out1(int a){

bb=a;

}

@Override

public void pp(){

ff();

//Out1(8);

System.out.println("匿名内部类覆盖外部类方法");

System.out.println(bb);

}

};

//继承式匿名内部类

}

}

public static void main(String[] args){

Out1 ou1=new Out1("abc");

ou1.pp();

InnerFn t2=ou1.new InnerFn();

System.out.println(ou1);

System.out.println(t2.rOut2());

System.out.println(t2.rOut1());

t2.rOut2().prf();

t2.rOut1().pp();

//t2.rOut1().ff(); //编译通不过，匿名内部类的方法不能被外部识别

}

}

public abstract class Out2 {

private int a;

Out2(int a ) {

this.a=a;

}

abstract void prf();

}

-------------------------------------------------------------------------------------

又看了几篇文章及其评论，觉得有些概念还是深究一下：

1.所匿的是类的名字而非实例的名字——也就是说，原本这里应该写出 Classxx extends Out1或 Classxx implements Iout1 的，然后再 new Classxx()

2.既然这个Classxx没写，那么我们new的时候就用了其超类的类型，也就是写出了new  Out1(){}

3.此时定义了类的同时也产生了实例。这个实例可以赋给一个Out1类型的变量。当然我上面的例子是直接return 了一个对象，而且在外面我也没有给它分配名字，就直接调用其方法了：t2.rOut1().pp();

4.我们甚至可以定义完就直接调用某个方法来完成某个任务，而在外面根本就没有任何使用它的痕迹：比如在某个方法中 new Out1(){ public ... }.xx 。同前所述，这个xx必须是超类中定义了的方法。其实这种用法才是匿名内部类的意义。单次使用，用完就“扔”了。

5.有的文章里说可以实现多个接口，我觉得不对。因为匿名类采用的是隐含的继承(与超类同名)，那么名称只有一个，也就是只能实现一个接口。——当然，如果其超类实现了多个接口，这个就不算在这了。