1.内部类是定义在另一个类中的类。使用内部类的原因有：
- 内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据
- 内部类可以对同一个包中的其他类隐藏起来
- 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷
2.使用内部类访问对象状态
内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。
例如，外部类TalkingClock中有数据域beep，而内部类中没有定义数据域beep，但是却可以直接通过if (beep) Toolkit.getDefaultToolkit().beep();来引用外部类TalkingClock的对象的数据域。
public class InnerClassTest { public static void main(String[] args) { TalkingClock clock = new TalkingClock(1000, true); clock.start(); } } class TalkingClock { private int interval; private boolean beep; public TalkingClock(int interval, boolean beep) { this.interval = interval; this.beep = beep; } public void start() { ActionListener listener = new TimePrinter(); Timer t = new Timer(interval, listener); t.start(); } public class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); } } }
3.使用内部类访问外部类的对象的作用域的具体实现
（1）内部类对象总有一个隐式引用，它指向了创建它的外部类对象，这个引用在内部类中的定义是不可见的，将外围类对象的引用称为outer，则上面的引用语句可以修改为：
if (outer.beep) Toolkit.getDefaultToolkit().beep();
（2）编译器修改了所有的内部类的构造器，添加了一个外围类引用的参数，例如：编译器为TimePrinter类生成了一个默认的构造器,用来将外围类对象传递进来
public TimerPrinter(Talking clock){ outer = clock; }
（3）在start方法中，执行ActionListener listener = new TimePrinter();时编译器实际上会将外围类对象this传递到TimerPrinter的构造器中：
ActionListener listener = new TimePrinter(this);
到此，就实现了内部类访问外围类的对象的数据域。
使用正规语法在内部类中引用外部对象的数据域：
if (TalkingClock.this.beep) Toolkit.getDefaultToolkit().beep();
使用正规语法在内部类中编写内部对象的构造器
ActionListener listener = this.new TimePrinter();
显式地命名将外围类引用设置为其他的对象
TalkingClock jabberer = new TalkingClock(100,true); TalkingClock.TimerPrinter listener = jabberer.new TimerPrinter();
4.局部内部类
（1）观察上述代码可以看到，TimerPrinter这个类只在start方法中创建这个类型的对象时使用了一次，这时就可以将TimerPrinter类定义成start方法的局部类，局部类不能用public或private声明，它的作用域被限制在这个局部类的块中。局部类的优势就是可以对外部世界完全隐藏起来，即使TalkingClock类中的其他代码也不能访问它，除了start方法，其他没有任何方法知道这个类的存在。
public void start() { class TimePrinter implements ActionListener { public void actionPerformed(ActionEvent event) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); } } ActionListener listener = new TimePrinter(); Timer t = new Timer(interval, listener); t.start(); }
（2）局部类还有一个优点：它们不仅能够访问包含它们的外部类，还可以访问局部变量，但是，局部类访问的局部变量必须为final，即一旦赋值就不可变。
class TalkingClock {
private int interval; private final boolean beep;
public void start(int interval, boolean beep)
{
...
}
}
5.匿名内部类
如果只创建内部类的一个对象，那么这个内部类就不用命名了，可以直接使用代码块替代，这种类被称为匿名内部类
public void start(int interval, boolean beep) { ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent event) { System.out.println("At the tone, the time is " + new Date()); if (beep) Toolkit.getDefaultToolkit().beep(); } }; Timer t = new Timer(interval, listener); t.start(); }
6.静态内部类
如果使用内部类只是为了把一个类隐藏在另外一个类的内部，而不需要在内部类中引用外围类对象，这个时候可以将内部类声明为static，以便取消产生的引用。
例如，如果想要计算一下数组中最大值和最小值，可以有常规方法和静态内部类方法两种。
（1）常规实现
- 首先需要写一个包含两个值的Pair类：
package test; public class Pair { private double first; private double second; public Pair(double f, double s) { first = f; second = s; } public double getFirst() { return first; } public double getSecond() { return second; } }
- 然后需要写一个比较数组中的元素然后得到最大值和最小值的类，并返回一个Pari类型的对象
package test; public class ArrayAlg { public static Pair minmax(double[] values) { double min = Double.POSITIVE_INFINITY; double max = Double.NEGATIVE_INFINITY; for (double v : values) { if (min > v) min = v; if (max < v) max = v; } return new Pair(min, max); } }
- 最后可以这么来调用：
package test; public class Main { public static void main(String[] args) { double[] d = new double[20]; for (int i = 0; i < d.length; i++) d[i] = 100 * Math.random(); Pair p = ArrayAlg.minmax(d); System.out.println("min = " + p.getFirst()); System.out.println("max = " + p.getSecond()); } }
这样一来确实是实现了，没有问题。但是，由于在大型项目中很可能会有类名和Pair冲突的情况，同时，两个类也显得很麻烦，并且最为重要的是，在Pari对象中不需要引用任何其他的对象，因此可以使用静态内部类来解决这些问题。
（2）静态内部类实现
package staticInnerClass; /** * This program demonstrates the use of static inner classes. * @version 1.02 2015-05-12 * @author Cay Horstmann */ public class StaticInnerClassTest { public static void main(String[] args) { double[] d = new double[20]; for (int i = 0; i < d.length; i++) d[i] = 100 * Math.random(); ArrayAlg.Pair p = ArrayAlg.minmax(d); System.out.println("min = " + p.getFirst()); System.out.println("max = " + p.getSecond()); } } class ArrayAlg { public static class Pair { private double first; private double second; public Pair(double f, double s) { first = f; second = s; } public double getFirst() { return first; } public double getSecond() { return second; } } public static Pair minmax(double[] values) { double min = Double.POSITIVE_INFINITY; double max = Double.NEGATIVE_INFINITY; for (double v : values) { if (min > v) min = v; if (max < v) max = v; } return new Pair(min, max); } }
将Pair类放在ArrayAlg类中并声明为static，然后就可以通过下面的代码同时调用这两个类：使用ArrayAlg.Pair也不会出现重名的困扰。
ArrayAlg.Pair p = ArrayAlg.minmax(d); System.out.println("min = " + p.getFirst()); System.out.println("max = " + p.getSecond());
如果不将Pair声明为static，由于没有可用的隐式（静态）ArrayAlg类型对象初始化内部类对象，编译器就会报错
Exception in thread "main" java.lang.Error: Unresolved compilation problem: No enclosing instance of type ArrayAlg is accessible. Must qualify the allocation with an enclosing instance of type ArrayAlg (e.g. x.new A() where x is an instance of ArrayAlg). at staticInnerClass.ArrayAlg.minmax(StaticInnerClassTest.java:76) at staticInnerClass.StaticInnerClassTest.main(StaticInnerClassTest.java:15)
静态类的对象在代码编译前就已经存在于内存中的对象，如果Pair类中不加static，在静态方法minmax中会return new Pair(min, max);此时，由于Pari不是静态类，所以在程序代码编译前无法执行，因此就会出现无法编译的错误。