객체지향 프로그래밍의 장점 중 하나는 코드를 재사용하기가 용이하다는 것이다.
이번 장에서는 클래스를 재사용하기 위해 새로운 클래스를 추가하는 가장 대표적인 기법인 상속에 관해 살펴보도록 한다.
01. 상속과 중복 코드
중복 코드는 우리를 주저하게 만들뿐만 아니라 동료들을 의심하게 만든다.
DRY 원칙
중복 코드는 변경을 방해한다. 이것이 중복 코드를 제거해야 하는 가장 큰 이유다.
중복 여부를 판단한느 기준은 변경이다. 요구사항이 변경됐을 때 두 코드를 함께 수정해야 한다면 이 코드는 중복이다.
신뢰할 수 있고 수정하기 쉬운 소프트웨어를 만드는 효과적인 방법 중 하나는 중복을 제거하는 것이다. DRY는 '반복하지 마라'라는 뜻의 Don't Repeat Yourself의 첫 글자를 모아 만든 용어이다.
중복과 변경
중복 코드 살펴보기
중복 코드의 문제점 이해하기 위해 한 달에 한 번씩 가입자별로 전화 요금을 계산하는 애플리케이션을 개발해보자.
전화 요금을 계산하는 규칙
- 통화 시간을 단위 시간 당 요금으로 나눈다.
- 10초당 5원의 통화료를 부과하는 요금제에 가입돼 있는 가입자가 100초 동안 통화를 했다면 요금으로 100 / 10 * 5 = 50원이 부과된다.
@Getter
public class Call {
private LocalDateTime from;
private LocalDateTime to;
public Call(LocalDateTime from, LocalDateTime to) {
this.from = from;
this.to = to;
}
public Duration getDuration() {
return Duration.between(from, to);
}
}이제 통화 요금을 계산할 객체가 필요하다. 정보 전문가에게 요금을 계산할 책임을 할당해야 한다. 따라서 Call의 목록을 관리할 정보 전문가는 Phone이다.
@Getter
public class Phone {
private Money amount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
public Phone(Money amount, Duration seconds) {
this.amount = amount;
this.seconds = seconds;
}
public void setCalls(Call call) {
calls.add(call);
}
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
result = result.plus(amount.times((double) call.getDuration().getSeconds() / seconds.getSeconds()));
}
return result;
}
}다음은 Phone을 이용해 '10초당 5원'씩 부과되는 요금제에 가입한 사용자가 각각 1분 동안 두 번 통화를 한 경우의 통화 요금을 계산하는 방법을 코드로 나타낸 것이다.
Phone phone = new Phone(Money.wons(5), Duration.ofSeconds(10));
phone.call(new Call(LocalDateTime.of(2018, 1, 1, 12, 10, 0),
LocalDateTime.of(2018, 1, 1, 12, 11, 0)));
phone.call(new Call(LocalDateTime.of(2018, 2, 1, 12, 10, 0),
LocalDateTime.of(2018, 1, 2, 12, 11, 0)));
phone.calculdateFee(); // => Money.wons(60)요구사항 변경
- 심야 할인 요금제
- 밤 10시 이후의 통화에 대해 요금 할인
- 요금제 구분
- 일반 요금제
- 심야 요금제
이 요구사항을 해결할 수 있는 쉽고도 가장 빠른 방법은 Phone의 코드를 복사해서 NightliyDiscountPhone 이라는 새로운 클래스를 만든 후 수정하는 것이다.
@Getter
public class NightlyDiscountPhone {
private static final int LATE_NIGHT_HOUR = 22;
private Money nightlyAmount;
private Money regularAmount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
public NightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds) {
this.nightlyAmount = nightlyAmount;
this.regularAmount = regularAmount;
this.seconds = seconds;
}
public void call(Call call) {
calls.add(call);
}
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
result = result.plus(nightlyAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds()));
} else {
result = result.plus(regularAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds()));
}
}
return result;
}
}예를 들어, 심야 할인 요금제가 10시 이전에는 10초당 5원이고 10시 이후에는 10초당 2원이라면 seconds는 10초, regularAmount는 5원, nightlyAmount는 2원의 값을 저장하고 있을 것이다.
중복 코드 수정하기
새로운 요구사항
- 통화 요금에 부과할 세금을 계산
- 부과되는 세율은 가입자의 핸드폰마다 다르다고 가정
현재 통화 요금을 계산하는 로직은 Phone과 NightlyDiscountPhone 양쪽 모두 구현돼 있기 때문에 세금을 추가하기 위해서는 두 클래스 함께 수정해야 한다.
Phone 클래스부터 수정하자. 가입자의 핸드폰 별로 세율이 서로 달라야 하기 때문에 Phone은 세율을 저장할 인스턴스 변수인 taxRate를 포함해야 한다. taxate의 값을 이용해 통화 요금에 세금을 부과하도록 Phone에 calculdateFee 메서드를 수정하자.
@Getter
public class Phone {
private Money amount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
private double taxRate;
public Phone(Money amount, Duration seconds, double taxRate) {
this.amount = amount;
this.seconds = seconds;
this.taxRate = taxRate;
}
public void call(Call call) {
calls.add(call);
}
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
result = result.plus(amount.times((double) call.getDuration().getSeconds() / seconds.getSeconds()));
}
return result.plus(result.times(taxRate));
}
}@Getter
public class NightlyDiscountPhone {
private static final int LATE_NIGHT_HOUR = 22;
private Money nightlyAmount;
private Money regularAmount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
private double taxRate;
public NightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds, double taxRate) {
this.nightlyAmount = nightlyAmount;
this.regularAmount = regularAmount;
this.seconds = seconds;
this.taxRate = taxRate;
}
public void call(Call call) {
calls.add(call);
}
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
result = result.plus(nightlyAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds()));
} else {
result = result.plus(regularAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds()));
}
}
return result.minus(result.times(taxRate));
}
}위 코드는 중복 코드가 발생한다. 많은 코드 속에서 어떤 코드가 중복인지 파악하기 어렵다. 또 더 큰 문제는 중복 코드를 서로 다르게 수정하기가 쉽다는 것이다. NightlyDiscountPhone 의 calculdateFee 메서드에서 plus 대신 minus 메서드를 호출하고 있다.
민첩하게 변경하기 위해서는 중복 코드를 추가하는 대신 제거애햐 한다.
타입 코드 사용하기
두 클래스 사이의 중복 코드를 제거하는 한 가지 방법은 클래스를 합치는 것이다.
상속을 이용해서 중복 코드 제거하기
NightlyDiscountPhone 클래스의 코드 대부분은 Phone 클래스의 코드와 거의 유사하다. 따라서 NightlyDiscountPhone 클래스가 Phone 클래스를 상속받게 만들면 코드를 중복시키지 않고도 Phone 클래스 코드 대부분을 재사용할 수 있다.
@Getter
public class NightlyDiscountPhone extends Phone {
private static final int LATE_NIGHT_HOUR = 22;
private Money nightlyAmount;
private List<Call> calls = new ArrayList<>();
public NightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds, double taxRate) {
super(regularAmount, seconds, taxRate);
this.nightlyAmount = nightlyAmount;
}
public void call(Call call) {
calls.add(call);
}
@Override
public Money calculateFee() {
Money result = super.calculateFee();
Money nightlyFee = Money.ZERO;
for (Call call : calls) {
if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
nightlyFee = nightlyFee.plus(
getAmount().minus(nightlyAmount).times(
(double) call.getDuration().getSeconds() / getSeconds().getSeconds()
)
);
}
}
return result.minus(nightlyFee);
}
}calculdateFee() 메서드를 살펴보면, super 참조를 통해 부모 클래스인 Phone의 calculateFee 메서드를 호출해서 일반 요금제에 따라 통화 요금을 계산한 후 이 값에서 통화 시간이 10시 이후인 통화의 요금을 빼주는 부분이다.
심야 할인 요금제 규칙이 다음과 같다고 해보자.
- 밤 10시 이전: 10초당 5원(regularAmount = 5원, seconds = 10초)
- 밤 10시 이후: 10초당 2원(nightlyAmount = 2원, seconds = 10초)
어떤 가입자가 두 번 통화했고 각 통화시간은 40초와 50초라고 가정하자. 이 통화가 밤 10시 이전에 일어났다면 통화요금은 45원이 된다.
(40초 / 10초 5원) + (50초 / 10초 5원) = 45원
만약이 이 통화가 10시 이후에 일어났다면 통화요금은 18원이 된다.
(40초 / 10초 2원) + (50초 / 10초 2원) = 18원
만약 전체 통화 시간 중 처음 40초 동안은 10시 이전에, 나머지 50초 동안은 10시 이후에 이뤄졌다면 통화요금은 다음과 같이 30원이 될 것이다.
(40초/10초 5원) + (50 / 10초 2원) = 30원
30원을 구하는 또 다른 방법은 40초, 50초 모두 10시 이전 기준으로 요금을 계산한다. 그리고 10시 이전 기본 요금에서 10시 이후 기본 요금을 뺀 후 이 값을 이용해서 10시 이후의 통화 요금을 계산한다. 뒤의 값을 빼주면 요금을 구할 수 있다.
상속을 이용해 코드를 재사용하기 위해서는 부모 클래스의 개발자가 세웠던 가정이나 추론 과정을 정확하게 이해해야 한다. 이것은 자식 클래스의 작성자가 부모 클래스의 구현 방법에 대한 정확한 지식을 가져야 한다는 것을 의미한다.
강하게 결합된 Phone과 NightlyDiscountPhone
코드 중복을 제거하기 위해 상속을 사용했음에도 세금을 계산하는 로직을 추가하기 위해 새로운 중복 코드를 만들어야 하는 것이다.
이것은 NightlyDiscountPhone 이 Phone 구현에 너무 강하게 결합돼 있기 때문에 발생하는 문제다.
이처럼 상속 관계로 연결된 자식 클래스가 부모 클래스의 변경에 취약해지는 현상을 가리켜 취약한 기반 클래스 문제라고 한다.
02. 취약한 기반 클래스 문제
자식 클래스가 부모 클래스의 변경에 영향 받는 현상을 가리켜 취약한 기반 클래스 문제라고 한다.
상속 관계를 추가할수록 전체 시스템의 결합도가 높아진다는 사실을 알고 있어야 한다. 상속은 자식 클래스를 점진적으로 추가해서 기능을 확장하는 데는 용이하지만 높은 결합도로 인해 부모 클래스를 점진적으로 개선하는 것은 어렵게 만든다.
상속은 자식 클래스가 부모 클래스의 구현 세부사항에 의존하도록 만들기 때문에 캡슐화를 약화시킨다.
불필요한 인터페이스 상속 문제
그림 10.1의 퍼블릭 인터페이스를 살펴보면 이 상속 관계가 가지는 문제점을 잘 알 수 있다. Vector는 임의의 위치(index)에서 요소를 조회하고, 추가하고, 삭제할 수 있는 get, add, remove 오퍼레이션을 제공한다. 이에 비해 Stack은 맨 마지막 위치에서만 요소를 추가하거나 제거할 수 있는 push, pop 오퍼레이션을 제공한다.
Stack에게 상속된 Vector의 퍼블릭 인터페이스를 이용하면 임의의 위치에 요소를 추가하거나 삭제할 수 있다. 따라서 맨 마지막 위치에서만 요소를 추가하거나 제거할 수 있도록 허용하는 Stack의 규칙을 쉽게 위반할 수 있다.
Stack<String> stack = new Stack<>();
stack.push("1st");
stack.push("2nd");
stack.push("3rd");
stack.add(0, "4th");
System.out.println(stack); // [4th, 1st, 2nd, 3rd]문제의 원인은 Stack이 규칙을 무너뜨릴 여지가 있는 Vector의 퍼블릭 인터페이스까지 함께 상속받았기 때문이다.
이 클래스는 Map의 조상인 Hashtable을 상속받는데 자바에 제네릭(generic)이 도입되기 이전에 만들어졌기 때문에 컴파일러가 키와 값의 타입이 String인지 여부를 체크할 수 있는 방법이 없었다. 따라서 Hashtable의 인터페이스에 포함돼 있는 put 메서드를 이용하면 String 타입 이외의 키와 값이라도 Properties에 저장할 수 있다.
Properties properties = new Properties();
properties.setProperty("Bjarne Stroustrup", "C++");
properties.setProperty("James Gosling", "Java");
properties.put("Dennis Ritchie", 67);
assertEquals("C", properties.getProperty("Dennis Ritchie")); // 에러위 코드를 실행해 보면 "Dennis Ritchie"를 키로 검색할 경우 null이 반환된다는 사실을 알 수 있다. 그 이유는Properties 의 getProperty 메서드가 반환할 값의 타입이 String이 아닐 경우 null을 반환하도록 구현돼 있기 때문이다.
이런 사례는 퍼블릭 인터페이스에 대한 고려 없이 단순히 코드 재사용을 위해 상속을 이용하는 것이 얼마나 위험한지 잘 보여준다.
상속을 위한 경고 2
상속 받은 부모 클래스의 메서드가 자식 클래스의 내부 구조에 대한 규칙을 깨트릴 수 있다.
메서드 오버라이딩의 오작용 문제
조슈아 블로치는 이펙티브 자바에서 HashSet의 구현에 강하게 결합된 InstrumentedHashSet 클래스를 소개한다. InstrumentedHashSet은 HashSet 내부에 저장된 요소의 수를 셀 수 있는 기능을 추가한 클래스로서 HashSet의 자식 클래스로 구현돼 있다.
public class InstrumentedHashSet<E> extends HashSet<E> {
private int addCount = 0;
@Override
public boolean add(E e) {
addCount++;
return super.add(e);
}
@Override
public boolean addAll(Collection<? extends E> c) {
addCount += c.size();
return super.addAll(c);
}
}InstrumentedHashSet의 구현에는 아무런 문제가 없어 보인다. 적어도 다음과 같은 코드를 실행하기 전까지는 말이다.
InstrumentedHashSet<String> languages = new InstrumentedHashSet<>();
languages.addAll(Arrays.asList("Java", "Ruby", "Scala"));addCount = 3 이라고 예측할 수 있지만 실제로는 6이다. 그 이유는 부모 클래스인 HashSet의 addAll 메서드 안에서 add 메서드를 호출하기 때문이다.
좋은 해결책은 InstrumentedHashSet의 addAll 메서드를 오버라이딩하고 추가되는 각 요소에 대해 한 번씩 add 메서지를 호출하는 것이다. 이제 미래에 HashSet의 addAll 메서드가 add 메시지를 전송하지 않도록 수정되더라도 InstrumentedHashSet의 행동에는 아무런 영향도 없을 것이다.
public class InstrumentedHashSet<E> extends HashSet<E> {
private int addCount = 0;
@Override
public boolean add(E e) {
addCount++;
return super.add(e);
}
@Override
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c) {
if (add(e)) {
modified = true;
}
}
return modified;
}
public static void main(String[] args) {
InstrumentedHashSet<String> languages = new InstrumentedHashSet<>();
languages.addAll(Arrays.asList("Java", "Ruby", "Scala"));
System.out.println("languages.size() = " + languages.size());
}
}하지만 이 방법에도 문제가 없는 것은 아니다. 바로 오버라이딩된 addAll 메서드의 구현이 HashSet의 것과 동일하다는 것이다.
상속을 위한 경고3
자식 클래스가 부모 클래스의 메서드를 오버라이딩할 경우 부모 클래스가 자신의 메서드를 사용하는 방법에 자식 클래스가 결합될 수 있다.
부모 클래스와 자식 클래스의 동시 수정 문제
음악 목록을 추가할 수 있는 플레이리스트를 구현한다고 가정하자. 필요한 것은 음악 정보를 저장할 Song 클래스와 음악목록을 저장할 Playlist 클래스다. 먼저 Song 클래스는 가수의 이름(singer)과 노래 제목(title)을 인스턴스 변수로 포함한다.
@Getter
@AllArgsConstructor
public class Song {
private String singer;
private String title;
}
@Getter
public class Playlist {
private List<Song> tracks = new ArrayList<>();
public void append(Song song) {
getTracks().add(song);
}
}이제 플레이리스트에서 노래를 삭제할 수 있는 기능이 추가된 PersonPlaylist가 필요하다고 가정해보자.
public class PersonPlaylist extends Playlist {
public void remove(Song song) {
getTracks().remove(song);
}
}문제는 지금부터다. 요구사항이 변경돼서 Playlist에서 노래의 목록뿐만 아니라 가수별 노래의 제목도 함께 관리해야 한다고 가정하자.
@Getter
public class Playlist {
private List<Song> tracks = new ArrayList<>();
private Map<String, String> singers = new HashMap<>();
public void append(Song song) {
tracks.add(song);
singers.put(song.getSinger(), song.getTitle());
}
}위 수정 내용이 정상 작동하려면 PersonalPlaylist의 remove 메서드도 함께 수정해야 한다. 만약 PersonPlaylist를 수정하지 않는다면 Playlist의 tracks에서는 노래가 제거되지만 singers에는 남아있을 것이다.
public class PersonPlaylist extends Playlist {
public void remove(Song song) {
getTracks().remove(song);
getSingers().remove(song.getSinger());
}
}이 예는 자식 클래스 부모 클래스의 메서드를 오버라이딩하거나 불필요한 인터페이스를 상속받지 않았음에도 부모 클래스를 수정할 때 자식 클래스를 함께 수정해야 할 수도 있다는 사실을 잘 보여준다. 상속을 사용하면 자식 클래스가 부모 클래스의 구현에 강하게 결합되기 때문에 이 문제를 피하기는 어렵다.
결합도란 다른 대상에 대해 알고 있는 지식의 양이다. 상속은 기본적으로 부모 클래스의 구현을 재사용한다는 기본 전제를 따르기 때문에 자식 클래스가 부모 클래스의 내부에 대해 속속들이 알도록 강요한다.
상속을 위한 경고 4
클래스를 상속하면 결합도로 인해 자식 클래스와 부모 클래스의 구현을 영원히 변경하지 않거나, 자식 클래스와 부모 클래스를 동시에 변경하거나 둘 중 하나를 선택할 수 밖에 없다.
03. Phone 다시 살펴보기
이제 다시 Phone과 NightlyDiscountPhone의 문제로 돌아와 상속으로 인한 피해를 최소화할 수 있는 방법을 찾아보자. 취약한 기반 클래스 문제를 완전히 없앨 수 없지만 어느 정도까지 위험을 완화시키는 것은 가능하다. 문제 해결의 열쇠는 바로 추상화다.
추상화에 의존하자
NightlyDiscountPhone의 가장 큰 문제점은 Phone에 강하게 결합되어 있기 때문에 Phone이 변경될 경우 함께 변경될 가능성이 높다는 것이다. 이 문제를 해결하는 가장 일반적인 방법은 자식 클래스가 부모 클래스의 구현이 아닌 추상화에 의존하도록 만드는 것이다.
- 두 메서드가 유사하게 보인다면 차이점을 메서드로 추출하라. 메서드 추출을 통해 두 메서드를 동일한 형태로 보이도록 만들 수 있다.
- 부모 클래스의 코드를 하위로 내리지 말고 자식 클래스의 코드를 상위로 올려라. 부모 클래스의 구체적인 메서드를 자식 클래로 내리는 것보다 자식 클래스의 추상적인 메서드를 부모 클래스로 올리는 것이 재사용성과 응집도 측면에서 더 뛰어난 결과를 얻을 수 있다.
차이를 메서드로 추출하라
먼저 할 일은 두 클래스의 메서드에서 다른 부분을 별도의 메서드로 추출하는 것이다. 이 경우에는 calculateFee
의 for문 안에 구현된 요금 계산 로직이 서로 다르다는 사실을 알 수 있다.
@Getter
public class Phone {
private Money amount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
private double taxRate;
public Phone(Money amount, Duration seconds, double taxRate) {
this.amount = amount;
this.seconds = seconds;
this.taxRate = taxRate;
}
public void call(Call call) {
calls.add(call);
}
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
result = result.plus(calculateCallFee(call));
}
return result.plus(result.times(taxRate));
}
private Money calculateCallFee(Call call) {
return amount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());
}
}
@Getter
public class NightlyDiscountPhone {
private static final int LATE_NIGHT_HOUR = 22;
private Money nightlyAmount;
private Money regularAmount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
public NightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds) {
this.nightlyAmount = nightlyAmount;
this.regularAmount = regularAmount;
this.seconds = seconds;
}
public void call(Call call) {
calls.add(call);
}
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
result = calculateCallFee(call);
}
return result;
}
private Money calculateCallFee(Call call) {
if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
return nightlyAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds())
} else {
return regularAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());;
}
}
}
두 클래스의 calculate 메서드는 완전히 동일해졌고 추출한 calculateCallFee 메서드 안에 서로 다른 부분을 격리시켜 놓았다. 이제 같은 코드를 부모 클래스에 올리는 일만 남았다.
중복 코드를 부모 클래스로 올려라
부모 클래스를 추가하자. 목표는 모든 클래스들이 추상화에 의존하도록 만드는 것이기 때문에 이 클래스는 추상 클래스로 구현하는 것이 적합할 것이다. 새로운 부모 클래스의 이름은 AbstractPhone으로 하고 Phone과 NightlyDiscountPhone이 AbstractPhone을 상속받도록 수정하자.
이제 Phone과 NightlyDiscountPhone의 공통 부분을 부모 클래스로 이동 시키자.
public abstract class AbstractPhone {
public List<Call> calls = new ArrayList<>();
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
result = result.plus(calculateCallFee(call));
}
return result;
}
abstract protected Money calculateCallFee(Call call);
}
@Getter
public class Phone extends AbstractPhone {
private Money amount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
public Phone(Money amount, Duration seconds, double taxRate) {
this.amount = amount;
this.seconds = seconds;
}
public void call(Call call) {
calls.add(call);
}
@Override
protected Money calculateCallFee(Call call) {
return amount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());
}
}
@Getter
public class NightlyDiscountPhone extends AbstractPhone {
private static final int LATE_NIGHT_HOUR = 22;
private Money nightlyAmount;
private Money regularAmount;
private Duration seconds;
private List<Call> calls = new ArrayList<>();
public NightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds) {
this.nightlyAmount = nightlyAmount;
this.regularAmount = regularAmount;
this.seconds = seconds;
}
public void call(Call call) {
calls.add(call);
}
@Override
protected Money calculateCallFee(Call call) {
if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
return nightlyAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());
} else {
return regularAmount.times((double) call.getDuration().getSeconds() / seconds.getSeconds());
}
}
}
지금까지 살펴본 것처럼 자식 클래스들 사이의 공통점을 부모 클래스로 옮김으로써 실제 코드를 기반으로 상속 계층을 구성할 수 있다. 이제 우리의 설계는 추상화에 의존하게 된다.
의도를 드러내는 이름 선택하기
Phone은 사용자가 가입한 전화기의 한 종류지만 AbstractPhone이라는 이름은 전화기를 포괄한다는 의미를 명확하게 전달하지 못한다. 따라서 AbstractPhone은 Phone으로, Phone은 RegularPhone으로 변경하는 것이 적절할 것이다.
세금 추가하기
세금은 모든 요금제에 공통으로 적용돼야 하는 요구사항이다. 따라서 Phone을 수정하자.
public abstract class Phone {
public double taxRate;
public List<Call> calls = new ArrayList<>();
public Phone(double taxRate) {
this.taxRate = taxRate;
}
public Money calculateFee() {
Money result = Money.ZERO;
for (Call call : calls) {
result = result.plus(calculateCallFee(call));
}
return result;
}
abstract protected Money calculateCallFee(Call call);
}@Getter
public class RegularPhone extends Phone {
public RegularPhone(Money amount, Duration seconds, double taxRate) {
super(taxRate);
this.amount = amount;
this.seconds = seconds;
}
}
@Getter
public class NightlyDiscountPhone extends Phone {
public NightlyDiscountPhone(Money nightlyAmount, Money regularAmount, Duration seconds, double taxRate) {
super(taxRate);
this.nightlyAmount = nightlyAmount;
this.regularAmount = regularAmount;
this.seconds = seconds;
}
}클래스 사이의 상속은 자식 클래스가 부모 클래스가 구현한 행동뿐만 아니라 인스턴스 변수에 대해서도 결합되게 만든다.
인스턴스 변수의 목록이 변하지 않는 상황에서 객체의 행동(메서드의 내용)이 변경된다면 상속 계층에 속한 각 클래스들을 독립적으로 진화할 수 있다. 하지만 추가되는 상황이라면 자식 클래스는 부모 클래스에 정의된 인스턴스 변수를 초기화해야 하기 때문에 자연스럽게 자식 클래스의 초기화 로직에 영향을 미친다.
하지만 인스턴스 초기화 로직을 변경하는 것이 두 클래스에 동일한 세금 계산 코드를 중복시키는 것보다 현명한 선택이다. 객체 생성 로직에 대한 변경을 막기보단 핵심 로직의 중복을 막아야 한다. 핵심 로직은 한 곳에 모아놓고 조심스럽게 캡슐화해야 한다. 그리고 공통적인 핵심 로직은 최대한 추상화해야 한다.
04. 차이에 의한 프로그래밍
지금까지 살펴본 것처럼 상속을 사용하면 이미 존재하는 클래스의 코드를 기반으로 다른 부분을 구현함으로써 새로운 기능을 쉽고 빠르게 추가할 수 있다. 상속이 강력한 이유는 익숙한 개념을 이용해서 새로운 개념을 쉽고 빠르게 추가할 수 있기 때문이다.
이처럼 기존 코드와 다른 부분만을 추가함으로써 애플리케이션의 기능을 확장하는 방법을 차이에 의한 프로그래밍이라고 부른다.
상속이 재사용이라는 측면에서 매우 강력하지만 잘못 사용할 경우 돌아오는 피해 역시 크다.
상속의 단점을 피하면서도 코드를 재사용할 수 있는 더 좋은 방법이 바로 합성이다.
