
1. ๐ ๋ฏธ์ ์ค๋ช
3์ฃผ ์ฐจ์ ๋ฏธ์ ์ '๋ก๋ ๊ฒ์'์ ๊ตฌํํ๋ ๊ฒ์ด๋ค. ๋ก๋ ๊ฒ์์ ๊ธฐ๋ณธ์ ์ธ ๊ท์น์ ์๋์ ๊ฐ๋ค.
- ๋ก๋ ๋ฒํธ์ ์ซ์ ๋ฒ์๋ 1~45๊น์ง์ด๋ค.
- 1๊ฐ์ ๋ก๋๋ฅผ ๋ฐํํ ๋ ์ค๋ณต๋์ง ์๋ 6๊ฐ์ ์ซ์๋ฅผ ๋ฝ๋๋ค. (๋ก๋ 1์ฅ์ ๊ฐ๊ฒฉ์ 1,000์์ด๋ค.)
- ๋น์ฒจ ๋ฒํธ ์ถ์ฒจ ์ ์ค๋ณต๋์ง ์๋ ์ซ์ 6๊ฐ์ ๋ณด๋์ค ๋ฒํธ 1๊ฐ๋ฅผ ๋ฝ๋๋ค.
- ๋น์ฒจ์ 1๋ฑ๋ถํฐ 5๋ฑ๊น์ง ์๋ค.
- 1๋ฑ: 6๊ฐ ๋ฒํธ ์ผ์น / 2,000,000,000์
- 2๋ฑ: 5๊ฐ ๋ฒํธ + ๋ณด๋์ค ๋ฒํธ ์ผ์น / 30,000,000์
- 3๋ฑ: 5๊ฐ ๋ฒํธ ์ผ์น / 1,500,000์
- 4๋ฑ: 4๊ฐ ๋ฒํธ ์ผ์น / 50,000์
- 5๋ฑ: 3๊ฐ ๋ฒํธ ์ผ์น / 5,000์
- ์ฌ์ฉ์๊ฐ ๊ตฌ๋งคํ ๋ก๋ ๋ฒํธ์ ๋น์ฒจ ๋ฒํธ๋ฅผ ๋น๊ตํ์ฌ ๋น์ฒจ ๋ด์ญ ๋ฐ ์์ต๋ฅ ์ ์ถ๋ ฅํ๊ณ ๋ก๋ ๊ฒ์์ ์ข ๋ฃํ๋ค.
์ถ๊ฐ๋ ์๊ตฌ ์ฌํญ์ ์๋์ ๊ฐ๋ค.
- ํจ์(๋๋ ๋ฉ์๋)์ ๊ธธ์ด๊ฐ 15๋ผ์ธ์ ๋์ด๊ฐ์ง ์๋๋ก ๊ตฌํํ๋ค.
- else ์์ฝ์ด๋ฅผ ์ฐ์ง ์๋๋ค.
- Java Enum์ ์ ์ฉํ๋ค.
2. ๐ข ๊ณตํต ํผ๋๋ฐฑ
1) ๋ฐ์ํ ์ ์๋ ์์ธ ์ํฉ์ ๋ํด ๊ณ ๋ฏผํ๋ค.
์ ์์ ์ธ ๊ฒฝ์ฐ๋ฅผ ๊ตฌํ ํ๋ ๊ฒ๋ณด๋ค ์์ธ ์ํฉ์ ๋ชจ๋ ๊ณ ๋ คํด ํ๋ก๊ทธ๋๋ฐํ๋ ๊ฒ์ด ๋ ์ด๋ ต๋ค. ์์ธ ์ํฉ์ ๊ณ ๋ คํด ํ๋ก๊ทธ๋๋ฐํ๋ ์ต๊ด์ ๋ค์ธ๋ค. ์ด๋ฒ ๊ณผ์ ์ ์์ธ ์ํฉ์ ์๋์ ๊ฐ์ ๊ฒ๋ค์ด ์๋ค.
- ๋ก๋ ๊ตฌ์ ๊ธ์ก์ 1000 ์ดํ์ ์ซ์๋ฅผ ์ ๋ ฅํ๋ ๊ฒฝ์ฐ
- ๋น์ฒจ ๋ฒํธ์ ์ค๋ณต๋ ์ซ์๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ
- ๋น์ฒจ ๋ฒํธ์ 1 ~ 45 ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ ์ซ์๋ฅผ ์ ๋ ฅํ๋ ๊ฒฝ์ฐ
- ๋น์ฒจ ๋ฒํธ์ ์ค๋ณต๋ ๋ณด๋์ค ๋ฒํธ๋ฅผ ์ ๋ ฅํ๋ ๊ฒฝ์ฐ
2) ๋น์ฆ๋์ค ๋ก์ง๊ณผ UI ๋ก์ง์ ๋ถ๋ฆฌํ๋ค.
๋น์ฆ๋์ค ๋ก์ง๊ณผ UI ๋ก์ง์ ํ ํด๋์ค๊ฐ ๋ด๋นํ์ง ์๋๋ก ํ๋ค. ๋จ์ผ ์ฑ ์์ ์์น์๋ ์๋ฐฐ๋๋ค.
public class Lotto{
private List<Integer> numbers;
// ๋ก๋ ์ซ์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ ๋น์ฆ๋์ค ๋ก์ง
public boolean contains(int number){
...
}
// UI ๋ก์ง
private void print(){
...
}
}
ํ์ฌ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ณด๊ธฐ ์ํ ๋ก๊ทธ ๋ฉ์์ง ์ฑ๊ฒฉ์ด ๊ฐํ๋ค๋ฉด toString()์ ํตํด ๊ตฌํํ๋ค.
View์์ ์ฌ์ฉํ ๋ฐ์ดํฐ๋ผ๋ฉด getter ๋ฉ์๋๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๋ค.
3) ์ฐ๊ด์ฑ์ด ์๋ ์์๋ static final ๋์ enum์ ํ์ฉํ๋ค.
public enum Rank{
FIRST(6, 2_000_000_000),
SECOND(5, 30_000_000),
THIRD(5, 1_500_000),
FOURTH(4, 50_000),
FIFTH(3, 5_000),
MISS(0, 0);
private int countOfMatch;
private int winningMoney;
private Rank(int countOfMatch, int winningMoney){
this.countOfMatch = countOfMatch;
this.winningMoney = winningMoney;
}
}
4) final ํค์๋๋ฅผ ์ฌ์ฉํด ๊ฐ์ ๋ณ๊ฒฝ์ ๋ง๋๋ค.
์ต๊ทผ์ ๋ฑ์ฅํ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ค์ ๊ธฐ๋ณธ์ด ๋ถ๋ณ ๊ฐ์ด๋ค. ์๋ฐ๋ final ํค์๋๋ฅผ ํ์ฉํด ๊ฐ์ ๋ณ๊ฒฝ์ ๋ง์ ์ ์๋ค.
public class Money{
private final int amount;
public Money(int amount){
...
}
}
5) ๊ฐ์ฒด์ ์ํ ์ ๊ทผ์ ์ ํํ๋ค
์ธ์คํด์ค ๋ณ์์ ์ ๊ทผ ์ ์ด์๋ private๋ก ๊ตฌํํ๋ค.
public class WinningLotto{
private Lotto lotto;
private Integer bonusNumber;
public WinningLotto(Lotto lotto, Integer bonusNumber){
this.lotto = lotto;
this.bonusNumber = bonusNumber;
}
}
6) ๊ฐ์ฒด๋ ๊ฐ์ฒด์ค๋ฝ๊ฒ ์ฌ์ฉํ๋ค.
Lotto ํด๋์ค๋ numbers๋ฅผ ์ํ ๊ฐ์ผ๋ก ๊ฐ์ง๋ ๊ฐ์ฒด์ด๋ค. ๊ทธ๋ฐ๋ฐ ์ด ๊ฐ์ฒด๋ ๋ก์ง์ ๋ํ ๊ตฌํ์ ํ๋๋ ์๊ณ , numbers์ ๋ํ getter ๋ฉ์๋๋ง์ ๊ฐ์ง๋ค.
public class Lotto{
private final List<Integer> numbers;
public Lotto(List<Integer> numbers){
this.numbers = numbers;
}
public int getNumbers(){
return numbers;
}
}
public class LottoGame{
public void play(){
Lotto lotto = new Lotto(...);
// ์ซ์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ค.
lotto.getNumbers().contains(number);
// ๋น์ฒจ ๋ฒํธ์ ๋ช ๊ฐ๊ฐ ์ผ์นํ๋์ง ํ์ธํ๋ค.
lotto.getNumbers().stream()...
}
}
Lotto์์ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด์ง(get) ๋ง๊ณ ๋ฉ์์ง๋ฅผ ๋์ง๋๋ก ๊ตฌ์กฐ๋ฅผ ๋ฐ๊ฟ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๋ ๊ฐ์ฒด๊ฐ ์ผํ๋๋ก ํ๋ค.
public class Lotto{
private final List<Integer> numbers;
public boolean contains(int number){
// ์ซ์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ค.
...
}
public int matchCount(Lotto other){
// ๋น์ฒจ ๋ฒํธ์ ๋ช ๊ฐ๊ฐ ์ผ์นํ๋์ง ํ์ธํ๋ค.
...
}
}
public class LottoGame{
public void play(){
Lotto lotto = new Lotto(...);
lotto.contains(number);
lotto.matchCount(...);
}
}
7) ํ๋(์ธ์คํด์ค ๋ณ์)์ ์๋ฅผ ์ค์ด๊ธฐ ์ํด ๋ ธ๋ ฅํ๋ค.
ํ๋(์ธ์คํด์ค ๋ณ์)์ ์๊ฐ ๋ง์ ๊ฒ์ ๊ฐ์ฒด์ ๋ณต์ก๋๋ฅผ ๋์ด๊ณ , ๋ฒ๊ทธ ๋ฐ์ ๊ฐ๋ฅ์ฑ์ ๋์ผ ์ ์๋ค. ํ๋์ ์ค๋ณต์ด ์๊ฑฐ๋, ๋ถํ์ํ ํ๋๊ฐ ์๋์ง ํ์ธํด ํ๋์ ์๋ฅผ ์ต์ํํ๋ค.
์๋ฅผ ๋ค์ด ์ด ์๊ธ ๋ฐ ์์ต๋ฅ ์ ๊ตฌํ๋ ๋ค์ ๊ฐ์ฒด๋ฅผ ๋ณด์.
public class LottoResult{
private Map<Rank, Integer> result = new HashMap<>();
private double profitRate;
private int totalPrize;
}
์ ๊ฐ์ฒด์ profitRate์ totalPrize๋ ๋ฑ์ ๋ณ ๋น์ฒจ ๋ด์ญ(result)๋ง ์์ด๋ ๋ชจ๋ ๊ตฌํ ์ ์๋ ๊ฐ์ด๋ค. ๋ฐ๋ผ์ ์ ๊ฐ์ฒด๋ ๋ค์๊ณผ ๊ฐ์ด ํ๋์ ํ๋๋ง์ผ๋ก ๊ตฌํํ ์ ์๋ค.
public class LottoResult{
private Map<Rank, Integer> result = new HashMap<>();
public double calculateProfitRate(){ ... }
public int calculateTotalPrize(){ ... }
}
8) ํ ์คํธ ์ฝ๋๋ ์ฝ๋๋ค
ํ ์คํธ ์ฝ๋๋ ์ฝ๋์ด๋ฏ๋ก ๋ฆฌํฉํฐ๋ง์ ํตํด ๊ฐ์ ํด๋๊ฐ์ผ ํ๋ค. ํนํ ๋ฐ๋ณต์ ์ผ๋ก ํ๋ ๋ถ๋ถ์ ์ค๋ณต๋์ง ์๊ฒ ๋ง๋ค์ด์ผ ํ๋ค. ์๋ฅผ ๋ค์ด ๋จ์ํ ํ๋ผ๋ฏธํฐ์ ๊ฐ๋ง ๋ฐ๋๋ ๊ฒฝ์ฐ๋ผ๋ฉด ์๋์ ๊ฐ์ด ํ ์คํธํ ์ ์๋ค.
@DisplayNmae("์ฒ์ ๋ฏธ๋ง์ ๊ธ์ก์ ๋ํ ์์ธ ์ฒ๋ฆฌ")
@ValueSource(strings = {"999", "0", "-123"})
@ParameterizedTest
void underLottoPrice(Integer input){
assertThatThrownBy(() -> new Money(input))
.isInstanceof(IllegalArgumentException.class);
}
9) ํ ์คํธ๋ฅผ ์ํ ์ฝ๋๋ ๊ตฌํ ์ฝ๋์์ ๋ถ๋ฆฌ๋์ด์ผ ํ๋ค.
ํ ์คํธ๋ฅผ ์ํ ํธ์ ๋ฉ์๋๋ฅผ ๊ตฌํ ์ฝ๋์ ๊ตฌํํ์ง ๋ง๋ผ. ์๋์ ์์์ฒ๋ผ ํ ์คํธ๋ฅผ ํต๊ณผํ๊ธฐ ์ํด ๊ตฌํ ์ฝ๋๋ฅผ ๋ณ๊ฒฝํ๊ฑฐ๋ ํ ์คํธ์์๋ง ์ฌ์ฉ๋๋ ๋ก์ง์ ๋ง๋ค์ง ์๋๋ค.
- ํ ์คํธ๋ฅผ ์ํด ์ ๊ทผ ์ ์ด์๋ฅผ ๋ฐ๊พธ๋ ๊ฒฝ์ฐ
- ํ ์คํธ ์ฝ๋์์๋ง ์ฌ์ฉ๋๋ ๋ฉ์๋
10) ๋จ์ ํ ์คํธํ๊ธฐ ์ด๋ ค์ด ์ฝ๋๋ฅผ ๋จ์ ํ ์คํธํ๊ธฐ
์๋ ์ฝ๋๋ Random ๋๋ฌธ์ Lotto์ ๋ํ ๋จ์ ํ ์คํธ๋ฅผ ํ๊ธฐ ํ๋ค๋ค. ๋จ์ ํ ์คํธ๊ฐ ๊ฐ๋ฅํ๋๋ก ๋ฆฌํฉํฐ๋ง ํ๋ค๋ฉด ์ด๋ป๊ฒ ํ๋ ๊ฒ์ด ์ข์๊น?
public class Lotto{
private List<Integer> numbers;
public Lotto(){
this.numbers = Randoms.pickUniqueNumbersInRange(1, 45, 6);
}
}
-----------------------------------------
public class LottoMachine{
public void execut(){
Lotto lotto = new Lotto();
}
}
์ฌ๋ฐ๋ฅธ ๋ก๋ ๋ฒํธ๊ฐ ์์ฑ๋๋ ๊ฒ์ ํ ์คํธํ๊ธฐ ์ด๋ ต๋ค. ํ ์คํธํ๊ธฐ ์ด๋ ค์ด ๊ฒ์ ํด๋์ค ๋ด๋ถ๊ฐ ์๋ ์ธ๋ถ๋ก ๋ถ๋ฆฌํ๋ ์๋๋ฅผ ํด๋ณธ๋ค.
public class Lotto{
private List<Integer> numbers;
public Lotto(List<Integer> numbers){
this.numbers = numbers;
}
}
-----------------------------------------
public class LottoMachine{
public void execute(){
List<Integer> numbers = Randoms.pickUniqueNumbersInRange(1, 45, 6);
Lotto lotto = new Lotto(numbers);
}
}
์ด์ฒ๋ผ ๋จ์ ํ ์คํธ๋ฅผ ํ ๋ ํ ์คํธํ๊ธฐ ์ด๋ ค์ด ๋ถ๋ถ์ ๋ถ๋ฆฌํ๊ณ ํ ์คํธ ๊ฐ๋ฅํ ๋ถ๋ถ์ ๋จ์ ํ ์คํธํ๋ค. ํ ์คํธํ๊ธฐ ์ด๋ ค์ด ๋ถ๋ถ์ ๋จ์ ํ ์คํธํ์ง ์์๋ ๋๋ค. ๋จ์ LottoMachine์ ์ด๋ป๊ฒ ํ ์คํธํ๊ธฐ ์ฝ๊ฒ ๋ฐ๊ฟ ์ ์๋์ง ๊ณ ๋ฏผํด๋ณธ๋ค.
11) private ํจ์๋ฅผ ํ ์คํธํ๊ณ ์ถ๋ค๋ฉด ํด๋์ค(๊ฐ์ฒด) ๋ถ๋ฆฌ๋ฅผ ๊ณ ๋ คํ๋ค.
๊ฐ๋ ์ฑ์ ์ด์ ๋ง์ผ๋ก ๋ถ๋ฆฌํ private ํจ์์ ๊ฒฝ์ฐ public์ผ๋ก๋ ๊ฒ์ฆ ๊ฐ๋ฅํ๋ค๊ณ ์ฌ๊ฒจ์ง ์ ์๋ค. public ํจ์๊ฐ private ํจ์๋ฅผ ์ฌ์ฉํ๊ณ ์๊ธฐ ๋๋ฌธ์ ์์ฐ์ค๋ฝ๊ฒ ํ ์คํธ ๋ฒ์์ ํฌํจ๋๋ค. ํ์ง๋ง ๊ฐ๋ ์ฑ ์ด์์ ์ญํ ์ ํ๋ ๊ฒฝ์ฐ, ํ ์คํธํ๊ธฐ ์ฝ๊ฒ ๊ตฌํํ๊ธฐ ์ํด์๋ ํด๋น ์ญํ ์ ์ํํ๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๋ง๋ค ํ์ด๋ฐ์ด ์๋์ง ๊ณ ๋ฏผํด ๋ณผ ์ ์๋ค.
3. ๐ ๋ฐฐ์ด ์ & ๋๋ ์
- ์์ ๊ณตํต ํผ๋๋ฐฑ์ ํตํด์ ์ ์ ์๋ ๊ฒ์ฒ๋ผ ๊ฐ์ ํด์ผ ํ ์ ์ด ์์ฃผ ๋ง๋ค. ํนํ ํด๋์ค๋ฅผ ์ด๋ป๊ฒ ํ๋ฉด ์ ๋ถ๋ฆฌํ๋์ง์ ๋ํ ํ์ต์ด ํ์ํ๋ค.
- ์ด์ ๊น์ง๋ enum์ ๋จ์ ์ด๊ฑฐํ๋ ํํ๋ก ์ฌ์ฉํ๋๋ฐ ์ด๋ฒ ๊ธฐํ๋ฅผ ํตํด์ enum์ ํด๋์ค์ฒ๋ผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ตํ ์ ์์๋ค.