if - else์ ๋ฌธ์ ์
example
public double calculate(boolean isFirstGuest, boolean isLastGuest, List<Item> items) {
double sum = 0;
for (Item item : items) {
if (isFirstGuest) {
sum += item.getPrice() * 0.9;
} else if (!item.isFresh()) {
sum += item.getPrice() * 0.8;
} else if (isFirstGuest) {
sum += item.getPrice() * 0.8;
} else {
sum += item.getPrice();
}
}
return sum;
}
๊ธฐ๋ฅ์ด ์ถ๊ฐ๋ ๊ฒฝ์ฐ
- ์๋ก์ด ์กฐ๊ฑด๋ฌธ์ ์ง์ ์ถ๊ฐํด์ฃผ์ด์ผ ํ๋ค.
- ๋๋ฌธ์ ์ถ๊ฐ๋๋ ๊ธฐ๋ฅ๋ค์ด ๋ง์์ง ์๋กฃ ์ฝ๋ ๋ธ๋ญ๋ ์ ์ ์ฆ๊ฐํ๋ค.
- ์ด๋ด ๊ฒฝ์ฐ ์ ์ง๋ณด์์ฑ์ด ๋จ์ด์ง๋ค.
๋๋ฝ๋ ์ํ
- (์ ์ข์ ์์์ด์ง๋ง) ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋ ๋ก์ง์ ์๋ก ๋ค๋ฅธ ํด๋์ค์์ ์ฌ์ฉํ๊ธฐ ์ํด ๋ณต๋ถ์ ํ์ ๊ฒฝ์ฐ, ํ ์ชฝ์ ๊ธฐ๋ฅ์ด ๋ณ๊ฒฝ๋๋ฉด ์ด๋ฅผ ๋ณต๋ถํ ๋ชจ๋ ํด๋์ค๋ฅผ ์ ๋ถ ์์ ํด์ฃผ์ด์ผ ํ๋ค.
๋๋ฌธ์ if-else๋ฅผ ์ฌ์ฉํ๋ฉด ์ ์ง๋ณด์๊ฐ ์ด๋ ต๋ค.
OCP - Open Close Principle (๊ฐ๋ฐฉ ํ์์ ์์น)
์ํํธ์จ์ด ๊ตฌ์ฑ์์(์ปดํฌ๋ํธ, ํด๋์ค, ๋ชจ๋, ํจ์)๋ ํ์ฅ์ ๋ํด์๋ ๊ฐ๋ฐฉ๋์ด์ผ ํ์ง๋ง ๋ณ๊ฒฝ์ ๋ํด์๋ ํ์๋์ด์ผ ํ๋ค.
๊ธฐ์กด ์ฝ๋๋ฅผ ๋ณ๊ฒฝํ์ง ์์ผ๋ฉด์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ ์ ์๋๋ก ์ค๊ณ๋์ด์ผ ํ๋ค.
๊ธฐ์กด ์ฝ๋์ ๋ณ๊ฒฝ์ด ์์ผ๋ฉฐ, ํ์ฅ์ด ์ฝ๋ค๋ ์ฅ์ ์ด ์๋ค.
์ ์ฉ ๋ฐฉ๋ฒ
- ์์(is-a)
- ์ปดํฌ์ง์ (has-a)
์ปดํฌ์ง์
๋ณ๊ฒฝ(ํ์ฅ)๋ ๊ฒ๊ณผ ๋ณํ์ง ์์ ๊ฒ์ ๊ตฌ๋ถํ๋ค.
์ด ๋ ๋ชจ๋์ด ๋ง๋๋ ์ง์ ์ ์ธํฐํ์ด์ค๋ฅผ ์ ์ํ๋ค.
๊ตฌํ์ ์์กดํ๊ธฐ๋ณด๋ค ์ ์ํ ์ธํฐํ์ด์ค์ ์์กดํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ๋ค.
์์
- List์ ArrayList์ ๊ด๊ณ
- ํ์ ์ ์ธ์ List์ด์ง๋ง ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋๋ ๊ทธ ๊ตฌํ์ฒด์ธ ArrayList๋ก ์์ฑํ๋ค.
์ ๋ต ํจํด
- ๋์์ธ ํจํด ์ค ๊ฐ์ฅ ๋ง์ด ์ฐ์
- ๋์์ธ ํจํด์ด๋? (์ํํธ์จ์ด) ๋์์ธ + (๊ณตํต์ ์ผ๋ก ๋ง์ฃผ์น๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์) ํจํด
- ๋์ ์ผ๋ก ์ ๋ต ์์ ๊ฐ๋ฅ
- ํ์๋ฅผ ํด๋์ค๋ก ์บก์ํํด ๋์ ์ผ๋ก ํ์๋ฅผ ์์ ๋กญ๊ฒ ๋ฐ๊ฟ ์ ์๊ฒ ํจ
- ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐ๊ฐ ๊ธฐ์กด ์ฝ๋์ ์ํฅ์ ๋ฏธ์น์ง ๋ชปํ๊ฒ ํ๋ฏ๋ก OCP๋ฅผ ๋ง์กฑ
- ๊ธฐ์กด ์ฝ๋ ๋ณ๊ฒฝ์์ด ํ์๋ฅผ ์์ ๋กญ๊ฒ ๋ฐ๊ฟ ์ ์๊ฒ ํด์ฃผ๋ OCP๋ฅผ ์ค์ํ ๋์์ธ ํจํด
โ GoF์ ๋์์ธ ํจํด์์์ ์ ๋ตํจํด
- ๋์ผ ๊ณ์ด์ ์๊ณ ๋ฆฌ์ฆ๊ตฐ์ ์ ์ํ๊ณ (walk, run, fly, rocket)
- ๊ฐ ์๊ณ ๋ฆฌ์ฆ์ ์บก์ํํ๋ฉฐ(MoveStrategy)
- ์ด๋ค์ ์ํธ๊ตํ์ด ๊ฐ๋ฅํ๋๋ก ๋ง๋ ๋ค.
์ ๋ต์ด๋?
์ด๋ค ๋ชฉ์ ์ ๋ฌ์ฑํ๊ธฐ ์ํด ์ผ์ ์ํํ๋ ๋ฐฉ์.
๋น์ฆ๋์ค ๊ท์น, ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฑ (Random, Reverse, Nothing)
๊ตฌ์ฑ
Context
- ์ ๋ต ํจํด์ ์ด์ฉํ๋ ์ญํ ์ ์ํ
- ํ์์ ๋ฐ๋ผ ๋์ ์ผ๋ก ๊ตฌ์ฒด์ ์ธ ์ ๋ต์ ๋ฐ๊ฟ ์ ์๋๋ก ํจ (setter ๋๋ DI)
Strategy
- ์ธํฐํ์ด์ค๋ ์ถ์ ํด๋์ค๋ก ์ธ๋ถ์์ ๋์ผํ ๋ฐฉ์์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ํธ์ถํ๋ ๋ฐฉ๋ฒ ๋ช ์
ConcreateStrategy
- ์ ๋ตํจํด์์ ๋ช ์ํ ์๊ณ ๋ฆฌ์ฆ์ ์ค์ ๋ก ๊ตฌํํ ํด๋์ค
Example
๋ฐฐ๋ฏผ ๋ก๋ด ์ด๋ ์ ๋ต ์์
- Walk
- Run
- Fly
- Rocket
์ด๊ธฐ ๋ฐฐ๋ฌ ๋ก๋ด
public class Robot {
public void display() {
System.out.println("๋ฐฐ๋ฌ ๋ก๋ด");
}
public void move() {
System.out.println("๊ฑธ์ด์ ๋ฐฐ๋ฌํฉ๋๋น.");
}
}
๊ทธ๋ฐ๋ฐ ์ด์ ๋ฌ๋ฆฌ๋ ๋ก๋ด๋ ์ถ๊ฐํ๊ฒ ๋์๋ค๋ฉด,
public class RunningRobot {
public void display() {
System.out.println("๋ฐฐ๋ฌ ๋ก๋ด");
}
public void move() {
System.out.println("๋ฐ์ด์ ๋ฐฐ๋ฌํฉ๋๋น.");
}
}
์ดํ์ ๋ ์ผ๋ ๋ก๋ด, ๋ก์ผ์ผ๋ก ๋ฐฐ๋ฌํ๋ ๋ก๋ด์ด ์๊ธฐ๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์.
์ด๋ฅผ ๋จผ์ ์์์ผ๋ก ํด๊ฒฐํ๋ ๊ฒฝ์ฐ, ์๋์ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค.
๊ทธ๋ฐ๋ฐ ์ฌ๊ธฐ์ ๋ก๋ด์ ์จ๋ ์กฐ์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ ๊ฒฝ์ฐ, ์๋์ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค.
๐ค ๋ฌธ์ ์ ?
- ๋ฉ์๋ ์์ ์ด ์ด๋ ต๋ค.
- โ๊ฑธ์ด์ ๋ฐฐ๋ฌํ๋ ๋ก๋ดโ์ด โ๋น ๋ฅด๊ฒ ๊ฑธ์ด์ ๋ฐฐ๋ฌํฉ๋๋คโ๋ก ๋ณํ ๊ฒฝ์ฐ ๋ชจ๋ ํด๋์ค๋ฅผ ์ํํ๋ฉด์ ๋ฉ์๋๋ค์ ์์ ํด์ฃผ์ด์ผ ํ๋ค.
- ์๋ก์ด ๊ธฐ๋ฅ ์ถ๊ฐ๊ฐ ์ด๋ ต๋ค.
- ํ๊ตญ์ด, ์์ด, ์ค๊ตญ์ด๋ฅผ ๋งํ๋ ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋๋ค๋ฉด ์ถ์ ํด๋์ค์ ๋งํ๊ธฐ ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋ ๊ฒ์ด๊ณ , ์ด๋ฅผ ์์๋ฐ๋ ํด๋์ค์ ๊ธฐ๋ฅ์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฐ๊ฐ์ ๋ฉ์๋๋ฅผ ๊ตฌํํด์ฃผ์ด์ผ ํ๋ค.
์ด๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ด ๋ฐ๋ก ์ ๋ตํจํด์ด๋ค!
- ์ด๋์ ๋ต : ๊ฑท๊ธฐ, ๋ฌ๋ฆฌ๊ธฐ, ๋ ๊ธฐ ๋ฑ์ ๋ก๋ด์ ํ์๋ฅผ ์ ์ํ๋ค.
- ์จ๋ ์ ๋ต : cold, warm, hot๋ฑ์ ์ ์ํ๋ค.
๋ก๋ด์ ์์ฑํ ๋ ๊ฐ๊ฐ์ ์ ๋ต์ ์ฃผ์ ํด์ฃผ์ด ๋ก๋ด์ ์ ๋ต์ ํ์๋ฅผ ์คํํ๊ฒ ๋๋ค.
์ด๋ ๊ฒ ๋๋ฉด ๋ฌธ์ ์ ์ด ์ด๋ป๊ฒ ํด๊ฒฐ๋ ๊น?
- ๋ฉ์๋ ์์ ์ด ์ฉ์ดํ๋ค.
- โ๊ฑธ์ด์ ๋ฐฐ๋ฌํ๋ ๋ก๋ดโ์ด โ๋น ๋ฅด๊ฒ ๊ฑธ์ด์ ๋ฐฐ๋ฌํฉ๋๋คโ๋ก ๋ณํ ๊ฒฝ์ฐ walk ๋ถ๋ถ๋ง ๋ณ๊ฒฝํด์ฃผ๋ฉด ๋๋ค.
- ์๋ก์ด ๊ธฐ๋ฅ ์ถ๊ฐ๊ฐ ์ฉ์ดํ๋ค.
- ํ๊ตญ์ด, ์์ด, ์ค๊ตญ์ด๋ฅผ ๋งํ๋ ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋๋ค๋ฉด ์ด์ ๋ฐ๋ฅธ ์๋ก์ด ์ ๋ต์ ํ์๋ฅผ ์ ์ํด์ฃผ๊ณ , ๋ก๋ด์ ์์ฑํ ๋ ์ ๋ต์ ํจ๊ป ์ฃผ์ ํด์ฃผ๋ฉด ๋๋ค.
- ๋ง์ฝ ์ด๋๋ฐฉ์์ด ๋์ค์ ๋ณ๊ฒฝ๋๋ค๋ฉด?
- setter๋ฑ์ ํตํด ๊ฐ์ฒด ์์ฑ ํ ์ ๋ต์ ๋ณ๊ฒฝํ ์ ์๋ค.
JDK์์์ ์ ๋ตํจํด
Comparator
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
}
Comparator๊ฐ ์ ๋ต์ด๊ณ ๊ฐ๋ฐ์๋ง๋ค customํ๊ฒ ์ ์ํ Comparator๊ตฌํ์ sort()
๋ผ๋ ์ปจํ
์คํธ์์ ์ฌ์ฉํ๊ณ ์๋ค.
๊ฐ๋ฐ์๋ ์ํฉ์ ๋ง๊ฒ ๋น๊ต ์ ๋ต์ ๊ตฌํํ ์ ์๊ฒ ํ์ฌ ๊ธฐ์กด ์ฝ๋์ ์์ ์์ด ํ์ฅ์ ์ด๋ฃฐ ์ ์๋ค.