[이펙티브 자바] 맴버 클래스는 되도록 static으로 만들라

중첩 클래스

중첩 클래스 : 다른 클래스 안에 정의된 클래스를 말함. 중첩 클래스는 자신을 감싼 클래스에서만 사용되어야 한다. 만약 다른 쓰임새가 있다면 톱 레벨 클래스로 만들어야 함.

public class A {

  private class B{
   ...
  }

}

중첩 클래스의 종류 : 정적 맴버 클래스, (비정적) 맴버 클래스, 익명 클래스, 지역 클래스

정적 맴버 클래스를 제외한 나머지는 내부 클래스에 해당됨. 

 

정적 맴버 클래스

//정적 맴버 클래스
public class A {

  private static class B{
   ...
  }

}

특징

1. 정적 맴버 클래스는 다른 클래스 안에 선언되고 바깥 클래스의 private맴버에도 접근 할 수 있다는 점을 제외하면 일반 클래스와 같다.

2. 정적 맴버 클래스는 다른 정적 맴버와 같이 접근 지정자 규칙이 적용된다. ex) private

3. 정적 맴버 클래스가 바깥 클래스와 같이 사용될 때 유용한 public 도우미 클래스로 사용된다.

ex) Caculator의 클라이언트에서 Caculator.Operation.PLUS, Caculator.Opertation.MINUS와 같은 형태로 원하는 연산을 참조할 수있다.

public class Calculator{

  enum Operation{
    PLUS,
    MINUS
  }
  
}

 public static void main(String[] args){
    Calculator calculator new Calculator();
    Calculator.Operation.PLUS; //연산 방식을 꺼내 사용할 수 있음
 }

 

비정적 맴버 클래스

//비정적 맴버 클래스
public class A {

  private class B{
   ...
  }

}

특징

1. 비정적 맴버 클래스의 인스턴스는 바깥 클래스의 인스턴스와 암묵적으로 연결 된다. 비 정적 맴버 클래스의 인스턴스 메서드에서 정규화된 this를 사용해 바깥 인스턴스의 메서드를 호출하거나 바깥 인스턴스의 참조를 가져올 수 있다.

 

*정규화된 this : 클래스명.this 형태로 바깥 클래스의 이름을 명시하는 것 

public class A {
  int a;
  
  private class B{
    int b = A.this.a; //정규화된 this
  }
  
}

 

2. 개념상 중첩 클래스의 인스턴스가 바깥 인스턴스와 독립적으로 존재할 수 있다면 정적 맴버 클래스로 만들어야 한다. 비정적 맴버 클래스는 바깥 인스턴스 없이는 생성할 수 없다.

public class A {

  public class B{}

  public static void main(String[] args) {
    B b = new B(); //불가
  }
}

public class A {

  public class B{}
  
  public static void main(String[] args) {
    A a = new A();
    A.B b = a.new B(); //이건 가능
  }
}

public class A {

  public static class B{}

  public static void main(String[] args) {
    B b = new B(); //가능
  }
}

3. 인스턴스와 바깥 인스턴스와의 관계는 맴버 클래스가 인스턴스화 될 때 확립되며 더이상 변경 할 수없다. 이 관계는 바깥 클래스의 인스턴스 메서드에서 비정적 맴버 클래스의 생성자를 호출 할 때 자동으로 만들어지게 하는게 보통이지만 드물게는 직접 바깥 인스턴스 클래스.new MemberClass(args)를 호출해 수동으로 만들기도 한다. 

public class A {
  private B b;
  private int num;
  
  public A(){
    this.b = new B(num);
  }
  
  public class B{
    int num;
    public B(int num){
    	this.num = num;
  }

  public static void main(String[] args) {
     A b = new  A();
  }
}

public class A {
  private B b;
  private int num;
  
  public class B{
    int num;
    public B(int num){
    	this.num = num;
  }
  
  public static void main(String[] args) {
    A a = new A();
    a.num = 5;
    a.new B(num); 
  }
}

이 관계 정보는 비정적 맴버 클래스의 인스턴스 안에 만들어져 메모리 공간을 차지하며 생성 시간도 더 걸린다.

=> A인스턴스가 B인스턴스를 포함하고 있어 생성 시간 및 메모리 공간을 차지한다는 의미 같음

 

4. 비정적 맴버 클래스는 어댑터를 정의할 때 자주 쓰인다. 즉, 어떤 클래스의 인스턴스를 감싸 마치 다른 클래스의 인스턴스 처럼 보이게하는 뷰로 사용한다.

ex) Map인터페이스의 구현체는 보통(keySet, entrySet, values 메서드가 반환하는) 자신의 컬렉션 뷰를 구현할 때 비정적 멤버 클래스를 사용한다.

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

 

참조를 고려하면 static이 낫다.

맴버 클래스에서 바깥 인스턴스에 접근할 일이 없다면 무조건 static을 붙여서 정적 맴버 클래스로 만들어야함. static을 생략하면 숨은 외부 참조를 갖게 됨. 이 참조를 저장하려면 시간과 공간이 소비되며, 더 심각한 문제는 가비지 컬렉션이 바깥 클래스의 인스턴스를 수거하지 못하는 누수가 생길 수 있음. 참조가 눈에 보이지 않으니 문제의 원인을 찾기 어려워 때때로 심각한 상황을 초래하기도 한다.

 

private 정적 맴버 클래스는 흔히 바깥 클래스가 표현하는 객체의 한 부분을 나타낼 때 쓴다. 키와 값을 매핑시키는 Map인스턴스를 생각해보자 많은 Map구현체는 각각의 키-값 쌍을 표현하는 엔트리 객체들을 가지고 있다. 모든 엔트리가 맵과 연관되어 있지만 엔트리의 메서드들(getKey, getValue, setValue)은 Map을 직접 사용하지 않는다. 따라서 엔트리를 비정적 멤버 클래스로 표현하는 것은 낭비고 private 정적 맴버 클래스가 가장 알맞다.

 

=> static으로 Node를 사용하면 multi thread 환경에서 thread safe하지 않겠다고 생각이 들었는데, 실제로 HashMap은 그렇다. 하지만 한 가지 오해가 있었다. static class는 우리가 알던 static 메서드나 맴버와 다르다. 메모리에 하나만 올라가는 인스턴스가 아니다. 

#HashMap Class
public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

...

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

엔트리를 선언한 때 static을 제거한 경우

맵은 여전히 동작하지만 모든 엔트리가 바깥 맵으로 참조를 갖게되어 시간과 공간이 낭비된다.

맴버 클래스가 공개된 클래스의 public static, protected static이라면 향후 릴리스에서 static을 붙인 경우 기존의 구현된 부분과 하위 호환성에서 문제가 생김.

 

익명 클래스

public abstract class Action{
	public abstract void exec();

}

public class MyAction{
    Action action = new Action() { 
            @Override
            public void exec(){
          	System.out.println("exec"); 
            }
        };
}

특징

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

2. 코드의 어디서든 만들 수 있다. 그리고 오직 비정적인 문맥에서 사용될 때만 바깥 클래스의 인스턴스를 참조 할 수 있다. 정적 문맥에서라도 상수 변수 이외의 정적 맴버는 가질 수 없다. 즉, 상수 표현을 위해 초기화된 final 기본 타입과 문자열 필드만 가질 수 있다.

public class A {
  int a = 1;
  public C getC(){
    return new C(){
      @Override
      public void run() {
        a = 2;// a가능
      }
    };
  }

}

public class A {
  int a = 1;
  public static C getC(){
    return new C(){
      @Override
      public void run() {
        a = 2;// a가 final이 아니라 불가
      }
    };
  }

}

 

익명 클래스는 응용하는데 제약

1. 선언한 지점에서만 인스턴스를 만들 수 있고, instanceof 검사나 클래스의 이름이 필요한 작업은 수행할 수 없다.

2. 여러 인터페이스를 구현할 수 없고, 인터페이스를 구현하는 동시에 다른 클래스를 상속 할 수도 없다. 

3. 익명 클래스를 사용하는 클라이언트는 그 익명클래스의 상위 타입에서 상속한 맴버 외에는 호출 할 수 없다.

public class A {

  private int a = 1;
  private C c = new C() {
    int k = 1;
    
    @Override
    public void run() {}
  };
  
  public  void test(){
    int temp = c.k//오류
  }

}

4. 익명 클래스는 표현식 중간에 등장하므로 짧지 않으면 가독성이 떨어진다.

 

자바가 람다를 지원하기 전에 즉성에서 작은 함수 객체나 처리 객체를 만드는데 익명 클래스를 주로 사용했다. 익명 클래스의 또 다른 주 쓰임은 정적 팩터리 메서드를 구현할 때다

public class A {

  public static C getC(){
    return new C(){
      @Override
      public void run() {}
    };
  }

}

 

지역 클래스

public class A {

  public void getBInstance() {
    
    class B {

      private B() {
      }
    }
    
    B b = new B();
  }
  
}

특징

1. 지역 클래스는 네 가지 중첩 클래스 중 가장 드물게 사용된다.

2. 지역 클래스는 지역 변수를 선언 할 수 있는 곳이면 실질적으로 어디서든 선언 할 수있고 유효범위도 지역변수와 같다.

3. 맴버 클래스처럼 이름이 있고 반복해서 사용할 수 있다. 익명 클래스처럼 비정적 문맥에서 사용될 때만 바깥 인스턴스를 참조할 수 있으며, 정적 맴버는 가질수 없고 가독성을 위해 짧게 작성해야한다.

 

결론

중첩 클래스는 네가지가 있다. 각각 쓰임이 다르다.

1. 메서드 밖에서도 사용해야하거나 메서드 안에 정의하기에 너무 길다면 맴버 클래스로 만든다.

2. 맴버 클래스의 인스턴스 각각이 바깥 인스턴스를 참조한다면 비정적으로, 그렇지 않다면 정적으로 만들자.

3. 중첩 클래스가 한 메서드 안에서만 쓰이면서 그 인스턴스를 생성하는 지점이 단 한곳이고 해당 타입으로 쓰기에 적합한 클래스나 인터페이스가 이미 있다면 익명 클래스로 만들고, 그렇지 않으면 지역 클래스로 만들자.