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不是静态类，所以在程序代码编译前无法执行，因此就会出现无法编译的错误。