24. 멤버 클래스는 되도록 static으로 만들라

• 중첩 클래스(nested class)란?

  • 다른 클래스 안에 정의된 클래스

• 지켜야할 룰

  • 자신을 감싼 바깥 클래스에서만 쓰여야 하고, 아닐 경우 톱레벨 클래스로 정의하자.

• 중첩 클래스의 종류

  • 정적 멤버 클래스, 비정적 멤버 클래스, 익명 클래스, 지역 클래스

    • static member classes, nonstatic member classes, anonymous classes, local classes

  • 첫번째를 제외한 나머지는 중첩 클래스(inner class)

언제 어떤 중첩 클래스를 사용해야 할까?

중첩 클래스 1: static member classes

• Baeldung

  • 감싼 클래스의 instance가 아니라 그냥 class에 속한다

  • 내부 구현에 모든 종류의 접근 제어자를 가질 수 있다

  • 감싼 클래스의 static 키워드가 붙은 멤버에만 액세스할 수 있다

• 책에 따르면,

  • 바깥 클래스의 private 멤버에도 접근할 수 있다는 점만 제외하고는 일반 클래스와 똑같다

  • 바깥 클래스와 함께 쓰일때 유용한 도우미 클래스로 쓰인다.

    • 아이템 34 예시, Calulator의 Operation enu 중첩 클래스

  • 개념상 중첩 클래스의 인스턴스가 바깥 인스턴스와 독립적으로 존재할 수 있다면 static 멤버 클래스로 만들어야 한다. non-static 멤버 클래스는 바깥 인스턴스 없이는 생성할 수 없기 때문이다.

    • 궁금

      • 위에서 "자신을 감싼 바깥 클래스에서만 쓰여야 하고, 아닐 경우 톱레벨 클래스로 정의하자." 라고 하였는데...

      • 바깥 인스턴스와 독립적으로 움직인다는 것은 감싼 클래스 이외에 쓰일때도 사용할 수 있다는 건가?

public class Enclosing {
    private static int x = 1;

    public static class StaticNested {
        private void run() {
            System.out.println(x); // private 접근 가능
        }
    }
}

public static void main(String[] args) {
    // Enclosing 클래스의 객체가 없어도 StaticNested 클래스의 객체 생성이 가능
    Enclosing.StaticNested nested = new Enclosing.StaticNested();
    nested.run();
}

종류 2: non-static member classes

• Baeldung

  • 감싼 클래스의 인스턴스 연결된다

  • 감싼 클래스의 모든 멤버들에 접근할 수 있다 (static non-static 상관 x)

  • 안에서 non-static 멤버만 가질 수 있다

    • 근데, 버전 16 부터는 가능한듯..

public class Outer {
    public class Inner {
        public static String str; // -> static 은 안됨 (컴파일 에러)
        private static void doSth1(){ // -> static 은 안됨 (컴파일 에러)
        }
        // ...
    }
}

public static void main(String[] args) {
    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner() // 생성시간 오래걸린다?
        // static을 생략할 시에 바깥 인스턴스로의 숨은 외부 참조를 가지게 되고 가비지 컬렉션 등의 문제가 생길 수 있다.
}

nonstatic 사용 예시

• 어댑터를 정의할 때 자주 쓰인다.

• 즉, 어떤 클래스의 인스턴스를 감싸 마치 다른 클래스의 인스턴스처럼 보이게 하는 뷰로 사용하는 것이다.

  • 예를 들어, Map 의 구현체들 자신의 컬렉션 뷰를 구현할 때 비정적 멤버 클래스를 사용

public class MySet<E> extends AbstractSet<E> {
    @Override 
    public Iterator<E> iterator() {
        return new MyIterator();
    }
    private class MyIterator implements Iterator<E> {
        ...
    }
}

public static void main(String[] args) {
    MySet<String> set = new MySet<>();
    set.add("a");
    set.add("b");

    while(set.iterator().hasNext()){
        System.out.println(set.iterator().next());
    }
}

자바 HashMap 코드 예시

public static void main(String[] args) {
    Map<String,String> map = new HashMap<>();
    map.put("a","1");
    map.put("b","2");

    System.out.println(map.keySet());
    System.out.println(map.values());

    for (Map.Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + ":" + entry.getValue());
    }

    // 결과
    // [a, b]
    // [1, 2]
    // a:1
    // b:2
}

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    //...
    public Set<K> keySet() {
        Set<K> ks = keySet;
        if (ks == null) {
            ks = new KeySet();
            keySet = ks;
        }
        return ks;
    }

    final class KeySet extends AbstractSet<K> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<K> iterator()     { return new KeyIterator(); }
        public final boolean contains(Object o) { return containsKey(o); }
        public final boolean remove(Object key) {
            return removeNode(hash(key), key, null, false, true) != null;
        }
        public final Spliterator<K> spliterator() {
            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super K> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (Node<K,V> e : tab) {
                    for (; e != null; e = e.next)
                        action.accept(e.key);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    } 
    
    public Collection<V> values() {
        Collection<V> vs = values;
        if (vs == null) {
            vs = new Values();
            values = vs;
        }
        return vs;
    }

    final class Values extends AbstractCollection<V> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<V> iterator()     { return new ValueIterator(); }
        public final boolean contains(Object o) { return containsValue(o); }
        public final Spliterator<V> spliterator() {
            return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super V> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (Node<K,V> e : tab) {
                    for (; e != null; e = e.next)
                        action.accept(e.value);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }

    public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }
        public final boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Node<K,V> candidate = getNode(hash(key), key);
            return candidate != null && candidate.equals(e);
        }
        public final boolean remove(Object o) {
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Object value = e.getValue();
                return removeNode(hash(key), key, value, true, true) != null;
            }
            return false;
        }
        public final Spliterator<Map.Entry<K,V>> spliterator() {
            return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (Node<K,V> e : tab) {
                    for (; e != null; e = e.next)
                        action.accept(e);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
    }
    //...
}

종류 3: anonymous classes

• 자바 7에서 람다를 지원하기 전에는 즉석에서 작은 함수나 객체 처리를 하기 위해 주로 사용했었지만 이제 람다에게 자리를 내어 주었다 (item42)

• 익명 클래스는 바깥 클래스의 멤버가 아니다. 멤버와 달리 쓰이는 시점에 선언과 동시에 인스턴스가 만들어 진다

abstract class SimpleAbstractClass {
    abstract void run();
}

public class AnonymousInnerUnitTest { 
    @Test
    public void whenRunAnonymousClass_thenCorrect() {
        SimpleAbstractClass simpleAbstractClass = new SimpleAbstractClass() {
            void run() {
                // method implementation
            }
        };
        simpleAbstractClass.run();
    }
}

자바 예시

public static void main(String[] args) {
    Queue<String> pq = new PriorityQueue<>(new Comparator<String>() {
        @Override
        public int compare(String str1, String str2) {
            return str1.compareTo(str2);
        }
    });

    pq.offer("cc");
    pq.add("aa");
    pq.offer("bb");

    while(!pq.isEmpty()){
        System.out.println(pq.poll());
    }

    // 결과
    // aa
    // bb
    // cc

    // 자바 8 이후 람다 
    Queue<String> pq = new PriorityQueue<>((str1, str2) -> str1.compareTo(str2));
}

종류 4: local classes

• 가장 드물게 사용된다.

• scope block 이나 메서드 안에 들어간 클래스이다

public class NewEnclosing {

    void run() {
        class Local {

            void run() { // 접근제한자 없음
                // method implementation
            }
        }
        Local local = new Local();
        local.run();
    }
}

public static void main(String[] args) {
    NewEnclosing newEnclosing = new NewEnclosing();
    newEnclosing.run();
}

질문

• MyCsvBuilder 안에서만 말고 이외 클래스에서 enum 클래스 값들을 접근해서 사용해도 되는가?

// 리팩토링 하려고 한 코드
public class MyCsvBuilder {
    static enum Header {
        HEADER1("header 1"),
        HEADER2("header 2"),
        HEADER3("header 3");

        String name;
        
        Header(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }
}

// 외부 클래스의 메서드
public void doSth() {
    System.out.println(Header.HEADER1.getName()); // header 1
    System.out.println(Header.HEADER2.getName()); // header 2
    System.out.println(Header.HEADER3.getName()); // header 3
}

참고자료

• https://www.baeldung.com/java-nested-classes

• Java inner class and static nested class