嵌套类（nested class）是指被定义在另一个类的内部的类。嵌套类的目的应该只是为它的外围类（enclosing class）提供服务。如果嵌套类将来可能会用于其他某个环境中，它就应该是顶层类，而不是被设计为嵌套类。嵌套类分如下四种：
静态成员类(static member class)、非静态成员类(nostatic member class)、匿名类(anonymous class)和局部类（local class）。
除了静态成员类之外，其他三种都被称为内部类（Inner Class）。静态成员类和非静态成员类称为成员类，后两个称为非成员类。
静态成员类
静态成员类是最简单的一种嵌套类，最好把它看作是普通的类，只是碰巧被声明在另一个类的内部而已，它可以访问外围类的所有成员(静态)，包括那些声明为私有的成员。静态成员类是外围类的一个静态成员，与其他的静态成员一样，也遵循同样的可访问性规则。如果它被声明为私有的，它就只能在外围类的内部才能被访问。
静态成员类的一种常见用法是作为公有的辅助类，仅当它与外部类一起使用时才有意义。
例如String类的CaseInsensitiveComparator比较器，该静态成员类提供了String类型忽略字符大小写的比较方法。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
{
public static final Comparator<String> CASE_INSENSITIVE_ORDER
= new CaseInsensitiveComparator();
private static class CaseInsensitiveComparator
implements Comparator<String>, java.io.Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 8575799808933029326L;
public int compare(String s1, String s2) {
int n1 = s1.length();
int n2 = s2.length();
int min = Math.min(n1, n2);
for (int i = 0; i < min; i++) {
char c1 = s1.charAt(i);
char c2 = s2.charAt(i);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
// No overflow because of numeric promotion
return c1 - c2;
}
}
}
}
return n1 - n2;
}
}
......
}
public class StaticMemberClassTest {
public static void main(String[] args) {
String[] strs={"ab","Ab","CC","abc"};
Arrays.sort(strs);//默认排序规则（大小写敏感）
for(String s:strs){
System.out.print(s+" ");
}
System.out.println();
Arrays.sort(strs,String.CASE_INSENSITIVE_ORDER);//大小写不敏感的排序规则
for(String s:strs){
System.out.print(s+" ");
}
}
}Ab CC ab abc
Ab ab abc CC
再比如HashMap中的静态成员类Entry，该类代表哈希映射表的键值对，与他的外围类一起使用。
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
final int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
public final String toString() {
return getKey() + "=" + getValue();
}
/**
* This method is invoked whenever the value in an entry is
* overwritten by an invocation of put(k,v) for a key k that's already
* in the HashMap.
*/
void recordAccess(HashMap<K,V> m) {
}
/**
* This method is invoked whenever the entry is
* removed from the table.
*/
void recordRemoval(HashMap<K,V> m) {
}
}
....
}
public class EntryStaticMemberClass {
public static void main(String[] args) {
int[] nums={1,3,3,2,1,5,4,3,8,2};
Map<Integer,Integer> countMap=new HashMap<Integer,Integer>();
for(int i:nums){
if(countMap.get(i)==null){
countMap.put(i, 1);
}else{
countMap.put(i, countMap.get(i)+1);
}
}
for(Entry<Integer, Integer> entry:countMap.entrySet()){
System.out.println("元素："+entry.getKey()+" 出现了："+entry.getValue()+"次");
}
}
}元素：1 出现了：2次
元素：2 出现了：2次
元素：3 出现了：3次
元素：4 出现了：1次
元素：5 出现了：1次
元素：8 出现了：1次
非静态成员类
从语法上将，静态成员类和非静态成员类之间唯一的区别是，静态成员类的声明中包含修饰符static。尽管语法上非常相似，但是这两种嵌套类有很大的不同。非静态成员类的每个实例都隐含着与外围类的一个实例相关联。在非静态成员类的实例方法内部，可以调用外围实例上的方法，或者获取外围实例的引用。
如果嵌套的的实例可以在外围类的实例之外独立存在，即不需要与外围类的特定实例关联，这个嵌套类应该声明为静态成员类。
在没有外围实例的情况下，要想创建非静态成员类的实例是不可能的。当非静态成员类的实例被创建的时候，它和外围实例之间的关联关系就随之建立起来了。而且这种关联关系以后不会被修改。通常情况下，在外围类的某个实例方法的内部调用非静态成员类的构造器时，这种关联关系就建立起来了。
非静态成员类的一种常见的用法是定义一个Adapter(适配器)，提供类的各种视图。例如，Map接口的实现往往使用非静态成员类来实现它们的集合视图（Collection View），这些集合视图由Map的keySet、entrySet和values方法返回。
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{
// Views
transient volatile Set<K> keySet = null;//父类AbstractMap中
transient volatile Collection<V> values = null;//父类AbstractMap中
private transient Set<Map.Entry<K,V>> entrySet = null;
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}
private final class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
public Collection<V> values() {
Collection<V> vs = values;
return (vs != null ? vs : (values = new Values()));
}
private final class Values extends AbstractCollection<V> {
public Iterator<V> iterator() {
return newValueIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
HashMap.this.clear();
}
}
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<K,V> e = (Map.Entry<K,V>) o;
Entry<K,V> candidate = getEntry(e.getKey());
return candidate != null && candidate.equals(e);
}
public boolean remove(Object o) {
return removeMapping(o) != null;
}
public int size() {
return size;
}
public void clear() {
HashMap.this.clear();
}
}
....
}
public class NoStaticMemberClassTest {
public static void main(String[] args) {
int[] nums={1,3,3,2,1,5,4,3,8,2};
Map<Integer,Integer> countMap=new HashMap<Integer,Integer>();
for(int i:nums){
if(countMap.get(i)==null){
countMap.put(i, 1);
}else{
countMap.put(i, countMap.get(i)+1);
}
}
System.out.print("键集合：");
for(Integer i:countMap.keySet()){
System.out.print(i+" ");
}
System.out.println();
System.out.print("值集合：");
for(Integer i:countMap.values()){
System.out.print(i+" ");
}
System.out.println();
System.out.println("建值对集合：");
for(Entry<Integer, Integer> entry:countMap.entrySet()){
System.out.println("建："+entry.getKey()+" 值："+entry.getValue());
}
}
}键集合：1 2 3 4 5 8
值集合：2 2 3 1 1 1
建值对集合：
建：1 值：2
建：2 值：2
建：3 值：3
建：4 值：1
建：5 值：1
建：8 值：1
此外，Set和List这种集合接口的实现往往也使用非静态成员类来实现它们的迭代器（Iterator）。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned = null;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
......
}
public class IteratorTest {
public static void main(String[] args) {
LinkedList<Integer> arr=
new LinkedList<Integer>(Arrays.asList(1,2,3,4,5,6));
Iterator iter = arr.iterator();
while(iter.hasNext()){
System.out.print((Integer) iter.next()+" ");
}
System.out.println();
iter = arr.descendingIterator();
while(iter.hasNext()){
System.out.print((Integer) iter.next()+" ");
}
}
}1 2 3 4 5 6
6 5 4 3 2 1
私有静态成员类
私有静态成员类的一种常见用法就是来代表外围类的组件。例如，Map中的Entry,Entry代表键值对（key-value）。虽然每个Entry都与一个Map关联，但是entry上的方法并不需要访问该Map。因此，使用非静态成员来表示Entry是非常浪费的，而私有的静态成员类是最佳的选择。如果不小心漏掉了Entry声明中的static修饰符，该map仍然可以工作，但是每个Entry中将会包含一个指向该Map的引用，这样就浪费了空间和时间。因此，如果成员类不需要访问外围类实例，我们应该适用静态成员类，而不是非静态成员类。
匿名类
匿名类没有名字，匿名类在使用的同时被声明和初始化，匿名类可以出现在任何允许存在表达式的地方。匿名类的一种常见用法是动态的创建函数对象。
例如，利用匿名的Comparator实例，根据字符串长度对字符串数组进行排序。
public class AnonymousClassTest {
public static void main(String[] args) {
String[] strs={"ab","aaaa","CC","abc"};
Arrays.sort(strs,new Comparator<String>(){
public int compare(String s1,String s2){
return s1.length()-s2.length();
}
});
for(String s:strs){
System.out.print(s+" ");
}
}
}ab CC abc aaaa
另一种常见用法是创建过程对象，比如Runnable、Thread实例等。
public class AnonymousClassTest {
static class Anonymous implements Runnable{
@Override
public void run(){
System.out.println("do something only once");
}
}
public static void main(String[] args) {
//常规方式（定义一个静态成员类，也可以单独定义）
new Thread(new Anonymous()).start();
//实现接口的匿名类
new Thread(new Runnable(){
@Override
public void run(){
System.out.println("do something only once");
}
}).start();
//继承基类的匿名类
new Thread(){
@Override
public void run(){
System.out.println("do something only once");
}
}.start();
}
}第三种常见用法就是静态工厂方法的内部。
public class ListFactory {
//将int[]转换成的List<Integer>的静态工厂方法
static List<Integer> intArrayAsList(final int[] a ){
if(a==null){
throw new NullPointerException();
}
return new AbstractList<Integer>(){
@Override
public Integer get(int i){
return a[i];
}
@Override
public Integer set(int i,Integer value){
int oldValue=a[i];
a[i]=value;
return oldValue;
}
@Override
public int size(){
return a.length;
}
} ;
}
public static void main(String[] args) {
int[] a={1,2,3,45,2,1};
List<Integer> list=ListFactory.intArrayAsList(a);
Collections.sort(list);
for(int i:list){
System.out.print(i+" ");
}
}
}匿名类的适用性受到诸多的限制：
1、你无法声明一个匿名类来同时扩展基类和实现接口。匿名类要么实现一个接口要么继承一个父类。
2、由于匿名类出现在表达式中，它们必须保持简短，否则会影响程序的可读性。
3、除了声明它们的地方，你无法再次对它们实例化。
局部类
局部类是四种嵌套类中用得最少的。在任何“可以声明局部变量”的地方，都可以声明局部类，并且局部类也遵循同样的作用域规则，同样要求必须简短。
嵌套类的选择
四种不同的嵌套类，都有各自的适用场景。
如果一个嵌套类需要在单个方法之外仍然是可见的，或者它太长，不适合放在方法内部，就应该适用成员类（静态/非静态）。
如果成员类的每个实例都需要一个指向其外围实例的引用，就要设计为非静态成员类。否则，设计为静态成员类。
假设，这个嵌套类属于单个方法的内部，如果你只需要在一个地方创建实例，并且已经有了一个预知的类型（类或接口）可以说明这个类的特征，就要把它设计为匿名类。否则，就做成局部类。
为什么需要嵌套类
咋一看，嵌套类就像是一种代码隐藏机制，我们将嵌套类置于外围类的内部，从而允许你把一些逻辑相关的类组织在一起，并控制嵌套类的可见性。但是，嵌套类远非如此。
1、恰当的使用匿名类和局部类，可以让代码更加清晰而优雅。
2、我们可以利用私有静态成员类，将外围类的具体实现以及内部结构封装在内部，增加内聚度。（Map的Entry）
3、非静态成员类，每个非静态成员类的实例可以直接操作相关的外围类实例，不同的非静态成员类可以提供外围类的不同窗口（Iterator）。
4、每个非静态成员类都能独立的继承父类和实现接口，使得在单继承体系的Java语言中实现“多继承”变得可能。
参考：
《java编程思想》
《Effective Java》
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
