java 有关内部类的几个问题

/**************************

*1、内部类的形式是怎样的？

*2、为什么要有“内部类”？

*3、利用内部类可以方便实现哪些功能？

*4、内部类的实现机制？

*/

1、内部类的形式：

    在Thinking in java中有parcel的例子，里面包含两个内部类，Contents和Destination。然后在parcel类的ship()函数内构建两个内部类的引用。可以通过这两个内部类的对象调用对象方法。也可以在外部类parcel里建立方法，该方法返回内部类的对象。那么，在构建外部类的对象后可以调用该方法新建内部类对象。

public class Parcel2
{
    class Contents 
    {
        private int i = 11;
        public int value() { return i; }
    }
    class Destination
    {
        private String label;
        Destination(String whereTo) { label = whereTo; }
        String readLabel() { return label; }
    }
    public Destination to(String s)
    {
        return new Destination(s);
    }
    public Contents contents() 
    {
        return new Contents();
    }
    public void ship(String dest)
    {
        Contents c = new Contents();
        Destination d = new Destination(dest);
        System.out.println(d.readLabel());
    }
    public static void main(String[] args)
    {
        Parcel2 p = new Parcel2();
        p.ship("Tasmania");
        Parcel2 q = new Parcel2();
        // Defining references to inner classes:
        Parcel2.Contents c = q.contents();
        Parcel2.Destination d = q.to("Borneo");
    }
}

2、为什么要用内部类？

    上例中在外部类中建立内部类的对象引用，然后调用执行相关方法。如果仅仅是为了调用某个对象方法，大可不必创造“内部类”的概念。这涉及为什么要创造内部类的概念，它带来什么好处？内部类产生对象必须有一个重要的前提条件，那就是它的外部类对象必须先创建，通过外部类的对象构建内部类对象，有两种方法：其中之一就向上面那样，外部类有一个public方法生产内部类的对象；其二是通过外部类对象实现。

Parcel2.Contents c = q.new Contents();

    这要求内部类Inner是public或者protected访问权限。内部类的另一个重要特性是：它可以不受限制的访问其所在外部类的域。java可以实现多个接口，implements inerfaceA, interfaceB。但是不允许多重继承类，如果你确实需要利用例外的类来操控本类的成员，可以利用内部类满足这个需要，

3、利用内部类可以方便哪些功能？

    无论是方法内部类还是匿名内部类，它们的共同点同2中提到的一样，可以不受限制的访问外部类的域和方法。同时，可根据限制条件让内部类隐藏或向上转型为接口类型，从而消除方法返回的具体类型的限制。匿名内部类可以隐藏接口的具体实现，使得类的使用者只关注要实现的目标。

interface inner
{
	int fi()；
}
public class out
{
	private int i;
	private int f()
	{
		return i;
	}
	out(int i)
	{
		this.i = i;
	}
	public inner cf()
	{
		return new inner()
		{
			public int fi()
			{
				i++;
				return f();
			}
		};
	}
	public static void main(String[] args)
	{
		out ot = new out(4);
		inner oi = ot.cf();
		System.out.println("the i = " + oi.fi());
	}
}

从这个例子可以看到接口inner是以匿名内部类的方式实现的。在外部类out中，定义一个函数cf()，该函数返回接口inner，在函数内部实现接口并实例化。可以看到，匿名内部类有普通内部类一样的重要特性，那就是可以不受限制的访问外部类的域和方法。

i++;
return f();