概念
嵌套类（nested class）
指被定义在另一个类的内部的类。嵌套类存在的目的应该只是为他的外围类（enclosing class）提供服务。如果嵌套类将来可以回用于其他的某个环境中，他就应该是顶层类（top-level class）。
分类
嵌套类分为四种：静态成员类（static member class）、非静态成员类（nonstatic member class）、匿名类（anonymous class）和局部类（local class）。
内部类：非静态成员类（nonstatic member class）、匿名类（anonymous class）和局部类（local class）。
本条目的
告诉你什么时候应该使用哪种嵌套类，以及这样做的原因。
静态成员类
静态成员类是最简单的一种嵌套类。
最好把他看做是普通的类，只是碰巧被声明在另一个类的内部而已，他可以访问外围类的所有成员，包括声明为私有的成员。
静态内部类是外围类的一个静态成员，与其他的静态成员一样，也最受同样的可访问性规则。如果他被声明为私有的，他就只能在外围类的内部才可以被访问，等等。
注意：如果一个类要被声明为static的，只有一种情况，就是静态内部类。如果在外部类声明为static，程序会编译都不会过。
示例
public class Outer {
private String name;
private int age;
public static class Builder {
private String name;
private int age;
public Builder(int age) {
this.age = age;
}
public Builder withName(String name) {
this.name = name;
return this;
}
public Builder withAge(int age) {
this.age = age;
return this;
}
public Outer build() {
return new Outer(this);
}
}
private Outer(Builder b) {
this.age = b.age;
this.name = b.name;
}
}
静态成员类的一种常见用法是作为共有的辅助类，仅当与他的外部类一起使用时才有意义。例如考虑一个枚举，他描述了计算机支持的各种操作（见滴30条）。Operation枚举应该是Calculator类的公有静态成员类，然后，Calculator类的客户端就可以用诸如Calculator.Operation.PLUS和Calculator.Operation.MINUS这样的名称来引用这些操作。
public class Calculator {
public enum Operation {
PLUS, MINUS, TIMES, DIVIDE;
double apply(double x, double y) {
switch (this) {
case PLUS:
return x + y;
case MINUS:
return x - y;
case TIMES:
return x * y;
case DIVIDE:
return x / y;
}
throw new AssertionError("Unknow op:" + this);
}
}
}
非静态成员类
从语法上讲，静态成员类和非静态成员类之间唯一的区别是：静态成员类的声明中包含修饰符static。尽管他们语法非常相似，但是这两种嵌套类有很大的不同。
非静态成员类的每个实例都隐含着与外围类的一个外围实例（enclosing instance）想关联。在非静态成员类的实例方法内部，可以调用外围实例上的方法，或者利用修饰过的this构造获得外围实例的引用[JLS, 15.8.4]。如果嵌套类的实例可以在他外围实例的情况下，要想创建非静态成原来的实例是不可能的。
代码示例：
package example.nestedclass;
/**
* Created by Jiang Meiwei on 2017/5/24.
*/
public class Outer {
private int a;
private Inner inner;
public class Inner{
private int b ;
}
public Inner getInner(){
if(inner ==null){
inner = new Inner();
}
return inner;
}
}
调用方法：
package example.nestedclass;
/**
* Created by Jiang Meiwei on 2017/5/24.
*/
public class test {
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
}
当非静态成员类的实例被创建的时候，它和外围实例之间的关联关系也随之建立起来；而且，这种关联关系以后也不能被修改。通常情况下，当在外围类的某个实例方法的内部调用了非静态成员类的构造器时，这种管理就自动建立起来。使用表达式enclosingInstance.new MemberClass(args)来手工建立这种关系也是有可能的，但是很少使用。正如你预料的那样，这种关联需要消耗非静态成员类的实例空间，并且增加了构造的时间开销。
java编译器在创建内部类对象时，隐式的把其他外部类的对象也传了进来并一直保存着。这样就使得内部类的对象始终可以访问其外部类的对象。同时这也是为什么在外部类作用范围之外想要创建内部类对象必须创建起外部类对象的原因。
有人会问，如果一个外部类的成员变量与内部类的成员变量同名，也即外部类的成员变量被屏蔽了，怎么办？没事，java里面有如下格式表达外部类的引用：outerClass.this，有了它，我们就不怕这种屏蔽的情况了。
如果声明成员类不要求访问外围实例，就要始终把static修饰符放在它的生命中，使它成为静态成员类，而不是非静态成员类。如果省略了static修饰符，则每个实例都将包含一个额外的指向外围对象的引用。保存这份引用要消耗时间和空间，并且会导致外围实例在符合垃圾回收时仍然得以保留。如果没有外围实例的情况下，也需要分配实例，就不能使用非静态成员类，因为非静态成员类的实例必须要有一个外围实例。
私有静态成员类的一种常见用法用来代表外围类所代表的对象的组件。例如，考虑一个Map实例，他把键和值关联起来。许多Map实现的内部都有一个Entry对象，对应于map中的每个键值对。虽然每个entry斗鱼一哥map关联，但是entry上的方法并不需要访问该map。因此，使用非静态成员来表示entry是很浪费的：私有的静态成员类是最佳的选择。如果不小心漏掉了entry声明中的static修饰符，该map依然可以工作，但是每个entry中将会包含一个指向该map的引用，这样就浪费了空间和时间。
非静态成员类常见用法
非静态成员类常见用法是定义一个Adapter，它允许外部类的实例被看作是另一个不相关的类的实例。例如，Map接口的实现往往使用非静态成员类来实现它们的集合视图（collection view），这些集合视图是由Map的keySet、entrySet和Values方法返回的。
适配器模式
一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。
类图：
代码示例1(继承+实现)：
public interface PlugWithTwoItems {
public PlugWithTwoItems twoItems();
}
public class PlugWithThreeItems {
public String a;
}
public class ThreItemsToTwoItems extends PlugWithThreeItems implements PlugWithTwoItems {
public PlugWithTwoItems twoItems() {
//进行三项转两项的工作
return twoItems;
}
}
代码示例2(包含+实现)：
public interface PlugWithTwoItems {
public PlugWithTwoItems twoItems();
}
public class PlugWithThreeItems {
public String a;
}
public class ThreItemsToTwoItems implements PlugWithTwoItems {
PlugWithThreeItems threeItems = new PlugWithThreeItems();
public PlugWithTwoItems twoItems() {
//进行三项转两项的工作
return twoItems;
}
}
代码示例3(内部类)：
public interface PlugWithTwoItems {
public PlugWithTwoItems twoItems();
}
public class PlugWithThreeItems {
public String a;
public class ThreItemsToTwoItems implements PlugWithTwoItems{
public PlugWithTwoItems twoItems() {
//进行三项转两项的工作
return twoItems;
}
}
}
使用内部类的好处
示例1：
public class TestInnerClass{
public static void main(String args[]){
Goods good = new Goods();
Contents content = good.dest();
System.out.println(content.value());
Destination destination = good.cont("BeiJing");
System.out.println(destination.readLabel());
}
}
interface Contents{
int value();
}
interface Destination{
String readLabel();
}
class Goods{
private class Content implements Contents{
private int i = 11;
public int value(){
return i;
}
}
protected class GDestination implements Destination{
private String label;
private GDestination(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
public Content dest(){
return new Content();
}
public GDestination cont(String s){
return new GDestination(s);
}
}
在这个例子里，类Content和GDestination被定义在了Goods类内部，并且分别有着private和protected修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。在后面的main（）方法里面，直接用Contents content 和Destination destination进行操作，你甚至连这俩个内部类的名字都没有见过，这样，内部类的好处就体现出来了，隐藏你不想让别人知道的操作，即封装性。
示例2：
public class TestInnerClass{
public static void main(String args[]){
Goods good = new Goods();
Contents content = good.dest();
System.out.println(content.value());
}
}
interface Contents{
int value();
}
interface Destination{
String readLabel();
}
class Goods{
private int valueRate = 2;
private class Content implements Contents{
private int i = 11 * valueRate;
public int value(){
return i;
}
}
protected class GDestination implements Destination{
private String label;
public GDestination(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
public Content dest(){
return new Content();
}
public GDestination cont(String s){
return new GDestination(s);
}
}
在这里我们给Goods添加了一个新的private 成员变量 valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把他乘上。我们发现，value（）可以访问valueRate,这也是内部类的第二个好处，一个内部类对象可以访问创建他的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路跟捷径。要想实现这个功能，内部类对象必须有指向外部类对象的引用。
静态成员类与非静态成员类的区别
- 静态内部类没有了指向外部类的引用，非静态内部类对象有着指向其外部类对象的引用。
- 静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能访问非静态的方法和属性，但在普通的内部类可以访问任意外部类的成员变量和方法。
静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法。
静态内部类可以单独初始化
Inner i = new Outer.Inner();
普通内部类初始化：
Outer o = new Outer();
Outer.Inner i = o.new Inner();
匿名类
匿名类不同于Java程序设计语言中的其他任何语法单元。正如你所想象的，匿名类没有名字。它不是外围类的一个成员。它并不与其他的成员一起被声明，而是在使用的同时被声明和实例化。匿名类可以出现在代码中任何允许存在表达式的地方。当且仅当匿名类出现在非静态的环境中时，它才有外围实例。但是即使它们出现在静态的环境中，也不可能拥有任何静态成员。
匿名类适用性限制
匿名类的适用性受到诸多的限制。
- 除了在它们被声明的时候之外，是无法将它们实例化的，你不能执行instanceof测试，或者做任何需要命名类的其他事情。
- 你无法声明一个匿名类来实现多个接口，或者扩展一个类，并同时扩展类和实现接口。
- 匿名类的客户端无法调用任何成员，除了从它的超类型中继承得到之外。
- 由于匿名类出现在表达式当中，它们必须保持简短——大约10行或者更少些——否则会影响程序的可读性。
匿名类常见用法
- 第一种常见用法就是动态的创建函数对象（function object，见21条）。例如,第21条中Arrays.sort方法调用，利用匿名的Comparator实例，根据一组字符串的长度对它们进行排序。
- 第二种常见的用法是创建过程对象（process object），比如Runnable、Thread或者TimerTask实例。
- 第三种常见的用法是在静态工厂内部（参见第18条中部分的intArrayAsList方法）。
Arrays.sort(stringArray, new Comparator<String>() {
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
});
public static void runSomeThing(){
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("I am running");
}
};
new Thread(runnable).start();
}
// Concrete implementation built atop skeletal implementation
static List<Integer> intArrayAsList(final int[] a) {
if (a == null)
throw new NullPointerException();
return new AbstractList<Integer>() {
public Integer get(int i) {
return a[i];
}
@Override
public Integer set(int i, Integer val) {
int oldVal = a[i];
a[i] = val;
return oldVal;
}
public int size() {
return a.length;
}
};
}
额外介绍
局部类
局部类是四种嵌套类中用的最少的类。在任何“可以声明局部变量”的地方，都可以声明局部类，并且局部类也遵守同样的作用域规则。局部类与其他三种嵌套类中的每一种都有一些共同的属性。与成员类一样，局部类有名字，可以被重复使用。与匿名类一样，只有当局部类实在非静态环境中定义的时候，才有外围实例，它们也不能包含静态成员。与匿名类一样，它们必须简短以便不会影响到可读性。
示例：
public class outerTolocal {
public String string;
public int localInt;
public void OtoLocal() {}
public void localMthod(final int m, int n) {
class local {
//此类为局部类
//局部类不需要加public 修饰符，因为这方法执行完 这类就消失了
int methodInt = m;
/**
* 局部类的变量如果要等于外部类的方法的变量，
* 此时外部类的方法变量必须用final 修饰符
* 如：
*/
final int m;
void localInner() {
System.out.println("local method");
}
}
new local().localInner();//在另外的一个类的中不可以创建局部内部类的实例，只能在局部内部类中来创建。
}
}
小结
简而言之，共有四种不同的嵌套类，每一种都有自己的用途。
- 如果一个嵌套类需要在单个方法之外仍然可见的，或者它太长了，不适合于放在方法内部，就应该使用成员类。
- 如果成员类的每个示例都需要一个指向外围实例的引用，就要把成员类做成非静态的；否则，就做成静态的。
- 假设这个嵌套类属于一个方法的内部，如果你只需要在一个地方创建实例，并且已经有了一个预置的类型可以说明这个类的特征，就要把它做成匿名类；否则，就做成局部类。
