[EffectiveJava] item20 - 추상 클래스보다는 인터페이스를 우선시하라

06 Apr 2023

추상 클래스보다는 인터페이스를 우선하라.

자바의 다중 구현 메커니즘

자바에서는 인터페이스와 추상 클래스 이렇게 두가지를 제공하고 있으며, 자바 8부터는 인터페이스도 디폴트 메서드(default method)를 제공해 두 메커니즘 모두 인스턴스 메서드를 구현형태로 제공 할 수 있게 되었다.

인터페이스와 추상 클래스의 차이

인터페이스는 선언한 메서드를 모두 정의하고 그 일반 규약을 잘 지킨 클래스라면 다른 어떤 클래스를 상속했든 같은 타입으로 취급된다. 반면에, 추상 클래스는 정의한 타입을 구현하는 클래스는 반드시 추상 클래스의 하위 클래스가 되어야 한다. 즉, 추상 클래스는 새로운 타입을 정의하는데 커다란 제약을 안게 된다.

또한 인터페이스는 기존 클래스에도 손쉽게 새로운 인터페이스를 구현해 넣을 수 있는 장점이 있다.

믹스인(mixin) 정의

인터페이스는 믹스인(mixin)정의에 이점을 가지고 있다. 믹스인이란? 클래스가 구현할 수 있는 타입으로, 믹스인을 구현한 클래스에 원래의 ‘주된 타입’외에도 특정 선택적 기능를 제공한다고 선언하는 효과를 준다.

말이 어려우니 예시를 들어보자.

Comparable는 기존의 Class에 상속하여, 객체간의 순서를 정의해줄수 있는 역할을 한다.

class Employee implements Comparable<Employee>
{
    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Employee o) {
        return this.age - o.getAge();
    }
}

Employee 객체에 Comparable를 상속받아 Employee라는 타입은 해치지 않고 나이 순서대로 정렬이 되도록 ‘선택적 기능’을 추가한 모습을 볼 수 있다.

하지만, 추상 클래스로는 믹스인을 정의할 수 없다. 위 코드와 같은 범용성이 떨어진다.

계층구조가 없는 타입 프레임 워크

인터페이스로는 계층 구조가 없는 타입 프레임 워크를 만들 수 있다. 객체지향에서는 사물을 객체로 가져와 타입을 계층적으로 비교하고 있다.

하지만 현실에는 계층을 엄격히 구분하기 어려운 개념이 있는데, 예를 들면 가수(Singer)와 작곡가(Songwriter)가 그 예시이다.

해당 타입을 인터페이스로 구현해본다면 아래와 같을 것이다.

public interface Singer {
    AudioClip sing(Song s);
}

public interface Songwriter {
    Song compose(int chartPosition);
}

하지만 세상에는 스스로 작곡을 하며 노래를 부르는 가수가 있다. 이러한 개념을 코드로 표현한다면 어떻게 될까?

public interface SingerSongwriter extends Singer, Songwriter {
    AudioClip strum();
    void actSensitive();
}

Singer와 Songwriter의 타입을 인터페이스로 지정했다면, 이와 같은 타입을 구현해도 문제가 되지 않는다.

심지어 둘의 기능을 모두 확장하고 새로운 메소드를 추가하여 제3의 인터페이스를 정의할 수도 있다.

만약 이와같은 구조를 클래스로 만들려면 가능한 조합 전부를 각각의 클래스로 정의하다 보니, 자칫 매개변수 타입만 다른 메서드들을 수없이 많이 가진 거대한 클래스로 변모할 수도 있다.

래퍼클래스와 인터페이스

래퍼 클래스 관용구와 함께 사용하면 인터페이스는 기능을 향상시키는 안전하고 강력한 수단이 된다.

타입을 추상클래스로 정의해두면 그 타입에 기능을 추가하는 방법은 상속뿐이다. 상속해서 만든 클래스는 래퍼클래스보다 활용도가 떨어지고 깨지기는 더 쉽다.

인터페이스와 추상 골격 구현

인터페이스는 추상 골격 구현(skeletal implementation) 클래스를 함께 제공하는 식으로 인터페이스와 추상 클래스의 장점을 모두 취하는 방법도 있다.

인터페이스로는 타입을 정의하고, 필요하면 디폴트 메서드 몇개도 함께 제공한다. 그리고 골격 구현 클래스는 나머지 메서드를 구현한다.

이렇게 해두면 단순히 골격 구현을 확장하는 것만으로 이 인터페이스를 구현하는데 필요한일이 대부분 완료된다. 이러한 패턴을 템플릿 메서드 패턴이라고 한다.

관례상 인터페이스의 이름이 Interface라면 그 공격 구현 클래스의 이름은 AbstractInterface로 짓는다.

좋은 예시로 컬렉션 프레임 워크의 AbstractCollection, AbstractSet, AbstractList, AbstractMap 각각이 바로 핵심 컬렉선 인터페이스의 골격 구현이다.

List를 예시로 들어본다면, List구현체를 반환하는 정적 팩터리 메서드로, AbstractList 골격 구현으로 활용 되었다.

static List<Integer> intArrayAsList(int[] array){
    Objects.requireNonNull(array);

    return new AbstractList<>() {
        @Override
        public Integer get(final int i) {
            return array[i];
        }

        @Override
        public Integer set(final int i, final Integer e) {
            int oldValue = array[i];
            array[i] = e;
            return oldValue;
        }

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

List 구현체가 우리들에게 제공하는 기능들을 생각하면, 이 코드는 골격 구현의 좋은 예시라고 할 수 있다.

골격 구현을 확장하는 것으로 인터페이스 구현이 거의 끝나지만, 꼭 이렇게 해야 하는것은 아니다. 구조상 골격 구현을 확장하지 못하는 처지라면 인터페이스를 직접 구현해야한다.

골격 구현 클래스

추상클래스를 이용한 골격 구현 클래스는 상대적으로 쉽다.

인터페이스를 잘 살펴 다른 메서드들의 구현에 사용되는 기반 메서드들을 선정한다. 이 기반 메서드들은 골격 구현에서는 추상 메서드가 된다.
그다음으로 기반 메서드들을 사용해 직접 구현할 수 있는 메서드를 모두 디폴트 메서드로 제공한다. (단, equals와 hashCode 같은 Object의 메서드는 디폴트 메서드로 제공하면 안된다.)
기반 메서드나 디폴트 메서드로 만들지 못한 메서드가 남아있다면, 이 인터페이스를 구현하는 골격 구현 클래스를 하나 만들어 남은 메서드들을 작성해 넣는다. (공격 구현 클래스에는 필요하면 public 이 아닌 다른 필드와 메서드를 추가해도 된다.)

간단한 예시를 들어보자. Map.Entry의 인터페이스의 골격 구현 클래스 AbstractMapEntry를 생성해보고자 한다.

public abstract class AbstractMapEntry<K, V> implements Map.Entry<K, V> {

    /** 변경 가능한 엔트리는 이 메서드를 반드시 재정의 해야 한다. */
    @Override
    public V setValue(final V value) {
        throw new UnsupportedOperationException();
    }

    /** Map.Entry.equals의 일반 규약을 구현한다. */
    @Override
    public boolean equals(final Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<?, ?> entry = (Map.Entry) o;
        return Objects.equals(entry.getKey(), getKey())
                && Objects.equals(entry.getKey(), getValue());
    }

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

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

Map.Entry에서 getKey, getValue는 확실히 기반 메서드이며, 선택적으로 setValue도 포함할 수 있다.

단순 구현

단순 구현(simple implementation)은 골격 구현의 작은 변종으로, AbstractMap.SimpleEntry가 좋은 예다.

단순 구현도 골격 구현과 같이 상속을 위해 인터페이스를 구현한것이지만, 추상 클래스가 아니란 점이 다르다.

쉽게말해 동작하는 가장 단순한 구현인데, 이러한 단순구현은 그대로 써도 되고 필요에 맞게 확장해도 된다.

DEV ℧ Developer Diary