오브젝트 11장 합성과 유연한 설계

public class Properties {
  private Hashtable<String, String> properties = new Hashtable<>();

  public String setProperty(String key, String value) {
    return properties.put(key, value);
  }

  public String getProperty(String key) {
    return properties.get(key);
  }
}

public class InstrumentedHashSet<E> implements Set<E> {
  private int addCount = 0;
  private Set<E> set;

  public InstrumentedHashSet(Set<E> set) {
    this.set = set;
  }

  @Override
  public boolean add(E e) {
    addCount++;
    return set.add(e);
  }

  @Override
  public boolean addAll(Collection<? extends E> c) {
    addCount += c.size();
    return set.addAll(c);
  }

  public int getAddCount() {
    return addCount;
  }

  /* 포워딩 메서드 */
  @Override public boolean remove(Object o) { return set.remove(o); }
  ...
  @Oberride public boolean removeAll(Collection<?> c) { return set.removeAll(c); }
}

public class PersonalPlaylist {
  private Playlist playlist = new Playlist();

  public void append(Song song) {
    playlist.append(song);
  }

  public void remove(Song song) {
    playlist.getTracks().remove(song);
    palylist.getSingers().remove(song.getSinger());
  }
}

public abstract class Phone {
  private List<Call> calls = new AraryList<>();

  public Money calculateFee() {
    Money result = Money.ZERO

    for(Call call : calls) {
      result += result.plus(calculateCallFee(call));
    }

    return afterCalculated(result);
  }

  protected abstract Money calculateCallFee(Call call);
  protected abstract Money afterCalculated(Money fee) {
    /* 기본 구현과 함께 추가된 추상 메서드 */
    return fee;
  }
}

/* 부가 정책이 없는 RegularPhone과 NightlyDiscountPhone은 오버라이딩할 필요가 없다. */

/* RegularPhone 계산 요금에 세금을 부과하는 TaxableRegularPhone */
public class TaxableRegularPhone extends RegularPhone {
  ...
  @Override
  protected Money afterCalculated(Money fee) {
    return fee.plus(fee.times(texRate));
  }
}

/* NightlyDiscountPhone 계산 요금에 세금을 부과하는 TaxableNightlyDiscountPhone */
public class TaxableNightlyDiscountPhone extends NightlyDiscountPhone {
  ...
  @Override
  protected Money afterCalculated(Money fee) {
    return fee.plus(fee.times(texRate));
  }
}

public interface RatePolicy {
  Money calculateFee(Phone phone);
}

/* 요금 계산 방식을 제외한 전체 처리 로직이 동일한 기본 정책 추상 클래스 */
public abstract class BasicRatePolicy implements RatePolicy {
  @Override
  public Money calculateFee(Phone phone) {
    Money result = Money.ZERO;

    for (Call call : phone.getCalls()) {
      result.plus(calculateCallFee(call));
    }

    return result;
  }

  protected abstract Money calculateCallFee(Call call);
}

/* 요금 계산 방식을 구현한 기본 정책 요금제 클래스 */
public class RegularPolicy extends BasicRatePolicy {
  ...
  @Override
  protected Money calculateCallFee(Call call) {
    return amount.times(call.getDuration().getSeconds() / seconds.getSeconds());
  }
}

public class NightlyDiscountPolicy extends BasicRatePolicy {
  ...
  @Override
  protected Money calculateCallFee(Call call) {
    if (call.getFrom().getHour() >= LATE_NIGHT_HOUR) {
      return nightlyAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
    }

    return regularAmount.times(call.getDuration().getSeconds() / seconds.getSeconds());
  }
}

/* 요금 계산이 반영되도록 Phone 수정 */
public class Phone {
  private RatePolicy ratePolicy;
  private List<Call> calls = new ArrayList<>();

  // RatePolicy에 대한 참조자가 포함되어 있음 (합성)
  public Phone(RatePolicy ratePolicy) {
    this.ratePolicy = ratePolicy;
  }

  public List<Call> getCAlls() {
    return Collections.unmodifiableList(calls);
  }

  public Money calculateFee() {
    return ratePolicy.calculateFee(this);
  }
}

/* 인스턴스 합성 예제 */
Phone regularPhone = new Phone(new RegularPolicy(
    Money.wons(10), Duration.ofSeconds(10)
  )
);
Phone nightlyDiscountPhone = new Phone(
  new NightlyDiscountPolicy(
    Money.wons(5), Money.wons(10), Duration.ofSeconds(10)
  )
);

/* 부가 정책 추상 클래스 */
public abstract class AdditionalRatePolicy implements RatePolicy {
  private RatePolicy next;

  public AdditionalRatePolicy(RatePolicy next) {
    this.next = next;
  }

  @Override
  public Money calculateFee(Phone phone) {
    Money fee = next.calculateFee(phone); // 합성되는 요금 정책 인스턴스를 런타임 의존성으로 대체
    return afterCalculated(fee);
  }

  abstract protected Money afterCalculated(Money fee);
}

/* 요금 계산 메서드를 오버라이딩하는 부가 정책 자식 클래스 */
public class TaxablePolicy extends AdditionalRatePolicy {
  ...
  @Override
  protected Money afterCalculated(Money fee) {
    return fee.plus(fee.times(taxRatio));
  }
}

public class RateDiscountablePolicy extends AdditionalRatePolicy {
  ...
  @Override
  protected Money afterCalculated(Money fee) {
    return fee.minus(discountAmount);
  }
}

/* 인스턴스 합성 예제 */
Phone taxablePhone = new Phone(
  new TaxablePolicy(
    0.05,
    new RegularPolicy(...)
  )
);
Phone rateDiscountableAndTaxablePhone = new Phone(
  new TaxablePolicy(
    0.05,
    new RateDiscountablePolicy(
      Money.wons(1000),
      new RegularPolicy(...)
    )
  )
);

/* 세금 정책 트레이트 */
trait TaxablePolicy extends BasicRatePolicy {
  ...
  override def calculateFee(phone: Phone): Money = {
    val fee = super.calculateFee(phone)
    return fee + fee * taxRate
  }
}

/* 비율 할인 정책 트레이트 */
trait RateDiscountablePolicy extends BasicRatePolicy {
  ...
  override def calculateFee(phone: Phone): Money = {
    val fee = super.calculateFee(phone)
    return fee - discountableAmount
  }
}

/* 믹스인 예제 */
class TaxableRegularPolicy(
    amount: Money,
    seconds: Duration,
    val taxRate: Double)
  extends RegularPolicy(amount, seconds)
  with TaxablePolicy

class RateDiscountableAndTaxableRegularPolicy(
    amount: Money,
    seconds: Duration,
    val discaountAmount: Money,
    val taxRate: Double)
  extends RegularPolicy(amount, seconds)
  with TaxablePolicy
  with RateDiscountablePolicy