匿名内部类

一、 内部类特性

1.  内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。
2.  内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。
3.  内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。

二、 匿名内部类

1. 

 

public class Parcel7
{
    public Contents contents()
    {
        return new Contents()
        {
            private int i = 11;
            public int value() { return i; }
        };
    }
    public static void main(String[] args)
    {
        Parcel7 p = new Parcel7();
        Contents c = p.contents();
    }
}

 

在上述代码中， contents() 方法将返回值的生成与表达这个返回值的类定义结合在一起。另外，这个类是匿名的，它没有名字。

语法：创建一个继承自Contents的匿名类的对象。通过new表达式返回的引用被自动向上转型为对Contents的引用。（向上转型内容参照：https://www.cnblogs.com/Leo-Xia/p/10917614.html）

关于分号的说明：在匿名内部类末尾的分号，并不是用来标记此内部类结束的。实际上，它标记的是表达式的结束，只不过这个表达式正巧包含了匿名内部类，因此，这与别的地方使用的分号是一致的。

上述匿名内部类的代码，是下面代码的简化版本：

public class Parcel7
{
    public MyContents implements contents
    {
        private int i = 11;
        public int value() { return i; }
    }
    public Contents contents() { return new MyContents(); }
    public static void main(String[] args)
    {
        Parcel7 p = new Parcel7();
        Contents c = p.contents();
    }
}

在这个匿名类中，使用了默认的构造器来生成Contents。

 

2. 下面代码展示了基类需要一个有参数的构造器

public class Wrapping
{
    private int i;
    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() * 47; 
            }
        };
    }
    public static void main(String[] args)
    {
        Parcel8 p = new Parcel8();
        Contents w = p.wrapping();
    }
}

在该例子中，可以看到Wrapping拥有一个要求传递参数的构造器。

这里是将x传进new Warpping（x）。

在匿名内部类中，只需要简单地传递合适的参数给基类的构造器即可。

 

3. 在匿名内部类定义中，对其进行初始化操作

public class Parcel9
{
    public Destination destination(final String dest)
    {
        return new Destination()
        {
            private String lable = dest;
            public String readLable() { return lable; }
        };
    }
    public static void main(String[] args)
    {
        Parcel9 p = new Parcel9();
        Destination d = p.destination("Tasmaina");
    }
}

在new Destination（）中，使用到了在其外部定义的变量dest，编译器要求我们引用的参数是final的

即： 如果定义一个匿名内部类，并且希望他使用一个在其外部定义的对象，那么编译器会要求其参数引用final的。

 

4. 

如果只是简单的给一个字段赋值，那么3例中的方法是很好的。但是，如果想做一个类似构造器的行为，但是匿名类中不可能有命名构造器（其原因是因为它根本就没有名字）。通过实例初始化，就能够达到为匿名内部类创建一个构造器的效果。具体实例如下：

abstract class Base
{
    public Base(int i)
    {
        System.out.println("Base coustructor. i = " + i);
    }
    public abstract void f();
}
public class AnonymousConstructor
{
    public static Base getBase(int i)
    {
        return new Base(i)
        {
            { System.out.println("Inside instance initializer "); }
            public void f()
            {
                System.out.println("In anonymous f()");
            }
        };
    }
        public static void main(String[] args)
        {
            Base base = getBase(47);
            base.f();
        }
}

注意： 在此例中，并没有要求变量 i 一定是final的，因为 i 被传递给匿名类的基类的构造器，并没有在匿名类内部被直接使用。

 

5. 下面代码为带实例初始化的形式

public class Parcel10
{
    public Destination destination(final String dest, final float price) 
    {
        return new Destination()
        {
            private int cost;
            {
                cost = Math.round(price);
                if(cost > 100)
                    System.out.println("Over budget");
            }
            private String lable = dest;
            public String readLable() { return lable; }
        };
    }
    public static void main(String[] args)
    {
        Parcel10 p = new Parcel10();
        Destination d = p.destination("Tasmaina", 101.395F);
    }
}

其中 destination 的参数必须是 final 的，因为他们在匿名类中被使用到了。

在实例初始化的内部，有 if 语句，它们不能作为实例初始化动作的一部分。所以对于匿名类而言，实例初始化的实际效果就是构造器。（但是，你不能重载实例初始化方法，所以仅有一个这样的构造器）

 

匿名内部类与正规继承相比是受到限制的，因为匿名内部类既可以扩展类，也可以实现接口，但是不能二者兼备。并且，如果是实现接口，也只能实现一个接口。