이펙티브 자바:: 아이템 20 <추상 클래스보다는 인터페이스를 우선하라>

Intro::

이펙티브 자바 정리본입니다.

결론

• 일반적으로 다중 구현용 타입으로는 인터페이스가 가장 적합합니다.

• 복잡한 인터페이스라면 구현하는 수고를 덜어주는 골격 구현을 함께 제공하는 방법을 고려해보면 좋습니다.

• 골격 구현은 가능한 한 인터페이스의 디폴트 메서드로 제공하여 그 인터페이스를 구현한 모든 곳에서 활용할하도록 하는 것이 좋습니다.
• 인터페이스에 걸려 있는 구현상의 제약 때문에 골격 구현을 추상 클래스로 제공하는 경우가 흔하기 때문입니다.

인터페이스와 추상클래스

인터페이스

디폴트 메서드

• 많은 인터페이스가 equals와 hashCode와 같은 Object의 메서드를 정의하고 있지만, 이들은 디폴트 메서드로 제공해서는 안됩니다.

코드 예시

public interface TestInterface {
    /**
     * public static final이 필드값의 기본이어서 생략 가능
     */
    public static final  int one = 1;
    int two = 2;

    default void defaultFunction() {
        System.out.println("default function");
    }

    /**
     * static void publicStaticFunction()와 동일
     */
    public static void publicStaticFunction() {
        System.out.println("publicStaticFunction");
    }

    private static void privateStaticFunction() {
        System.out.println("privateStaticFunction");
    }
}

package item20;

public class TestImpl implements TestInterface {
    public static void main(String[] args) {
        TestInterface t = new TestImpl();
        t.defaultFunction();

        TestInterface.publicStaticFunction();
//        private access
//        TestInterface.privateStaticFunction();
    }
}

추상 골격 구현 클래스

• 인터페이스로는 타입을 정의합니다.

• 필요하면 디폴트 메서드도 제공합니다.

• 골격 구현 클래스에서 나머지 메서드들까지 구현합니다.

// 코드 20-1 골격 구현을 사용해 완성한 구체 클래스 (133쪽)
public class IntArrays {
    static List<Integer> intArrayAsList(int[] a) {
        Objects.requireNonNull(a);

        // 다이아몬드 연산자를 이렇게 사용하는 건 자바 9부터 가능하다.
        // 더 낮은 버전을 사용한다면 <Integer>로 수정하자.
        return new AbstractList<>() {
            @Override public Integer get(int i) {
                return a[i];  // 오토박싱(아이템 6)
            }

            @Override public Integer set(int i, Integer val) {
                int oldVal = a[i];
                a[i] = val;     // 오토언박싱
                return oldVal;  // 오토박싱
            }

            @Override public int size() {
                return a.length;
            }
        };
    }

    public static void main(String[] args) {
        int[] a = new int[10];
        for (int i = 0; i < a.length; i++)
            a[i] = i;

        List<Integer> list = intArrayAsList(a);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

// 코드 20-2 골격 구현 클래스 (134-135쪽)
public abstract class AbstractMapEntry<K,V>
        implements Map.Entry<K,V> {
    // 변경 가능한 엔트리는 이 메서드를 반드시 재정의해야 한다.
    @Override public V setValue(V value) {
        throw new UnsupportedOperationException();
    }
    
    // Map.Entry.equals의 일반 규약을 구현한다.
    @Override public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<?,?> e = (Map.Entry) o;
        return Objects.equals(e.getKey(),   getKey())
                && Objects.equals(e.getValue(), getValue());
    }

    // Map.Entry.hashCode의 일반 규약을 구현한다.
    @Override public int hashCode() {
        return Objects.hashCode(getKey())
                ^ Objects.hashCode(getValue());
    }

    @Override public String toString() {
        return getKey() + "=" + getValue();
    }
}

질문

인터페이스를 구현한 클래스에서 해당 골격 구현을 확장한 private 내부 클래스를 정의하고, 각 메서드 호출을 내부 클래스의 인스턴스에 전달해 골격 구현 클래스를 우회적으로 사용할 수 있다는게 정확히 이해가 안간다.

interface A {
    void method1();
    void method2();
}

abstract class AbstractA implements A {
    @Override
    public void method1() {
        System.out.println("AbstractA method1");
    }

    // method2는 서브클래스에서 구현해야 함.
}

public class MyClass implements A {
    // Private 내부 클래스가 골격 구현을 상속받음
    private class PrivateInnerClass extends AbstractA {
        @Override
        public void method2() {
            System.out.println("PrivateInnerClass method2");
        }
    }

    // 내부 클래스의 인스턴스 생성
    private final PrivateInnerClass delegate = new PrivateInnerClass();

    @Override
    public void method1() {
        // method1 호출을 내부 클래스 인스턴스에 위임
        delegate.method1();
    }

    @Override
    public void method2() {
        // method2 호출을 내부 클래스 인스턴스에 위임
        delegate.method2();
    }
}

public class Main {
    public static void main(String[] args) {
        A instance = new MyClass();
        instance.method1();  // Prints "AbstractA method1"
        instance.method2();  // Prints "PrivateInnerClass method2"
    }
}

인터페이스에서 디폴트 메서드를 다 정의할 수 있는데 굳이 골격 추상 클래스로도 만들어 줘야하는 이유가 있을까???

References::