이펙티브 자바 아이템 18 - 상속보다는 컴포지션을 사용하라 - 완벽 공략
아이템 18 - 상속보다는 컴포지션을 사용하라 - 완벽 공략
이 글은 백기선 님의 이펙티브 자바 강의와 이펙티브 자바 3 / E 편을 참고하여 작성하였습니다.
데코레이터 패턴
데코레이터 패턴은 기존 코드를 변경하지 않고 부가 기능을 추가하는 패턴 이다.
데코레이터는 상속이 아니라 위임 을 사용하는 대표적인 디자인 패턴 중 하나이다.
굳이 새로운 클래스를 만들 필요없이 기존의 클래스를 조합해 새로운 인스턴스를 만들 수 있다.
단점으로는 조합을 하는 코드가 복잡해 질 수 있다.
public class ForwardingSet<E> implements Set<E> {
private final Set<E> s;
public ForwardingSet(Set<E> s) { this.s = s; }
public void clear() { s.clear(); }
public boolean contains(Object o) { return s.contains(o); }
public boolean isEmpty() { return s.isEmpty(); }
public int size() { return s.size(); }
public Iterator<E> iterator() { return s.iterator(); }
public boolean add(E e) {
System.out.println("?????");
return s.add(e); }
public boolean remove(Object o) { return s.remove(o); }
public boolean containsAll(Collection<?> c)
{ return s.containsAll(c); }
public boolean addAll(Collection<? extends E> c)
{
System.out.println("?AWDASD");
return s.addAll(c); }
public boolean removeAll(Collection<?> c)
{ return s.removeAll(c); }
public boolean retainAll(Collection<?> c)
{ return s.retainAll(c); }
public Object[] toArray() { return s.toArray(); }
public <T> T[] toArray(T[] a) { return s.toArray(a); }
@Override public boolean equals(Object o)
{ return s.equals(o); }
@Override public int hashCode() { return s.hashCode(); }
@Override public String toString() { return s.toString(); }
}ForwardingSet 클래스는 데코레이터 역활을 한다.
public class InstrumentedSet<E> extends ForwardingSet<E> {
private int addCount = 0;
public InstrumentedSet(Set<E> s) {
super(s);
}
@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);
}
public int getAddCount() {
return addCount;
}
public static void main(String[] args) {
InstrumentedSet<String> s = new InstrumentedSet<>(new HashSet<>());
s.addAll(List.of("틱", "탁탁", "펑"));
System.out.println(s.getAddCount());
}
}InstrumentedSet 클래스는 Concrete 데코레이터 역할을 한다.
HashSet 을 감싸고 있으므로 HashSet 이 Concrete 컴포넌트가 된다.
콜백 프레임워크와 셀프 문제
콜백이란 어떤 함수에 다른 함수를 인자로 전달하는 걸 말한다.
interface FunctionToCall {
void call();
void run();
}
class BobFunction implements FunctionToCall {
private final Service service;
public BobFunction(Service service) {
this.service = service;
}
@Override
public void call() {
System.out.println("밥을 먹을까..");
}
@Override
public void run() {
this.service.run(this);
}
}BobFunction 이라는 클래스의 run 메서드에서 어떠한 객체를 넘긴다.
public class Service {
public void run(FunctionToCall functionToCall) {
System.out.println("뭐 좀 하다가...");
functionToCall.call();
}
public static void main(String[] args) {
Service service = new Service();
BobFunction bobFunction = new BobFunction(service);
bobFunction.run();
}
}Service 클래스에서 필요한 순간에 넘겨진 객체를 호출해서 사용한다.
이게 콜백이다.
비동기적으로 함수를 호출하는데 사용된다.
지금까지의 코드에서는 잘 동작하는 것처럼 보이지만 Wrapper 와 같이 사용하게되면 셀프 문제 가 발생한다.
public class BobFunctionWrapper implements FunctionToCall {
private final BobFunction bobFunction;
public BobFunctionWrapper(BobFunction bobFunction) {
this.bobFunction = bobFunction;
}
@Override
public void call() {
this.bobFunction.call();
System.out.println("커피도 마실까...");
}
@Override
public void run() {
this.bobFunction.run();
}
}BobFunctionWrapper 클래스는 메서드들을 bobFunction 에 위임한다.
결과에서는 우리가 기대했던 결과가 나오지 않는다.
@Override
public void run() {
this.bobFunction.run();
}BobFunctionWrapper 클래스에서 호출하는 run 은 bobFunction 의 run() 이다.
// BobFunction
@Override
public void run() {
this.service.run(this);
}이때 넘겨주게되는 this 는 BobFunction 이다.
때문에 우리가 기대한 BobFunctionWrapper 의 call() 을 호출한게 아닌 BobFunction 클래스의 call() 을 호출하게된다.
이래서 셀프 문제 라고 한다.
wrapper 클래스를 콜백 프레임워크와 같이 사용했을 때 발생 할 수 있는 문제이다.