【Java】内部类
可以将一个类的定义放在另一个类的定义内部，这就是内部类。
使用内部类的的原因主要有三点：
- 内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据。
- 内部类可以对同一个包中的其他类隐藏起来。
- 当想要定义一个回调函数且不想编写大量代码时，使用匿名(anonymous)内部类比较便捷。
使用内部类访问对象状态
public class TalkingClock {
private int interval;
private boolean beep;
public TalkingClock(int interval, boolean beep) {...}
public void start() {...}
public class TimePrinter implements ActionListener {
Date now = new Date();
System.out.println("At the tone, this time is" + now);
if (beep) Toolkit.getDefaultToolkit().beep();
}
}
内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。
外围类的引用在构造器中设置。编译器修改了所有的内部类的构造器，添加一个外围类引用的参数。因为TimePrinter类没有定义构造器，所以编译器为这个类生成了一个默认的构造器，其代码如下：
public TimePrinter(TalkingClock clock) {
outer = clock;
}
请再注意一下，outer不是Java的关键字。我们只是用它说明内部类中的机制。
当在start方法中创建了TimePrinter对象后，编辑器就会将this引用传递给当前的语音始终的构造器。
ActionListener listener = new TimePinter(this); //parameter automatically added
内部类的特殊语法规则
使用外围类引用的正规语法如下。表达式：
OuterClass.this
表示外围类引用。例如，可以像下面这样编写TimePrinter内部类的actionPerformed方法：
public void actionPerformed(ActionEvent event) {
if (TalkingClock.this.beep) Toolkit.getDefaultToolkit().beep();
}
反过来，可以采用下列语法格式更加明确地编写内部对象的构造器:
outerClass.new InnerClass(construction parameters)
例如
Actionlistner listener = this.new TimePrinter();
在这里，最新构造的TimePrinter对象的外围类引用被设置为创建内部类对象的方法中的this引用。这是一种最常见的情况。通常，this限定词是多余的。不过，可以通过显式地命名将外围类引用设置为其他的对象。例如，如果TimePrinter是一个共有内部类，对于任意的语音时钟都可以构造一个TimePrinter:
TalkingClock jabberer = new TalkingClock(1000, true);
Talking.TimePrinter listener = jabber.new TimePrinter();
需要注意，在外围类的作用域之外，可以这样引用内部类：
OuterClass.InnerClass
要想直接创建内部类的对象，你不能按照你想象的方式，去引用外部类的名字，而必须使用外部类的对象来创建该内部类对象。在拥有外部类对象之前是不可能创建内部类对象的。这是因为内部类对象会暗暗地连接到创建它的外部类对象上。
内部类是否有用、必要和安全
- 内部类是一种编译器现象，与虚拟机无关。编译器会把内部类翻译成用$（美元符号）分隔外部类与内部类名的常规类文件，而虚拟机一无所知。例如，在TalkingClock类内部的TimePrinter类将被翻译成TalkingClock$TimePrineter.class。
- 如果一个类是匿名内部类，那么clas文件名称是OuterClass$(1,2,3).class
- 编译器为了引用外部类，生成了一个附加的实例域this$0（名字this$0是由编译器合成的，在自己编写的代码中不能够引用）。
局部内部类
假设TimePrinter这个类名字只在start方法中创建这个类型的对象时使用了一次，那么可以像下面这样使用：
public void start() {
class TimePrinter implements ActionListner {
public void actionPerformed(ActionEvent event) {
Date now = new Date();
System.out.println("At the tone, the time is " + now);
if (beep) Toolkit.getDefaultToolkit().beep();
}
}
ActionListener listener = new TimePrinter();
Timer t = new Timer(interval, listner);
t.start();
}
局部类不能用public或private访问说明符进行声明。它的作用域被限定在声明这个局部类的块中。
局部类有一个优势，即对外部世界可以完全地隐藏起来。即使TaklingClock类中的其他代码也不能访问。除start方法之外，没有任何方法知道TimePrinter类的存在。
由外部方法访问final变量
与其他内部类比较，局部类还有一个优点。它们不仅能够访问包含它们的外部类，还可以访问局部变量。不过，那些局部变量必须被声明为final。如：
public void start(int interval, final bolean beep) {
class TimePrinter implements ActionListner {
public void actionPerformed(ActionEvent event) {
Date now = new Date();
System.out.println("At the tone, the time is " + now());
if (beep) Toolkit.getDefaultToolkit().beep();
}
}
}
编译器实现内部类访问局部变量的方式是这样的：在内部类中为每一个要访问的局部变量设置数据域，然后在构造函数中将这些数据域初始化为要访问的局部变量值。
匿名内部类
将局部内部类的使用再深入一步。假如只创建这个类的一个对象，就不必命名了。这种类被称为匿名内部类（annoymous inner class)
public void start(int interval, final boolean beep) {
ActionListener listener = new ActionListener() {
public void actionPerformed(ActionEvent event) {
Date now = new Date();
System.out.println("At the tone, the time is" + now());
if (beep) Toolkit.getDefaultToolkit().beep();
}
}
Timer t = new Timer(interval, listner);
t.start();
}
它的含义是：创建一个实现ActionListner接口的类的新对象，需要实现的方法actionPerformed定义在括号{}内。
通常的语法格式为：
new SuperType(construction parameters) {
inner class methods and data
}
其中，SuperType可以是ActionListner这样的接口，于是内部类就要实现这个接口。SuperType也可以是一个类，于是内部类就要扩展它。
如果你的基类需要一个有参数的构造器，应该怎么办：
public classs Parcel8 {
public Wrapping wrapping(int x) {
//Base constructor call
return new Wrapping(x) {
public int value() {
return super.value() * 47;
}
};
public static void main(String[] args) {
Parcel8 p = new Parcel8();
Wrapping w = p.wrapping(10);
}
}
只需要简单地传递合适的参数给基类的构造器即可，这里是将x传进new Wrapping(x)。尽管Wrapping 只是一个具有具体实现的普通类，但它还是被其导出类当做公共“接口”来使用：
public class Wrapping {
private int i;
public Wrapping (int x) { i = x;}
public int value() { return i; }
}
你会注意到， Wrapping拥有一个要求传递一个参数的构造器，这使得事情变的更有趣了。
在匿名类中定义定义字段时，还能够对其执行初始化操作：
public class Parcel9 {
public Destination destination(final String dest) {
return new Destination() {
private String label = dest;
public String readLabel() { return label; }
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d = p.destination(“Tesmania”);
}
}
如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，name编译器会要求其参数引用是final的，就像你在destinaion()的参数中看到的那样。如果你忘记了，将会得到一个错误信息。
如果只是简单地给一个字段赋值，那么此例中的方法是很好的。但是，如果想做一些类似构造器的行为。在匿名类中不可能有命名的构造器，但通过实例初始化，就能够达到为匿名内部类创建一个构造器的效果，就像这样：
abstract class Base {
public Base(int i) {
print("Base conctructor, i=" + 1);
}
}
public class AnonymousConstructor {
public class Base getBase(int i){
return new Base(i){
print("Inside instance initializer");
public void f() {
print("In anonymous f()");
}
}
}
public static void main(String[] args) {
Base base = getBase(47);
base.f();
}
}/*
Base constructor, i = 47;
Inside instance initializer
In anonymous f()
在此例中，不要求变量i一定是final的。以为i被传递给匿名内部类的积累的构造器，它并不会在你你们内部类被直接使用。
下例是带实例化的“parcel”形式。注意destination()参数必须是final的，因为它们是在匿名内部类使用的：
public class Parcel10 {
public Destination destination(final String dest, final float price) {
return new Destination(){
private int cost;
//Instance initialization for each object
{
cost = Math.round(price);
if (cost > 100) {
System.out.println("Over budget");
}
}
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
Parcel10 p = new Parcel10();
Destination d = p.destination("Tasmania", 101.395.F);
}
}
//
Over budget;
匿名内部类的重点
1.使用匿名内部类时，必须继承或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口
2. 匿名内部类是不能定义构造函数的
3. 匿名内部类是不能存在任何的静态成员变量和静态方法
4. 匿名内部类为局部内部类，所有局部内部类的所有限制对匿名内部类生效
5. 匿名内部类不能使抽象的，它必须要实现继承的类或者实现接口的所有抽象方法
嵌套类
如果不需要内部类对象与其外围类对象之间有联系，那么可以将内部类声明为staic。这通常称为嵌套类。
普通的内部类对象隐式地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了，嵌套类意味着：
1）要创建嵌套类的对象，不需要其外围类的对象。
2）不能从嵌套类的对象中访问非静态的外围类对象。嵌套类和普通的内部类还有一个区别。普通内部类的字段与方法，只能放在类的外部层次，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是嵌套类可以包含这些东西。
闭包和回调
- 闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。通过这个定义，可以看出内部类是面向对象的闭包，因为它不仅包含外围类的对象的信息，还自动拥有一个指向此外围类对象的引用，在此作用域内，内部类有权操作所有的成员，包括private成员。
内部类的重点
- 非静态内部类可以访问外部类的数据域，包括私有的
- 局部内部类和匿名内部类可以访问方法中的参数，不过参数必须为final
- 匿名内部类，必须要继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或实现一个接口。
- 匿名内部类不能定义构造函数
- 匿名内部类中不能存在任何的静态成员变量和静态方法。