10.6 匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
匿名内部类实际上都是父类引用指向子类的实现
匿名内部类与正规的继承相比有些受限，因为匿名内部类既可以扩展类，也可以实现接口。但是不能两者兼备。如果实现接口也只能实现一个接口。

—-这两个例子效果一样—-

创建一个继承自Contents的匿名类的对象，通过new表达式返回的引用被自动向上转型为对Contents的引用。

 class Wrapping {
    private int i =13 ;
    public Wrapping(int x){
        i = x;
    }
    public int value(){
        return i;
    }
}
public class Parcel8 {
    public Wrapping wrapping(int x) {
        return new Wrapping(x)
        {
            public int value() {
                return super.value() * 10;
            }
        };
    }
    public void f(Wrapping wrapping) {
        wrapping.value();
    }
    public static void main(String[] args) {
        Parcel8 p8 = new Parcel8();
        Wrapping w = p8.wrapping(10);
        p8.f(new Wrapping(5)
        {
            @Override
            public int value() {
                return super.value();
            }
        });
    }
}

public class Parcel9 {
    public Destination destination( final String dest){  //要求参数引用是final的
        return new Destination()
        {
            private  String label = dest;
            @Override
            public String realLabel() {
                return label;
            }
        };
    }
    public static void main(String[] args) {
        Parcel9 p9 = new Parcel9();
        Destination d = p9.destination("dsada");
    }
}

匿名类中不可能有命名的构造器（因为它根本没有名字），但是通过实例初始化，就能够达到为匿名内部类创建一个构造器的效果

abstract class Base {
    public Base(int i) {
        print("Base 构造器, i = " + i);
    }
    public abstract void f();
}
public class AnonymousConstructor {
    public static Base getBase( int i) {
        return new Base(i) {
            //此处的实例初始化，相当与这个匿名内部类的构造器
            //但它其实不需要构造器的
            {
                print("内部实例初始值设定项");
            }
            @Override
            public void f() {
                print("In anonymous f()");
            }
        };
    }
    public static void main(String[] args) {
        Base base = getBase(47);
        base.f();
    }
}