嵌套类（nested class）是指被定义在另一个类的内部的类。嵌套存在的目的应该只是为它的外围类提供服务。如果嵌套类将来可能会用于其他的某个环境中，它就应该是顶层类。嵌套类有四种：静态成员类，非静态成员类，匿名类和局部类，除了第一种外，其他三种都被称为内部类。本条目将告诉你什么时候应该使用哪种嵌套类，以及这样做的原因。

静态成员类是最简单的一种嵌套类。最好把它看作是普通的类。只是碰巧被声明在另一个类的内部而已，它可以访问外围类的所有成员，包括那些申明为私有的成员。静态成员类是外围类的一个静态成员，与其他的静态成员一样，也遵守同样的可访问性规则。如果它被申明为私有的，它就只能在外围类的内部才可以被访问，等等。

静态成员类的一种常见用法是作为共有的辅助类，仅当与它的外部类一起使用时才有意义。

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;
    }
}

从语法上来讲，静态成员类和非静态成员类之间唯一的区别是，静态成员类的声明中包含修饰符static，尽管他们的语法非常相似，但是这两种嵌套类有很大的不同。非静态成员类的每个实例都隐含着与外围实例上的方法，或者利用修饰过的this构造获得外围实例的引用。如果嵌套类的实例可以在它外围类的实例之外独立存在，这个嵌套类就必须是静态成员类，在没有外围实例的情况下，要想创建非静态成员的实例是不可能的。

当非静态成员类的实例被创建的时候，它和外围实例之间的关联关系也随之被建立起来，而且，这种关联关系以后不能被修改。通常情况下，当外围类的某个实例方法的内部调用非静态成员类的构造器时，这种关联关系被自动建立起来，这种关联关系需要消耗非静态成员类实例的空间，并且增加了构造的时间开销。如果声明成员类不要求访问外围实例，就要始终把static修饰符放在它的声明中，使它成为静态成员类，而不是非静态成员类。如果省略了static修饰符，则每个实例都将包含一个额外的指向外围对象的引用。保存这份引用要消耗时间和空间，并且会导致外围实例在符合垃圾回收时却任然保留

非静态成员类的常见用法是实现各种集合的迭代器（iterator），私有静态成员类的常见用法是用来代表外围类的对象的组件。例如，考虑一个Map实例，它把key和value关联起来，许多Map实现的内部都有一个Entry对象
对应于Map中的咩歌键值对。虽然每个entry都与一个map关联，但是entry上的方法（getKey，getValue等）并不需要访问改Map，因此使用非静态成员来表示就很浪费，

匿名类

匿名类不同于Java程序设计语言中的其他任何语法单元。正如你所想象的，匿名类没有名字。它不是外围类的一个成员。它并不与其他的成员一起被声明，而是在使用的同时被声明和实例化。匿名类可以出现在代码中任何允许存在表达式的地方。当且仅当匿名类出现在非静态的环境中时，它才有外围实例。但是即使它们出现在静态的环境中，也不可能拥有任何静态成员。
匿名类的适用性受到诸多的限制。

• 除了在它们被声明的时候之外，是无法将它们实例化的，你不能执行instanceof测试，或者做任何需要命名类的其他事情。
• 你无法声明一个匿名类来实现多个接口，或者扩展一个类，并同时扩展类和实现接口。
• 匿名类的客户端无法调用任何成员，除了从它的超类型中继承得到之外。
• 由于匿名类出现在表达式当中，它们必须保持简短——大约10行或者更少些——否则会影响程序的可读性。

匿名类常见用法

• 第一种常见用法就是动态的创建函数对象（function object，见21条）。例如,第21条中-Arrays.sort方法调用，利用匿名的Comparator实例，根据一组字符串的长度对它们进行排序。
• 第二种常见的用法是创建过程对象（process object），比如Runnable、Thread或者TimerTask实例。
• 第三种常见的用法是在静态工厂内部（参见第18条中部分的intArrayAsList方法）。

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();//在另外的一个类的中不可以创建局部内部类的实例，只能在局部内部类中来创建。
    }
}