java开发——静态成员类和非静态成员类如何选择？

区别：

是否有static修饰内部class

原则：

优先考虑使用静态成员类

 

相比于非静态成员类，静态成员类的优势有：

1、内嵌类的实例可以独立于外围类的实例而存在。

2、内嵌类和外围类的实例之间没有关联，减少时间和空间的开销。

3、当外围类实例符合垃圾回收时，可以被回收掉。如果使用的是非静态成员类则不行。

 

什么情况下使用非静态成员类呢？

如果内嵌类的实例需要用到外围类实例的属性或方法的时候，使用非静态成员类。

 

下面是举例：

例子1：String的compareToIgnoreCase方法。源码如下：

public int compareToIgnoreCase(String str) {
     return CASE_INSENSITIVE_ORDER.compare(this, str);
}

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

可以看出，CaseInsensitiveComparator这个私有静态内部类的功能只有一个，就是提供一个忽略大小的字符串比较的功能，并不需要使用到外围类String对象的属性或者方法（s1,s2是通过参数传进来的，别弄混淆了哦）。所以，CaseInsensitiveComparator设计为静态的非常合理。

 

例子2：ArrayList的迭代器方法——iterator()

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
        //这里使用到了：this.size
        protected int limit = ArrayList.this.size;

        int cursor;       
        int lastRet = -1; 
        //这里使用到了：modCount，modCount是ArrayList的成员属性。
        int expectedModCount = modCount;

     
        public void remove() {
                //这里用到了：this.remove();
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
                limit--;
        }
}

 可以看出，class Itr使用到了外围类的属性和方法，符合使用非静态成员类的条件，所以此处不应该加static修饰class。因为没有ArrayList对象，独立于ArrayList对象的new Itr()没有意义！（静态成员类优势的第一条）

例子1中的CASE_INSENSITIVE_ORDER，是可以String.CASE_INSENSITIVE_ORDER.comare()直接使用的，不需要依赖String对象。

 

参考书籍：Effective Java（第2版）

如果对您有用的话赞一下呗！谢谢谢谢~