可以将一个类的定义放在另一个类的定义内部，这就是内部类。
内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起，并控制位于内部类的可视性。内部类与组合是完全不同的概念。
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字段，也不能包含嵌套类；但是嵌套类可以包含所有这些东西。
为什么需要内部类？
每个内部类都能独立的继承自一个接口的实现，所以无论外围类是否已经继承了某个接口的实现，对于内部类都没有影响。
内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效的实现了“多重继承”，也就是说内部类允许继承多个非接口类型。
原文地址：http://blog.csdn.net/cstopcoder/article/details/41116975
