Java内部类

Java内部类

可以将一个类的定义放在另一个类的定义内部，这就是内部类。

内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起，并控制位于内部类的可视性。内部类与组合是完全不同的概念。

import java.util.*;

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 dest){
		return new Destination(dest);
	}

	public Contents contents(){
		return new Contents();
	}

	public void ship(String dest){
		Contents c=contents();
		Destination d=to(dest);
		System.out.println(d.readLabel());
	}

	public static void main(String[] args){
		Parcel2 p=new Parcel2();
		p.ship("HongKong");
		Parcel2 q=new Parcel2();
		Parcel2.Contents c=q.contents();
		Parcel2.Destination d=q.to("Beijing");
	}
}

当生成一个内部类的对象时，此对象与制造它的外围对象之间就有了一种联系，所以它能访问其外围对象的所有成员，而不需要任何特殊条件。此外，内部类还拥有外部类的所有元素的访问权。

import java.util.*;

interface Selector{
	boolean end();
	Object current();
	void next();
}

public class Sequence{
	private Object[] items;
	private int next=0;
	public Sequence(int size){
		items=new Object[size];
	}
	public void add(Object x){
		if(next<items.length){
			items[next++]=x;
		}
	}
	private class SequenceSelector implements Selector{
		private int i=0;
		public boolean end(){
			return i==items.length;
		}
		public Object current(){
			return items[i];
		}
		public void next(){
			if(i<items.length)
				i++;
		}
	}
	public Selector selector(){
		return new SequenceSelector();
	}
	public static void main(String[] args){
		Sequence sequence=new Sequence(10);
		for(int i=0;i<10;i++)
			sequence.add(Integer.toString(i));
		Selector selector=sequence.selector();
		while(!selector.end()){
			System.out.print(selector.current()+" ");
			selector.next();
		}
		System.out.println();
	}
}

最初看到SequenceSelector，可能觉得它只不过是一个内部类罢了。但请仔细观察它，注意方法end(),current(),next(),都用到了objects，这是一个引用，它并不是SequenceSelector的一部分，而是外围类中的一个private字段。然而内部类可以访问外部类的方法和字段，就像自己拥有它们似的，这带来了很大方便。

所以内部类自动拥有对其外围类所有成员的访问权。这是如何做到的呢？当某个外围类的对象创建一个内部类对象时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。然后，你在访问此外围类的成员时，就是用那个引用来选择外围类的成员。因此内部类对象只能在与其外围类对象相关联的情况下才能被创建(内部类为非static时)。

嵌套类

如果不需要内部类对象与外围类对象之间有联系，那么可以将内部类声明为static，这通常称为嵌套类。嵌套类意味着：

1）要创建嵌套类的对象，并不需要创建外围类的对象；

2）不能从嵌套类的对象中访问非静态的外围类的对象；

嵌套类与普通内部类还有一个区别：普通内部类的字段与方法，只能放在类的外部层次上，所以普通内部类不能有static数据和static字段，也不能包含嵌套类；但是嵌套类可以包含所有这些东西。

为什么需要内部类？

每个内部类都能独立的继承自一个接口的实现，所以无论外围类是否已经继承了某个接口的实现，对于内部类都没有影响。

内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效的实现了“多重继承”，也就是说内部类允许继承多个非接口类型。