CamelAct

Overview

데코레이터 패턴은 음료에 시럽을 첨가하는 것과 같습니다.
한 음료에 시럽을 첨가하여 다른 음료를 만들 수 있습니다.

장점
1. 기존 코드를 수정하지 않고 데코레이터 패턴을 통해 행동을 확장할 수 있습니다.
2. 구성 및 위임을 통해 실행하면서 새 작업을 추가할 수 있습니다.

불리
1. 무의미한 대상을 너무 많이 추가할 수 있습니다.
2. 데코레이터가 너무 많으면 코드가 필요 이상으로 복잡해질 수 있습니다.

다음과 같은 상황에서 데코레이터 패턴을 사용하는 것이 좋습니다.
1. 클래스의 요소를 계속 수정하면서 사용할 구조체가 필요한 경우
2. 다양한 요소를 조합하여 사용하는 클래스 구조인 경우

Structure

Code Example

package com.example.design.pattern;

abstract class Beverage {
	protected String description = "Unknown Beverage";

	public String getDescription() {
		return description;
	}

	public abstract double cost();
}

class Espresso extends Beverage {
	public Espresso() {
		this.description = "Espresso";
	}

	@Override
	public double cost() {
		return 1;
	}
}

class HouseBlend extends Beverage {
	public HouseBlend() {
		this.description = "House Blend";
	}

	@Override
	public double cost() {
		return 1.5;
	}
}

abstract class CondimentDecorator extends Beverage {
	public abstract String getDescription();
}

class Mocha extends CondimentDecorator {
	private final Beverage beverage;

	public Mocha(Beverage beverage) {
		this.beverage = beverage;
	}

	@Override
	public double cost() {
		return 0.20 + beverage.cost();
	}

	@Override
	public String getDescription() {
		return beverage.getDescription() + ", Mocha";
	}
}

class Whip extends CondimentDecorator {
	private final Beverage beverage;

	public Whip(Beverage beverage) {
		this.beverage = beverage;
	}

	@Override
	public double cost() {
		return 0.15 + beverage.cost();
	}

	@Override
	public String getDescription() {
		return beverage.getDescription() + ", Whip";
	}
}

public class MyDecorator {
	public static void main(String[] args) {
		Beverage b = new Mocha(new Mocha(new Whip(new HouseBlend())));
		System.out.println(b.getDescription());
		System.out.println(b.cost());
	}
}

Console Result

House Blend, Whip, Mocha, Mocha
2.05

Additional Code Example

You can use Decorator Pattern to create arithmetic calculators.

package com.example.test;

abstract class Base {
	protected float result = 0;

	public float calc() {
		return result;
	}
}

class Number extends Base {
	public Number(float n) {
		this.result = n;
	}
}

abstract class CondimentDecorator extends Base {
	public abstract float calc();
}

class Plus extends CondimentDecorator {
	final Base base1;
	final Base base2;

	public Plus(Base base1, Base base2) {
		this.base1 = base1;
		this.base2 = base2;
	}

	@Override
	public float calc() {
		return base1.calc() + base2.calc();
	}
}

class Minus extends Plus {
	public Minus(Base base1, Base base2) {
		super(base1, base2);
	}

	@Override
	public float calc() {
		return base1.calc() - base2.calc();
	}
}

class Multipl extends Plus {
	public Multipl(Base base1, Base base2) {
		super(base1, base2);
	}

	@Override
	public float calc() {
		return base1.calc() * base2.calc();
	}
}

class Division extends Plus {
	public Division(Base base1, Base base2) {
		super(base1, base2);
	}

	@Override
	public float calc() {
		return base1.calc() / base2.calc();
	}
}

public class MyDecorator {
	public static void main(String[] args) {
		Base a = new Number(3);
		System.out.println(a.calc());
		
		Base b = new Plus(new Number(2), new Number(5));
		System.out.println(b.calc());
		// 		( ( 4 + 2 ) * ( 8 - 1 ) ) / 2
		Base c = new Division(new Multipl(new Plus(new Number(4), new Number(2)), new Minus(new Number(8), new Number(1))), new Number(2));
		System.out.println(c.calc());
	}
}

Console Result

3.0
7.0
21.0

Conclusion

N/A