[Effective Java] Item 20. 추상 클래스보다는 인터페이스를 우선하라

추상 클래스의 단점

 추상 클래스를 구현하는 클래스는 반드시 추상 클래스의 하위 클래스가 되어야 한다. 그래서 기존 클래스에 추상 클래스를 새롭게 끼워넣기는 어려운 게 일반적이다.

 

 

 

인터페이스의 장점

추상 클래스와 달리 인터페이스는 인터페이스의 규약만 잘 지키면 다른 어떤 클래스를 상속해도 같은 타입으로 취급되므로 추상 클래스보다 훨씬 확장에 유연한 구조를 갖출 수 있다. 인터페이스를 사용할 때 얻을 수 있는 이점을 더 살펴보자.

 

 

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

인터페이스가 요구하는 메서드를 추가하고, 클래스 선언에 implements 구문만 추가하면 끝이다.

 

 

2. 인터페이스는 믹스인(mixin) 정의에 안성맞춤이다.

믹스인이란 클래스가 구현할 수 있는 타입을 말한다. 믹스인을 구현하면 클래스에 '주된 타입' 외에도 특정 선택적 행위를 제공한다고 선언하는 효과를 낼 수 있다. 

 

예를 들어 Comparable 인터페이스는 Comparable 자신을 구현한 클래스의 인스턴스끼리는 순서를 정할 수 있다고 선언하는 믹스인 인터페이스의 일종이다.

// x, y 좌표를 갖는 Position 클래스
public class Pos implements Comparable<Pos> {
    private int x;
    private int y;
    
    public Pos(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() {
        return this.x;
    }
    
    public int getY() {
        return this.y;
    }
    
    // Comparable 인터페이스의 compareTo 메서드를 재정의하여 순서 속성을 부여
    @Override
    public int compareTo(Pos other) {
        if (this.x == other.x) return this.y - other.y;
        return this.x - other.x;
    }
}

 

 

 

3. 인터페이스는 계층 구조가 없는 타입 프레임워크를 만들 수 있다.

현실에는 계층을 엄격히 구분하기 어려운 개념들도 있다. 예를 들어 가수 인터페이스와 작곡가 인터페이스가 있다고 해보자.

 

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

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

 

현실에는 작곡도 하는 가수도 제법 있다. 작곡도 하는 가수에 대해 인터페이스를 만들어보자.

public interface SingerSongWriter extends Singer, Songwriter {
    AudioClip strum();
    void actSensivite();
}

 

Singer와 SongWriter 모두를 구현해도 전혀 문제되지 않는다. 더해 두 인터페이스를 확장하고 새 메서드까지 추가할 수 있다.

 

 

 

이 부분을 추상 클래스로 다시 구현해보자.

public abstract class Singer {
    abstract void sing();
}

public abstract class SongWriter {
    abstract void compose();
}

public abstract class SingerSongWriter {
    abstract void actSensitive();
    abstract void sing();
    abstract void compose();
}

 

자바에서는 다중 상속이 불가능하므로 결국 새로운 추상 클래스를 만들어 중복되는 메서드들을 추가할 수밖에 없다.

 

 

 

 

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

위처럼 클래스가 가질 수 있는 속성이 n개일 때 같은 구조끼리 클래스로 만들기 위해 2^n개의 모든 조합의 수를 각각의 클래스로 정의하면 조합 폭발이라고도 불리우는 고도비만 계층구조가 만들어진다. 이 때, 래퍼 클래스 관용구를 인터페이스와 함께 사용하면 안전하고 강력하게 기능을 향상시킬 수 있다. 결론적으로 다중 구현용 타입으로는 대부분 인터페이스가 가장 적합하다. 

 

 

 

 

 

인터페이스가 점점 복잡해진다면..

구현 방법이 명백한 인터페이스 메서드는 디폴트 메서드로 정의해 일감을 덜자.

예시로 자바 8의 Collection 인터페이스에 추가된 디폴트 메서드는 주어진 boolean 함수가 true를 반환하는 모든 원소를 제거한다.

default boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    boolean result = false;
    for (Iterator<E> it = iterator(); it.hasNext(); ) {
        if (filter.test(it.next()) {
            it.remove();
            result = true;
        }
    }
    return result;
}

 

 

[ 디폴트 메서드 구현 시 주의 사항 ]

- 디폴트 메서드를 제공할 때는 상속하려는 사람을 위한 설명을 Javadoc으로 문서화해야 한다.

- Object의 메서드인 equals와 hashCode 등은 디폴트 메서드로 제공해서는 안 된다.

- 인터페이스는 인스턴스 필드와 public이 아닌 정적 멤버를 가질 수 없다.

- 직접 만든 인터페이스가 아니라면 디폴트 메서드를 추가할 수 없다.

 

 

 

인터페이스와 추상 골격 구현 클래스를 함게 제공하여 두 장점을 모두 취해보자.

- 인터페이스: 타입을 정의하고, 필요하면 디폴트 메서드 몇 개를 함께 제공한다.

- 골격 구현 클래스: 인터페이스에서 정의하지 않은 나머지 메서드들까지 구현한다.

 

 사실 이 방식은 템플릿 메서드 패턴으로 단순히 골격 구현만 확장해도 인터페이스를 구현하는 것과 마찬가지가 된다.

 

 

[헤드퍼스트 디자인패턴] 8. 템플릿 메소드 패턴 (Template Method Pattern)

 

 

 

 

관례상 인터페이스 이름이 Interface라면, 골격 구현 클래스의 이름은 AbstractInterface로 짓는다. 좋은 예로, 컬렉션 프레임워크의 AbstractCollection, AbstractSet, AbstractList, AbstractMap 골격 구현 클래스가 있다.

 

 

다음 코드는 완벽히 동작하는 List 구현체를 반환하는 정적 팩터리 메서드로, AbstractList 골격 구현을 활용했다.

static List<Integer> intArrayAsList(int[] a) {
    Objects.requireNonNull(a);
    
    // 익명 클래스 사용
    return new AbstractList<>() {
        @Override
        public Integer get(int i) {
            return a[i];
        }
        
        @Override
        public Integer set(int i, Integer val) {
            int oldVal = a[i];
            a[i] = val;    // 오토 언박싱
            return oldVal; // 오토 박싱
        }
        
        @Override
        public int size() {
            return a.length;
        }

 

 골격 구현 클래스는 추상 클래스처럼 구현을 도와주는 동시에, 추상 클래스로 타입을 정의할 때 따라오는 심각한 제약에서 자유롭다. 구조상 골격 구현을 확장하지 못한다면 인터페이스를 직접 구현해야 한다. 또는 골격 구현 클래스를 우회적으로 이용할 수도 있다. 골격 구현 클래스를 확장한 private 내부 클래스를 정의하고, 각 메서드의 호출을 내부 클래스의 인스턴스에 전달하면 된다. 이 방식을 시뮬레이트한 다중 상속이라 하며, 다중 상속의 많은 장점을 얻고, 단점을 피하게 해준다.

 

 

 

골격 구현 작성 방법

1. 인터페이스를 잘 살펴 다른 메서드들의 구현에 사용되는 기반 메서드들을 선정한다.

이 기반 메서드들은 골격 구현에서 추상 메서드가 된다.

 

 

2. 기반 메서드들로 직접 구현할 수 있는 메서드들을 모두 디폴트 메서드로 제공한다.

- 단, equals와 hashCode 같은 Object의 메서드는 디폴트 메서드로 제공해선 안된다.

- 만약 인터페이스 메서드 모두가 기반 메서드와 디폴트 메서드가 된다면 골격 구현 클래스를 별도로 만들 이유가 없다.

 

 

3. 기반 또는 디폴트 메서드로 만들지 못한 메서드가 있다면, 골격 구현 클래스를 만들어 작성한다.

골격 구현 클래스에는 필요하면 public이 아닌 필드와 메서드를 추가해도 된다.

 

 

간단한 예로 Map.Entry 인터페이스를 살펴보자.

 

- getKey, getValue, toString : 기반 메서드

- setValue: 선택적 기반 메서드

- equals, hashCode: 골격 구현 클래스에 구현

 

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 Object.equals(e.getKey(), getKey()) && Objects.equals(e.getValue(), getValue());
    }
    
    // MapEntry.hashCod의 일반 규약을 구현한다.
    @Override
    public int hashCode() {
        return Object.hashCode(getKey()) ^ Objects.hashCode(getValue());
    }
    
    @Override 
    public String toString() {
        return getKey() + "=" + getValue();
    }
}

 

 

또다른 예시로 카페인 음료를 인터페이스와 추상 골격 구현 클래스로 만들어보자.

public interface CaffeinBeverage {
    public void boilWater();
    public void pourInCup();
    public void brew();
    public void addCondiments();
    public void prepareRecipe();
}

public abstract class AbstractCaffeinBeverage implements CaffeinBeverage {
    public void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
        System.out.println("음료 나왔습니다!");
    }
    
    pubilc void boilWater() {
        System.out.println("물이 끓는 중...");
    }
    
    public void poutInCup(){
        System.out.println("컵에 붓는 중...");
    }
}

public class Coffee extends AbstractCaffeinBeverage implements CaffeinBeverage {

    @Override
    public void brew() {
        System.out.println("커피를 추출하는 중...");
    }
    
    @Override
    public void addCondiments() {
        System.out.println("시럽을 넣는 중...");
    }
}

public class Tea extends AbstractCaffeinBeverage implements CaffeinBeverage {

    @Override
    public void brew() {
        System.out.println("차를 우리는 중...");
    }
    
    @Override
    public void addCondiments() {
        System.out.println("찻잎을 넣는 중...");
    }
}

 

만약 Coffee 클래스가 Menu라는 클래스를 상속해야해서 위의 추상 골격 구현을 상속받지 못한다면 어떻게 해야 할까? 이런 경우에는 아까 언급했던 시뮬레이트한 다중 상속 기법을 사용해보자.

 

public class Coffee extends Menu implements CaffeinBeverage {
    InnerAbstractCaffeinBeverage caffeinBeverage = new InnerAbstractCaffeinBeverage();

    @Override
    public void boilWater() {
        caffeinBeverage.boilWater();
    }
    
    @Override
    public void pourInCup() {
        caffeinBeverage.pourInCup();
    }
    
    @Override
    public void brew() {
        caffeinBeverage.brew();
    }
    
    @Override
    public void addCondiments() {
        caffeinBeverage.addCondiments();
    }
    
    @Override
    public void prepareRecipe() {
        caffeinBeverage.prepareRecipe();
    }
    
    private class InnerAbstractCaffeinBeverage extends AbstractCaffeinBeverage {
        @Override
        public void brew() {
            System.out.println("커피를 추출하는 중...");
        }

        @Override
        public void addCondiments() {
            System.out.println("시럽을 넣는 중...");
        }
    }
}

 

 

 

 

단순 구현

 골격 구현의 작은 변종으로 골격 구현처럼 상속을 위해 인터페이스를 구현했으나, 추상 클래스가 아니다. 동작하는 가장 단순한 구현이라고 보면 된다.

 

ex. AbstractMap.SimpleEntry

 

 

 

 

 

 

참고 자료:

https://it-mesung.tistory.com/192

https://javabom.tistory.com/22

 

 

이펙티브 자바 Effective Java 3/E - YES24