Skip to content

상속과 컴포지션의 선택 ​

학습일: 2026-09-14 · 학습 순서 13 · 아이템 18: 상속보다는 컴포지션을 사용하라

핵심 결론 ​

기존 객체의 기능을 이용하거나 기능을 덧붙이려면 컴포지션을 먼저 검토한다. 자식이 부모의 역할을 수행하는 특수한 종류이고, 부모의 동작 계약을 지키며, 부모가 상속을 위해 설계한 확장 지점을 구현할 때는 상속을 검토한다.

컴포지션은 다른 객체를 필드로 가지고 활용하는 구조다. 위임은 그 객체의 메서드를 호출하여 일을 맡기는 동작이다. 여기서 주의하는 상속은 주로 extends로 클래스의 구현을 물려받는 상속이다. implements로 인터페이스의 공통 역할을 구현하는 것과 구분한다.

이 노트는 대화에서 학습한 개념과 설명용 코드를 정리한다. 13번의 Java Lab 소스와 테스트는 아직 추가하지 않았으며, 아래 결과는 코드 흐름에 따른 예상 결과다.

할인 기능에 로그를 추가하는 방법 ​

앞선 12번 실습에서 DiscountPolicy는 할인 금액을 반환하는 인터페이스이고, FixedDiscount와 PercentDiscount는 정액·정률 할인 구현이다. 주문 서비스인 OrderService는 전달받은 정책을 호출하여 최종 가격을 계산한다.

정액 할인 클래스를 상속해 로그를 추가하면 그 로그 클래스는 정액 할인 구현에 묶인다. 실제 12번의 FixedDiscount는 final이므로 상속할 수 없다. 대화에서 제시한 상속 예제는 그 제약을 풀었다고 가정한 비교이며, 실제 클래스는 변경하지 않았다.

컴포지션을 사용하면 할인 정책을 필드로 받고 계산을 위임할 수 있다.

java
class LoggingDiscount implements DiscountPolicy {
    private final DiscountPolicy policy;

    LoggingDiscount(DiscountPolicy policy) {
        this.policy = policy;
    }

    @Override
    public int discount(int price) {
        int amount = policy.discount(price);
        System.out.println("할인 금액: " + amount);
        return amount;
    }
}
java
var orders = new OrderService(
    new LoggingDiscount(new PercentDiscount())
);
orders.finalPrice(20000); // 예상: 할인 금액 2000 출력, 최종 가격 18000 반환

주문 서비스 → 로그 객체 → 정률 할인 객체 순서로 요청한다. 정률 할인 객체가 할인 금액을 반환하면 로그 객체는 이를 출력하고 그대로 반환한다. 주문 서비스는 그 금액을 원래 가격에서 뺀다. new FixedDiscount()를 감싸도 로그 코드를 다시 작성할 필요가 없다.

이처럼 같은 인터페이스를 구현하는 객체로 기존 객체를 감싸 기능을 추가하는 방식을 데코레이터 패턴이라고 한다. 컴포지션은 객체를 가지고 활용하는 일반적인 구조이고, 데코레이터는 그 구조를 이용하는 특정 패턴이다. 모든 컴포지션이 데코레이터인 것은 아니다.

이 코드에서는 계산이 성공한 뒤에만 로그를 출력한다. 계산 중 예외가 발생하면 로그를 출력하지 않고 예외가 전달된다. 실제 구현에서는 null 정책 거절과 필요한 로그 범위도 정해야 한다. 래퍼 클래스와 전달 메서드를 관리하는 비용이 있으므로 작은 기능마다 무조건 감싸지는 않는다.

상속에서 내부 호출 때문에 중복 집계되는 사례 ​

다음 부모 클래스는 목록 전체를 처리할 때 한 개를 처리하는 메서드를 반복 호출한다. List는 java.util.List이며, 예제는 저장 기능 없이 출력으로 처리를 나타낸다.

java
class Basket {
    public void add(String item) {
        System.out.println("담기: " + item);
    }

    public void addAll(List<String> items) {
        for (String item : items) {
            add(item);
        }
    }
}

자식이 한 개 처리와 여러 개 처리 모두에 집계를 추가했다고 가정한다.

java
class CountingBasket extends Basket {
    private int count;

    @Override
    public void add(String item) {
        count++;
        super.add(item);
    }

    @Override
    public void addAll(List<String> items) {
        count += items.size();
        super.addAll(items);
    }

    public int count() { return count; }
}
java
var basket = new CountingBasket();
basket.addAll(List.of("크림", "로션"));
basket.count(); // 예상: 2가 아니라 4
  1. 자식의 addAll이 목록 크기만큼 2를 더한다.
  2. super.addAll로 부모 메서드를 실행한다.
  3. 부모 메서드 안의 add는 실제 객체인 자식의 재정의된 메서드를 호출한다.
  4. 자식의 add가 두 번 실행되므로 2를 더 더한다.

super.addAll()은 부모의 addAll 구현을 선택하지만, 그 안에서 호출하는 모든 메서드를 부모 구현으로 고정하지는 않는다. 부모와 자식 메서드가 동일한 객체에서 실행된다는 점이 핵심이다.

자식의 addAll 재정의를 삭제하면 현재 구조에서는 2가 된다. 하지만 부모가 나중에 add를 거치지 않고 직접 일괄 처리하도록 바뀌면 이번에는 집계가 누락될 수 있다. 부모가 내부 호출 방식을 확장 계약으로 보장하지 않는다면, 자식은 변경될 수 있는 구현 세부사항에 의존하게 된다.

컴포지션에서는 별도 객체에 일을 맡긴다 ​

아래 코드는 앞의 상속 방식 대신 사용하는 대안이다. 같은 이름의 두 클래스를 동시에 선언하는 코드가 아니다.

java
class CountingBasket {
    private final Basket basket = new Basket();
    private int count;

    public void add(String item) {
        basket.add(item);
        count++;
    }

    public void addAll(List<String> items) {
        basket.addAll(items);
        count += items.size();
    }

    public int count() { return count; }
}

basket.addAll의 내부 add 호출은 별도 Basket 객체에서 실행된다. 바깥 CountingBasket.add로 되돌아가지 않아 정상 실행 시 두 항목을 2로 집계한다. 부모의 메서드 간 내부 호출 방식에 집계가 묶이지 않는다.

이 예제는 내부에서 Basket을 생성하므로 컴포지션은 사용하지만 의존성 주입은 사용하지 않는다. 필요하면 생성자로 전달받도록 바꿀 수 있다. 또한 이 대안은 Basket의 하위 타입이 아니므로 Basket을 요구하는 자리에 그대로 전달할 수 없다. 같은 타입으로 사용해야 한다면 앞의 할인 예제처럼 공통 인터페이스를 설계하는 방법을 검토한다.

두 집계 예제는 정상 실행을 설명한다. 일부 항목을 처리한 뒤 실패할 수 있다면 무엇을 집계하는지 별도로 정의해야 한다. 상속 예제는 처리 전에 수를 더하고, 컴포지션 예제는 전체 호출이 성공한 뒤 더한다. 따라서 실패 시 의미는 서로 다르며, 후자의 코드도 부분 성공 개수를 정확히 집계하는 해법은 아니다.

상속이 적합한 조건 ​

상속은 다음 조건을 함께 확인한다.

  • 자식이 부모의 한 종류로서 역할을 수행한다. 다른 객체의 기능을 이용하는 관계와 구분한다.
  • 부모를 사용하는 자리에 자식을 넣어도 호출자가 의존하는 동작 계약을 지킨다. 이를 리스코프 치환 원칙이라고 한다.
  • 부모가 상속을 위해 설계됐으며 자식이 재정의할 메서드, 호출 시점과 제약이 명확하다.

예를 들어 부모 계약이 추가 작업의 지원을 보장하는데 자식이 읽기 전용이라는 이유로 이를 무조건 거절하면 호출자의 기대를 깨뜨린다. 반대로 부모 계약부터 해당 작업을 선택 사항으로 정하고 미지원 예외를 허용했다면, 그 예외만으로 계약 위반이라고 판단하지 않는다.

이름상 한 종류라는 관계나 공통 필드가 있다는 사실만으로 상속의 적절성이 보장되지는 않는다. 기능 재사용만 필요하면 컴포지션으로도 해결할 수 있다.

의도된 확장 지점: 템플릿 메서드 ​

보고서 생성의 전체 순서는 부모가 관리하고 본문 작성만 자식에게 맡기는 구조다.

java
abstract class Report {
    public final String generate() {
        return "보고서 시작\n" + body() + "\n보고서 끝";
    }

    protected abstract String body();
}

class SalesReport extends Report {
    @Override
    protected String body() {
        return "오늘 매출: 100,000원";
    }
}

부모가 body()를 자식의 확장 지점으로 명시하고, generate()는 final로 재정의를 막는다. 전체 처리 흐름을 정의하면서 일부 단계를 자식에게 맡기는 방식을 템플릿 메서드 패턴이라고 한다.

이 구조에서는 body의 자식 구현을 호출하는 것이 의도된 설계다. 앞의 중복 집계 사례와 달리, 자식이 부모의 우연한 내부 동작을 추측하여 기능을 끼워 넣는 방식이 아니다. 실제 API에서는 body의 반환값과 예외 처리 같은 확장 계약도 정해야 한다. final은 재정의를 제한할 뿐 모든 동작의 안전성을 보장하지는 않는다.

학습 연결과 남은 확인 ​

인터페이스로 역할을 정의하고, 의존성 주입으로 구현을 전달하며, 컴포지션으로 일을 맡기면서 기능을 덧붙일 수 있다. 상속은 무조건 금지하는 것이 아니라 대체 가능성과 의도된 확장 계약을 근거로 선택한다.

후속 실습에서는 할인 로그의 정상·실패 동작과 집계 중복을 실행해 확인한다. 부모의 내부 호출을 바꿨을 때 상속 방식과 컴포지션 방식에 어떤 차이가 생기는지도 검증한다. 이어서 학습한 14번 equals에서는 객체의 동등성 기준과 상속을 제한한 값 객체 예제를 다룬다.

공부 목표 · 이전 학습: 인터페이스 · 30선 전체 목록