์๋ฐ 2๋ฒ์งธ ๊ณผ์ ๊ฐ ๋ฐ์ ๋์๋ค.
์ด๋ฒ ๊ณผ์ ๋ ํ์ ๊ตฌํ 5๋จ๊ณ์ ๋์ ๊ตฌํ 2๋จ๊ณ๋ก ๋๋์ด์ ธ์๋ค.
์์ ๋จ๊ณ๋ฅผ ์ข
ํฉํ์ฌ ์ต์ข
์ ์ผ๋ก ๊ณผ์ ๋ฅผ ๋ง๋ฌด๋ฆฌํ๊ธฐ์ ๋์ lv2๋ฅผ ๊ธฐ์ค์ผ๋ก TIL ์ ์์ฑํด๋ณด๋ ค ํ๋ค.
Main : ๋ฉ์ธ ๋ฉ์๋๋ฅผ ๊ฐ์ง ํด๋์คMenu: MenuItem ํด๋์ค๋ฅผ ๊ด๋ฆฌํ๋ ํด๋์คMenuItem: ์ธ๋ถ ๋ฉ๋ด ์์ฑ ๊ฐ์ง๋ ํด๋์คKiosk: ํ๋ก๊ทธ๋จ ์์ ๋ฐ ํ๋ฆ ์ ์ด๋ฅผ ๋ด๋นํ๋ ํด๋์คCustomerType: ์ฌ์ฉ์ ์ ํ๋ณ ํ ์ธ์จ์ ๊ด๋ฆฌํ๋ enum ํด๋์ค์์ธ ์ฒ๋ฆฌ
๋๋ค & ์คํธ๋ฆผ์ ํ์ฉํ ๊ธฐ๋ฅ ๊ตฌํ
ํ ์ธ ๊ธฐ๋ฅ ๊ตฌํ
enum ์ ์ ์ ํ๊ณ ์ ํ์ ๋ฐ๋ฅธ ํ ์ธ์จ ์ ์ฉ์
๋ ฅ ์ฒ๋ฆฌํ ์ผ์ด ๋ง์์ง๊ณ ์ฝ๋๊ฐ ์ ์ ๊ธธ์ด์ง๋ฉด์ try-catch ๋ฅผ ์ด์ฉํ ์์ธ ์ฒ๋ฆฌ๊ฐ ์ ์ ์ด๋ ค์์ก๋ค.
ํนํ ๋ฐ๋ณต๋ฌธ ์ ์ฒด๋ฅผ try ๋ธ๋ก์ผ๋ก ๊ฐ์ธ๋ ๋ฐฉ์์ด ์ ์ง๋ณด์์ ๋งค์ฐ ๋ถํธํ ๊ตฌ์กฐ๋ฅผ ๋ง๋ค์๊ณ ํด๋น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ๋ฐฉ๋ฒ์ด ํ์ํ๋ค.
์ด ๊ณ ๋ฏผ์ ์บ ํ๋ฅผ ํจ๊ป ์งํ ์ค์ธ ๋๋ฃ์ ์กฐ์ธ ๋๋ถ์ ํด๊ฒฐํ ์ ์์๋ค.
์ง๊ธ๊น์ง๋ ์
๋ ฅ์ ๋ฐ์ ๋ Scanner์ ๋ฉ์๋๋ฅผ ์ง์ ํธ์ถํ๋ ๋ฐฉ์๋ง ์ฌ์ฉํด์์ง๋ง ์
๋ ฅ ์ ์ฉ ๋ฉ์๋๋ฅผ ๋ฐ๋ก ๋ถ๋ฆฌํ๋ฉด ์์ธ ์ฒ๋ฆฌ๋ ์กฐ๊ฑด ๊ฒ์ฆ ๋ฑ ๋ด๊ฐ ์ํ๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํ์ฌ ๋ณด๋ค ์ ์ฐํ๊ฒ ์ ์ดํ ์ ์๋ค๋ ๊ฒ์ ์๊ฒ ๋์๋ค.
public static int getInput(int firstIndex, int lastIndex) {
while (true) {
try {
int input = sc.nextInt();
if (input < firstIndex || input > lastIndex) {
throw new IndexOutOfBoundsException();
}
return input;
} catch (InputMismatchException e) {
System.out.println("์ซ์๋ง ์
๋ ฅํด์ฃผ์ธ์");
sc.nextLine(); //๋ฒํผ๋น์ฐ๊ธฐ ์๋น์ฐ๋ฉด ํฐ์ผ๋จ
} catch (IndexOutOfBoundsException e) {
System.out.println("์ ํ์ง๋ฅผ ํ์ธํด์ฃผ์ธ์");
}
}
}
์
๋ ฅ์ ์ ๋ดํ๋ getInput() ๋ฉ์๋๋ฅผ ๋ฐ๋ก ๋ถ๋ฆฌํ์ฌ ์
๋ ฅ๊ฐ์ ๋ํ ์์ธ ์ฒ๋ฆฌ๋ฅผ ๋ณด๋ค ์ ์ฐํ๊ณ ๋ช
ํํ๊ฒ ์ ์ดํ ์ ์๋๋ก ์ค๊ณํ๋ค.
์ด ๋ฉ์๋๋ ์ฌ์ฉ์๊ฐ ์
๋ ฅํ ์ซ์๊ฐ ์ง์ ํ ๋ฒ์๋ฅผ ๋ฒ์ด๋ ๊ฒฝ์ฐ ์ง์ IndexOutOfBoundsException์ ๋ฐ์์์ผ ์์ธ๋ฅผ ๊ฐ์งํ๊ณ
์ ์๊ฐ ์๋ ๊ฐ์ด ๋ค์ด์ฌ ๊ฒฝ์ฐ InputMismatchException์ ํตํด ์๋ชป๋ ์
๋ ฅ์ ์๋ดํ๋ค.
๊ธฐ์กด์๋ ์ ๋ ฅ์ ๋ํ ์์ธ๋ฅผ ๋ฐ๋ณต๋ฌธ ์ ์ฒด๋ฅผ ๊ฐ์ธ ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ์ฝ๋๊ฐ ์ฅํฉํ๊ณ ์ ์ง๋ณด์๊ฐ ์ด๋ ค์ ์ง๋ง ์ ๋ ฅ ์ฒ๋ฆฌ๋ฅผ ๋ฉ์๋๋ก ๋ถ๋ฆฌํ๊ณ ์์ธ๋ฅผ ๊ฐ๋ณ์ ์ผ๋ก ์ฒ๋ฆฌํจ์ผ๋ก์จ ๊ฐ๋ ์ฑ๊ณผ ์ฌ์ฌ์ฉ์ฑ ๋ชจ๋ ํฅ์๋๋ ํจ๊ณผ๋ฅผ ์ป์ ์ ์์๋ค.
๋๋ค์ ์คํธ๋ฆผ์ ํ์ฉํด์ ํด๋น ๊ธฐ๋ฅ์ ๊ตฌํํ๋ ๊ฒ์ด ์๊ตฌ์ฌํญ์ด๋ค.
Consumer<List<MenuItem>> myConsumer1 = menuItemList -> {
IntStream.range(0, menuItemList.size()).forEach(i -> {
MenuItem m = menuItemList.get(i);
System.out.println((i + 1) + ". " + m.toString());
});
};
myConsumer1.accept(chooseMenu.getMenuItemList());
menuItemList ์์ item์ ๋ฝ์ ์ถ๋ ฅํ๋ ๋๋ค์์ด๋ค.
Consumer<>๋ ํ๋์ ์ธ์๋ฅผ ๋ฐ์ ์ฒ๋ฆฌ๋ง ํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ์ง ์๋ ํจ์ํ ์ธํฐํ์ด์ค๋ก java.util.function ํจํค์ง์ ๋ฏธ๋ฆฌ ์ ์๋์ด ์์ด ๋ณ๋ ๊ตฌํ ์์ด import ๋ง์ผ๋ก ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋ค.
์ ์ํ ๋๋ค์์ accept() ๋ฉ์๋๋ฅผ ํตํด ์คํ๋๋ค.
์ด๊ธฐ์๋ Stream.forEach()๋ฅผ ์ฌ์ฉํด ์ถ๋ ฅํ๋ ค ํ์ง๋ง ํญ๋ชฉ๋ง๋ค ์ธ๋ฑ์ค๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ๋ฒํธ๋ฅผ ์ถ๋ ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ฒ์๋ฅผ ์ ์ดํ ์ ์๋ IntStream.range()๋ก ๋ฐฉํฅ์ ๋ฐ๊ฟ ๊ตฌํํ๋ค.
๊ตฌ์กฐ ๋ณ๊ฒฝ์ ํตํด ๋ฆฌ์คํธ์ ์ธ๋ฑ์ค๋ฅผ ํ์ฉํ์ฌ "1. ํญ๋ชฉ" ํ์์ผ๋ก ์ถ๋ ฅ์ด ๊ฐ๋ฅํ๊ฒ ํ๋ค.
BiFunction<String, List<MenuItem>, Boolean> myFunction1 = (inputString, orders) ->
orders.removeIf(m -> inputString.equals(m.getItemName()));
sc.nextLine();//๋ค์์
๋ ฅ์ด nextLine ์ด๊ธฐ์ ๋ฒํผ ๋น์ฐ๊ธฐ
while (true) {
System.out.println("์ญ์ ํ ๋ฉ๋ด์ ์ด๋ฆ์ ์
๋ ฅํ์ธ์.(๋์๋ฌธ์ ๊ตฌ๋ถ)");
if (myFunction1.apply(sc.nextLine(), order.getOrders())) {
System.out.println("์ญ์ ์๋ฃ");
break;
}
System.out.println("์
๋ ฅํ ๋ฉ๋ด๋ช
์ ํ์ธํด์ฃผ์ธ์.");
}
์ฃผ๋ฌธ๋ชฉ๋ก์ ๋ค์ด์๋ menuItem ์ ์ญ์ ํ๋ ๋๋ค์์ด๋ค.
์ฒ์์๋ BiConsumer<>์ ์ฌ์ฉํ์ฌ ๋ฌธ์์ด๊ณผ ์ฃผ๋ฌธ ๋ชฉ๋ก์ ๋ฐ์ ์ผ์นํ๋ ํญ๋ชฉ์ ์ญ์ ํ์ง๋ง ์ญ์ ์ฑ๊ณต ์ฌ๋ถ์ ๋ฐ๋ผ ์ถ๊ฐ ๋์(๋ฐ๋ณต๋ฌธ ์ข
๋ฃ)์ ์ ์ดํ ํ์๊ฐ ์์ด ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํ ์ ์๋ BiFunction์ผ๋ก ๋ณ๊ฒฝํ๋ค.
BiFunction<T, U, R> ์ ๋ ๊ฐ์ ์
๋ ฅ(T, U)์ ๋ฐ์ ํ๋์ ๊ฒฐ๊ณผ(R)์ ๋ฐํํ๋ ํจ์ํ ์ธํฐํ์ด์ค์ด๊ณ .removeIf()๋ ์กฐ๊ฑด์ ๋ง๋ ์์๋ฅผ ์ ๋ถ ์ ๊ฑฐํ๊ณ ํ๋๋ผ๋ ์ ๊ฑฐ๋๋ฉด true, ์๋ฌด ๊ฒ๋ ์ ๊ฑฐ๋์ง ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ ๋ฉ์๋์ด๋ค.
.removeIf() ๋ฉ์๋๋ฅผ ํตํด MenuItem์ itemName ๊ณผ ์
๋ ฅ๊ฐ์ด ์ผ์นํ๋ ํญ๋ชฉ์ ์ ๊ฑฐํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ก ์ญ์ ์ฌ๋ถ๋ฅผ ๋ฐํํ๋๋ก ๊ตฌ์ฑํ๋ค.
์ด ๋ฐํ๊ฐ์ ํตํด ์ญ์ ์ฌ๋ถ๋ฅผ ํ๋จํ๊ณ ์ฑ๊ณต ์ ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃํ๊ฑฐ๋ ์คํจ ์ ์ฌ์ฉ์์๊ฒ ์ฌ์
๋ ฅ์ ์ ๋ํ๋ ๊ตฌ์กฐ๋ก ๊ตฌํํ์๋ค.
public enum CustomerType {
VETERAN(0.1), SOLDIER(0.05), STUDENT(0.03), BASIC(0);
private double discountPercent;
CustomerType(double discountPercent) {
this.discountPercent = discountPercent;
}
public double discountPrice(double price) {
return price - (price * discountPercent);
}
public static CustomerType gradeChoice(int input) {
switch (input) {
case 1:
return CustomerType.VETERAN;
case 2:
return CustomerType.SOLDIER;
case 3:
return CustomerType.STUDENT;
case 4:
return CustomerType.BASIC;
default:
throw new IllegalArgumentException("์ ํ์ง๋ฅผ ํ์ธํ์ธ์");
}
}
}
์ฌ์ฉ์ ์ ํ์ ๋ฐ๋ผ ํ ์ธ๋ฅ ์ ์ ์ฉํ๊ธฐ ์ํ enum ํด๋์ค์ด๋ค.
VETERAN, SOLDIER, STUDENT, BASIC ๋ค ๊ฐ์ง ์ ํ์ ์์๋ก ์ ์ํ๊ณ ๊ฐ ์ฌ์ฉ์ ์ ํ์
๊ณ ์ ๋ ํ ์ธ ๋น์จ(discountPercent)์ ๊ฐ์ง๋ค.
discountPrice() ๋ฉ์๋๋ ํด๋น ์ฌ์ฉ์ ์ ํ์ ํ ์ธ ๋น์จ์ ์ ์ฉํ์ฌ ์ต์ข
๊ฒฐ์ ๊ธ์ก์ ๋ฐํํ๋ ๊ธฐ๋ฅ์ ํ๋ค.
๋ํ gradeChoice() ์ ์ ๋ฉ์๋๋ฅผ ํตํด ์ฌ์ฉ์์ ์
๋ ฅ์ ๋ง๋ ์ ํ์ ๋งคํํ ์ ์๋๋ก ํ๋ค.
์์ ๊ณ์ฐ๊ธฐ ํ๋ก์ ํธ์ ๋นํด ํจ์ฌ ๋ง์ ์๊ฐ์ด ๋ค์ด๊ฐ๊ณ ๊ทธ๋งํผ ๋ง์ ์ํ์ฐฉ์ค๋ ๊ฒช์๋ค.
ํค์ค์คํฌ ํ๋ก์ ํธ๋ฅผ ์์ํ๊ธฐ ์ ์๋ ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ๊ทธ์ ํด๊ฒฐํ๋ ๋ฐ๋ง ๊ธ๊ธํ๊ณ ๋ด๊ฐ ๊ณต๋ถ ์ค์ธ ์๋ฐ์ ํต์ฌ ๊ฐ๋
์ธ ๊ฐ์ฒด์งํฅ์ ๋ํด์๋ ๊น์ด ๊ณ ๋ฏผํด๋ณธ ์ ์ด ์์๋ ๊ฒ ๊ฐ๋ค.
ํ์ง๋ง ์ฌ๋ฌ ์ฌ๋๊ณผ ํผ๋๋ฐฑ์ ์ฃผ๊ณ ๋ฐ์ผ๋ฉฐ ๋ฌธ์ ๋ฅผ ํ์ด๊ฐ๋ ๊ณผ์ ์ ํตํด ์กฐ๊ธ์ด๋๋ง ๊ฐ์ฒด์งํฅ์ ์ธ ์ฌ๊ณ ๋ก ์ ๊ทผํ ์ ์๋ ๊ณ๊ธฐ๊ฐ ๋์๋ค.
๋ํ ํผ์ ๋๋๋๋ฉฐ ๊ณต๋ถํ๋ ๊ฒ์ด ์ผ๋ง๋ ๋นํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ธ์ง๋ ๋๋ ์ ์์๊ธฐ์ ๋ง์ ๊ฒ์ ์ป์ ์๊ฐ์ด์๋ค๊ณ ์๊ฐ๋๋ค.
ํค์ค์คํฌ ํ๋ก์ ํธ