java匿名内部类

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