Template Method
Template Method ํจํด์ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฒด์ ์ธ ๋ผ๋๋ฅผ ์ถ์ ํด๋์ค์ ์ ์ํด๋๊ณ , ๊ทธ ์ค ์ผ๋ถ ๊ตฌ์ฒด์ ์ธ ๋จ๊ณ๋ ์๋ธํด๋์ค์์ ๊ตฌํํ๋๋ก ์์ํ๋ ๋์์ธ ํจํด์ ๋๋ค.
+-------------------------+
| AbstractClass | <-- ํ
ํ๋ฆฟ ๋ฉ์๋ ์ ์
+-------------------------+
| + templateMethod() | <-- ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฒด ๊ตฌ์กฐ
| { } |
| |
| - primitiveOperation1() | <-- ๊ตฌํ์ ์๋ธํด๋์ค์ ์์
| - primitiveOperation2() | <-- ๊ตฌํ์ ์๋ธํด๋์ค์ ์์
+-------------------------+
/ \
/ \
/ \
+----------------+ +----------------+
| ConcreteClass1 | | ConcreteClass2 | <-- ๊ตฌ์ฒด์ ์ธ ๊ตฌํ ํด๋์ค๋ค
+----------------+ +----------------+
| + primitiveOperation1() ๊ตฌํ |
| + primitiveOperation2() ๊ตฌํ |
+----------------+ +----------------+
์ฆ, ์๊ณ ๋ฆฌ์ฆ์ ๊ณตํต ๋ถ๋ถ์ ๋ถ๋ชจ ํด๋์ค์์ ์ฒ๋ฆฌํ๊ณ , ๋ณํ๋ ๋ถ๋ถ์ ์์ ํด๋์ค์์ ๊ตฌํํ์ฌ ์ฝ๋์ ์ค๋ณต์ ์ค์ด๊ณ , ์๊ณ ๋ฆฌ์ฆ์ ์ผ๊ด์ฑ์ ์ ์งํ ์ ์์ต๋๋ค.
How do Code?
// ์ถ์ ํด๋์ค: ์๊ณ ๋ฆฌ์ฆ์ ๋ผ๋๋ฅผ ์ ์ํ๋ ํ
ํ๋ฆฟ ๋ฉ์๋ ํฌํจ
public abstract class AbstractClass {
// ํ
ํ๋ฆฟ ๋ฉ์๋: ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฒด ๊ตฌ์กฐ๋ฅผ ์ ์ํ๋ฉฐ, ์ผ๋ถ ๋จ๊ณ๋ ์ถ์ ๋ฉ์๋๋ก ์์
public final void templateMethod() {
primitiveOperation1();
primitiveOperation2();
concreteOperation();
}
// ์๋ธํด๋์ค์์ ๊ตฌํํ ์ถ์ ๋ฉ์๋๋ค
protected abstract void primitiveOperation1();
protected abstract void primitiveOperation2();
// ๊ณตํต์ผ๋ก ์ฌ์ฉ๋๋ ๊ตฌ์ฒด์ ์ธ ๋ฉ์๋ (ํ์์ ๋ฐ๋ผ ์ค๋ฒ๋ผ์ด๋ฉ ๊ฐ๋ฅ)
private void concreteOperation() {
System.out.println("AbstractClass์ ๊ณตํต ์์
์ํ");
}
}
// ๊ตฌ์ฒด์ ์ธ ๊ตฌํ ํด๋์ค 1
public class ConcreteClass1 extends AbstractClass {
@Override
protected void primitiveOperation1() {
System.out.println("ConcreteClass1: primitiveOperation1 ์ํ");
}
@Override
protected void primitiveOperation2() {
System.out.println("ConcreteClass1: primitiveOperation2 ์ํ");
}
}
// ๊ตฌ์ฒด์ ์ธ ๊ตฌํ ํด๋์ค 2
public class ConcreteClass2 extends AbstractClass {
@Override
protected void primitiveOperation1() {
System.out.println("ConcreteClass2: primitiveOperation1 ์ํ");
}
@Override
protected void primitiveOperation2() {
System.out.println("ConcreteClass2: primitiveOperation2 ์ํ");
}
}// ์ถ์ ํด๋์ค: ํ
ํ๋ฆฟ ๋ฉ์๋๋ฅผ ํฌํจํ์ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฒด ํ๋ฆ์ ์ ์
abstract class AbstractClass {
// ํ
ํ๋ฆฟ ๋ฉ์๋: ์ ์ฒด ์๊ณ ๋ฆฌ์ฆ์ ํ๋ฆ์ ์ ์, final ์ญํ ์ ํ๋ฏ๋ก ์ค๋ฒ๋ผ์ด๋ฉ ๊ธ์ง
fun templateMethod() {
primitiveOperation1()
primitiveOperation2()
concreteOperation()
}
// ์๋ธํด๋์ค์์ ๊ตฌํํ ์ถ์ ๋ฉ์๋๋ค
protected abstract fun primitiveOperation1()
protected abstract fun primitiveOperation2()
// ๊ณตํต ์์
: ํ์์ ๋ฐ๋ผ ์๋ธํด๋์ค์์ ๋ณ๊ฒฝํ์ง ์๊ณ ์ฌ์ฉ
private fun concreteOperation() {
println("AbstractClass์ ๊ณตํต ์์
์ํ")
}
}
// ๊ตฌ์ฒด์ ์ธ ๊ตฌํ ํด๋์ค 1
class ConcreteClass1 : AbstractClass() {
override fun primitiveOperation1() {
println("ConcreteClass1: primitiveOperation1 ์ํ")
}
override fun primitiveOperation2() {
println("ConcreteClass1: primitiveOperation2 ์ํ")
}
}
// ๊ตฌ์ฒด์ ์ธ ๊ตฌํ ํด๋์ค 2
class ConcreteClass2 : AbstractClass() {
override fun primitiveOperation1() {
println("ConcreteClass2: primitiveOperation1 ์ํ")
}
override fun primitiveOperation2() {
println("ConcreteClass2: primitiveOperation2 ์ํ")
}
}ํ ํ๋ฆฟ ๋ฉ์๋(templateMethod()) ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฒด ํ๋ฆ์ ์ ์ํฉ๋๋ค. ํ ํ๋ฆฟ ๋ฉ์๋ ๋ด์์ ๊ณตํต์ผ๋ก ์ํํด์ผ ํ๋ ๋จ๊ณ์, ์๋ธํด๋์ค์์ ๊ฐ๊ฐ ๋ค๋ฅด๊ฒ ๊ตฌํํด์ผ ํ๋ ์ถ์ ๋ฉ์๋๋ฅผ ํธ์ถํฉ๋๋ค.
primitiveOperation1()์ primitiveOperation2() ์๋ธํด๋์ค์์ ๊ตฌ์ฒด์ ์ผ๋ก ๊ตฌํํ ๋ฉ์๋์ ๋๋ค. ์ด ๋ฉ์๋๋ค์ด ์๊ณ ๋ฆฌ์ฆ์ ๋ณ๊ฒฝ ๊ฐ๋ฅํ ๋ถ๋ถ์ ๋ด๋นํฉ๋๋ค.
concreteOperation() ์๊ณ ๋ฆฌ์ฆ์์ ๋ณ๊ฒฝ๋์ง ์๊ณ ๊ณตํต์ผ๋ก ์ํ๋๋ ์์ ์ผ๋ก, ๋ณดํต private ๋ฉ์๋๋ก ์ ์๋์ด ์๋ธํด๋์ค์์ ์ค๋ฒ๋ผ์ด๋ฉํ์ง ์์ต๋๋ค.
์ฅ์ ์๊ณ ๋ฆฌ์ฆ์ ๊ณตํต ๋ถ๋ถ๊ณผ ๋ณํํ๋ ๋ถ๋ถ์ ๋ถ๋ฆฌํจ์ผ๋ก์จ ์ฝ๋ ์ฌ์ฌ์ฉ์ฑ์ ๋์ด๊ณ , ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌ์กฐ๋ฅผ ์ผ์ ํ๊ฒ ์ ์งํ ์ ์์ต๋๋ค.
Last updated