Lv1 ํธ๋ฌ๋ธ ์ํ
- ๋ฌธ์ ์ํฉ
- Scanner๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ฉ์ ์ ๋ ฅ์ ์ฒ๋ฆฌํ๋ ์ค, nextInt( ) ๋ค์ nextLine( )์ ํธ์ถํ๊ฒ ๋๋ฉด ์๋์น ์๊ฒ ๋น ์ ๋ ฅ์ด ์ฒ๋ฆฌ๋๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
- nextInt( )๊ฐ ์ซ์ ์ ๋ ฅ ๋ค ๋จ์ ์๋ ์ค ๋ฐ๊ฟ ๋ฌธ์(\n)๋ฅผ ์๋นํ์ง ์์์ ์๊ธฐ๋ ๋ฌธ์ ์๋ค.
- ๋ฌธ์ ์์ธ
- nextInt( )๋ ์ซ์๋ง ์ฝ๊ณ , ์ค ๋ฐ๊ฟ ๋ฌธ์(\n)๋ ์ ๋ ฅ ๋ฒํผ์ ๋จ๊ฒจ๋๋ค.
- ์ดํ nextLine( )์ด ํธ์ถ๋๋ฉด ์ ๋ ฅ ๋ฒํผ์ ๋จ์ ์๋ ์ค ๋ฐ๊ฟ ๋ฌธ์๋ง ์ฝ์ด์ ๋น ๋ฌธ์์ด์ ๋ฐํํ๊ฒ ๋๋ค.
- ๋ฌธ์ ์ํฉ ์ฝ๋
// ์ฒซ ๋ฒ์งธ ์ ์ ์
๋ ฅ ๋ฐ๊ธฐ ์ ์๋ด ๋ฌธ๊ตฌ ์ถ๋ ฅ
System.out.print("์ฒซ ๋ฒ์งธ ์ ์ ์
๋ ฅ(0 ํฌํจ) : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ์์ ์ ์๋ฅผ firstNumber ๋ณ์์ ํ ๋น
int firstNumber = scanner.nextInt();
// ๋ ๋ฒ์งธ ์ ์ ์
๋ ฅ ๋ฐ๊ธฐ ์ ์๋ด ๋ฌธ๊ตฌ ์ถ๋ ฅ
System.out.print("๋ ๋ฒ์งธ ์ ์ ์
๋ ฅ(0 ํฌํจ) : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ์์ ์ ์๋ฅผ secondNumber ๋ณ์์ ํ ๋น
int secondNumber = scanner.nextInt();
// ์ฌ์น์ฐ์ฐ ๊ธฐํธ(+, -, *, /) ์
๋ ฅ ๋ฐ๊ธฐ ์ ๋ฌธ๊ตฌ
System.out.println("์ฌ์น์ฐ์ฐ ๊ธฐํธ(+, -, *, /) ์
๋ ฅ : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ๋ฌธ์์ด์ operator ๋ณ์์ ํ ๋น
String operator = scanner.nextLine(); // ์ค๋ฐ๊ฟ ๋ฌธ์ ๋ฐ์
์ ์ฝ๋๋ฅผ ์คํํ๋ฉด ์ ์ํ ์ซ์ ์ ๋ ฅ ํ ๋ฌธ์์ด ์ ๋ ฅ์ ๊ธฐ๋ค๋ฆฌ์ง ์๊ณ ๋น ๋ฌธ์์ด์ด ์ถ๋ ฅ๋๋ค.
- ํด๊ฒฐ ๋ฐฉ๋ฒ
- ๋ฐฉ๋ฒ 1 : nextLine( ) ํธ์ถ๋ก ์ค๋ฐ๊ฟ ๋ฌธ์ ์๋นํ๊ธฐ
- nextLine( ) ํธ์ถ ํ, ๋จ์ ์๋ ์ค๋ฐ๊ฟ ๋ฌธ์๋ฅผ ์๋นํ๊ธฐ ์ํด์ scanner.nextLine( )์ ํ ๋ฒ ํธ์ถํ๋ค.
// ์ฒซ ๋ฒ์งธ ์ ์ ์
๋ ฅ ๋ฐ๊ธฐ ์ ์๋ด ๋ฌธ๊ตฌ ์ถ๋ ฅ
System.out.print("์ฒซ ๋ฒ์งธ ์ ์ ์
๋ ฅ(0 ํฌํจ) : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ์์ ์ ์๋ฅผ firstNumber ๋ณ์์ ํ ๋น
int firstNumber = scanner.nextInt();
// ๋ ๋ฒ์งธ ์ ์ ์
๋ ฅ ๋ฐ๊ธฐ ์ ์๋ด ๋ฌธ๊ตฌ ์ถ๋ ฅ
System.out.print("๋ ๋ฒ์งธ ์ ์ ์
๋ ฅ(0 ํฌํจ) : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ์์ ์ ์๋ฅผ secondNumber ๋ณ์์ ํ ๋น
int secondNumber = scanner.nextInt();
// ์ค๋ฐ๊ฟ ๋ฌธ์ ์๋น
scanner.nextLine();
// ์ฌ์น์ฐ์ฐ ๊ธฐํธ(+, -, *, /) ์
๋ ฅ ๋ฐ๊ธฐ ์ ๋ฌธ๊ตฌ
System.out.println("์ฌ์น์ฐ์ฐ ๊ธฐํธ(+, -, *, /) ์
๋ ฅ : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ๋ฌธ์์ด์ operator ๋ณ์์ ํ ๋น
String operator = scanner.nextLine(); // ์ค๋ฐ๊ฟ ๋ฌธ์ ๋ฐ์
- ๋ฐฉ๋ฒ 2 : next( ). charAt(0) ํ์ฉํ๊ธฐ
- ๊ณต๋ฐฑ์ด๋ ์ค๋ฐ๊ฟ ๋ฌธ์๋ฅผ ๋ฌด์ํ๋ next( )๋ฅผ ์ฌ์ฉํด ์ ๋ ฅ์ ๋ฐ๊ณ , ์ฒซ ๊ธ์๋ง ์ถ์ถํ๋ค.
- ์ด๋ ๊ฒ ํ๋ฉด ์ค๋ฐ๊ฟ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ง ์๋๋ค.
// ์ฒซ ๋ฒ์งธ ์ ์ ์
๋ ฅ ๋ฐ๊ธฐ ์ ์๋ด ๋ฌธ๊ตฌ ์ถ๋ ฅ
System.out.print("์ฒซ ๋ฒ์งธ ์ ์ ์
๋ ฅ(0 ํฌํจ) : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ์์ ์ ์๋ฅผ firstNumber ๋ณ์์ ํ ๋น
int firstNumber = scanner.nextInt();
// ๋ ๋ฒ์งธ ์ ์ ์
๋ ฅ ๋ฐ๊ธฐ ์ ์๋ด ๋ฌธ๊ตฌ ์ถ๋ ฅ
System.out.print("๋ ๋ฒ์งธ ์ ์ ์
๋ ฅ(0 ํฌํจ) : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ์์ ์ ์๋ฅผ secondNumber ๋ณ์์ ํ ๋น
int secondNumber = scanner.nextInt();
// ์ฌ์น์ฐ์ฐ ๊ธฐํธ(+, -, *, /) ์
๋ ฅ ๋ฐ๊ธฐ ์ ๋ฌธ๊ตฌ
System.out.println("์ฌ์น์ฐ์ฐ ๊ธฐํธ(+, -, *, /) ์
๋ ฅ : ");
// ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ ๋ฐ์ ๋ฌธ์์ด์์ ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ ๋ฌธ์(์ฐ์ฐ ๊ธฐํธ)๋ฅผ operator ๋ณ์์ ํ ๋น
char operator = scanner.next().charAt(0);
- ๊ฒฐ๋ก
- ์ํฉ์ ๋ฐ๋ผ ์ ํฉํ ๋ฐฉ๋ฒ ์ ํํ๊ธฐ
- ๋ฌธ์ฅ ์ ๋ ฅ์ฒ๋ผ ์ฌ๋ฌ ๊ธ์๋ฅผ ๋ฐ๋ ๊ฒฝ์ฐ : scanner.nextLine( ) ์ฌ์ฉ.
- ์ฌ์น์ฐ์ฐ ๊ธฐํธ์ฒ๋ผ ๋ช ํํ ์ฒซ ๊ธ์๋ง ํ์ํ ๊ฒฝ์ฐ : scanner.next( ).charAt(0) ์ฌ์ฉ.
- ์ํฉ์ ๋ฐ๋ผ ์ ํฉํ ๋ฐฉ๋ฒ ์ ํํ๊ธฐ
- ๋ฌธ์ ์ํฉ
- ์ฌ์ฉ์์๊ฒ ํ๋ก๊ทธ๋จ ์ข ๋ฃ ์ฌ๋ถ๋ฅผ ๋ฌป๋ ์ฝ๋๋ฅผ ๋ฐ๋ณต๋ฌธ ์์ ๋ฃ์์ง๋ง ์ฝ๋๋ฅผ ๋ฐ๋ณต๋ฌธ์ ์์ ๋ถ๋ถ์ ๋ฐฐ์นํ์ ๋ ํ๋ก๊ทธ๋จ ์คํ ์ ์ ์ข ๋ฃ ์ฌ๋ถ๋ฅผ ๋ฌป๋ ๋นํจ์จ์ ์ธ ํ๋ฆ์ด ๋ฐ์ํ๋ค.
- ๋ฌธ์ ์์ธ
- ํ๋ก๊ทธ๋จ์ ์คํ ํ๋ฆ๊ณผ ๋ง์ง ์๊ฒ ๋ฐ๋ณต๋ฌธ ์์ ๋ถ๋ถ์ ์ข ๋ฃ ์ฌ๋ถ๋ฅผ ๋ฌป๋ ์ฝ๋๋ฅผ ์์ฑํ์ฌ ์๋์ ๋ฌ๋ผ์ก๋ค.
- ์ข ๋ฃ ์ฌ๋ถ๋ฅผ ๋ง์ง๋ง์ ๋ฌผ์ด๋ณด๋ ๊ฒ์ด ๋ ์์ฐ์ค๋ฌ์ด ํ๋ฆ์ด์๋ค.
- ํด๊ฒฐ ๋ฐฉ๋ฒ
- ์ข ๋ฃ ์ฌ๋ถ๋ฅผ ๋ฌป๋ ์ฝ๋๋ฅผ ๋ฐ๋ณต๋ฌธ์ ๋ง์ง๋ง ๋ถ๋ถ์ผ๋ก ์ด๋ํด์ ์ฌ์น์ฐ์ฐ, ์ ์ฅ, ์ญ์ ์์ ์ ์๋ฃํ ํ ์ข ๋ฃ ์ฌ๋ถ๋ฅผ ๋ฌป๋๋ก ์์ ํ๋ค.
- ํ๋ก๊ทธ๋จ ์์ ํ๋ฆ์ด ๋ ์์ฐ์ค๋ฝ๊ฒ ๋ฐ๋์๋ค.
- ๊ฒฐ๋ก
- ํ๋ก๊ทธ๋จ ์ข ๋ฃ ์ฌ๋ถ๋ฅผ ๋ฌป๋ ์ฝ๋๋ฅผ ๋ฐ๋ณต๋ฌธ์ ์์ ๋ถ๋ถ์์ ๋ง์ง๋ง ๋ถ๋ถ์ผ๋ก ์ด๋ํ๋ฉด์ ์์ ํ๋ฆ์ด ์์ฐ์ค๋ฝ๊ฒ ๊ฐ์ ๋์๋ค.
- ์ด๋ฅผ ํตํด ์ฌ์ฉ์์ ์ ์ฅ์์ ์๊ฐํด๋ณด๋ ์ ์ด ์ค์ํ๋ค๋ ๊ฒ์ ์๊ฒ ๋์๋ค.
Lv2 ํธ๋ฌ๋ธ ์ํ
- ๋ฌธ์ ์ํฉ
- ์ฌ์น์ฐ์ฐ(๋ง์ , ๋บ์ , ๊ณฑ์ , ๋๋์ )์ ์ํํ๋ ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ ์ค, ๋๋์ ์ฐ์ฐ ์ ๋ถ๋ชจ๊ฐ 0์ธ ๊ฒฝ์ฐ ํ๋ก๊ทธ๋จ์ด ArithmeticException์ผ๋ก ์ข ๋ฃ๋๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
- ๋ฌธ์ ์์ธ
- ์ฌ์ง์ฐ์ฐ์ ์ํํ๋ operate ๋ฉ์๋๋ฅผ ์์ฑํ์ง๋ง, ๋๋์ ์ฐ์ฐ ์ ๋ถ๋ชจ๊ฐ 0์ธ ๊ฒฝ์ฐ ์ฒ๋ฆฌํด์ฃผ๋ ์กฐ๊ฑด๋ฌธ์ ์์ฑํ์ง ์์๋ค.
- ๋ถ๋ชจ๊ฐ 0์ธ์ง ํ์ธํ๋ ๊ฒ์ฆ ๋ก์ง์ด ์์๋ค.
- ๋ถ๋ชจ๊ฐ 0์ผ ๊ฒฝ์ฐ ArithmeticException์ด ๋ฐ์ํ๋ค.
- ๋ฌธ์ ์ํฉ ์ฝ๋
operate ๋ฉ์๋
// ์ฌ์น์ฐ์ฐ์ ์ํํ๋ ๋ฉ์๋
public int operate (int firstNumber, int secondNumber, char operator) {
int result = 0;
switch (operator) {
case '+' :
result = firstNumber + secondNumber;
break;
case '-' :
result = firstNumber - secondNumber;
break;
case '*' :
result = firstNumber * secondNumber;
break;
case '/' :
result = firstNumber / secondNumber;
break;
default :
System.out.println("์๋ชป๋ ์ฌ์น์ฐ์ฐ ๊ธฐํธ์
๋๋ค. ๋ค์ ์
๋ ฅํด์ฃผ์ธ์.");
}
return result;
}
App ํด๋์ค์์ ๋ฉ์๋ ํ์ฉ
int result = calculatorLv2.operate(firstNumber, secondNumber, operator);
secondNumber์ 0์ด ๋ค์ด์ค๋ฉด ArithmeticException์ด ๋ฐ์ํ๋ฉด์ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋๋ค.
- ํด๊ฒฐ ๋ฐฉ๋ฒ
- ๋ฉ์๋๋ฅผ ํธ์ถํ๊ธฐ ์ ์ ์
๋ ฅ๊ฐ ๊ฒ์ฆํ๊ธฐ
- ์ฌ์ฉ์ ์ ๋ ฅ์ ๋ฐ์ ํ if ์กฐ๊ฑด๋ฌธ์ ์ฌ์ฉํด์ secondNumber๊ฐ 0์ด๊ณ ์ฐ์ฐ์๊ฐ ๋๋์ (/)์ธ ๊ฒฝ์ฐ ๋ค์ ์ ๋ ฅ์ ์์ฒญํ๋ค.
- ์๋ชป๋ ์ ๋ ฅ์ ๋ฐ๋ณต์ ์ผ๋ก ํ์ธํด์ ์ฌ๋ฐ๋ฅธ ๊ฐ์ ๋ฐ์ ์ ์๋๋ก ๊ตฌํํ๋ค.
// ๋๋์
์ฐ์ฐ ์ ๋ถ๋ชจ์ 0 ์
๋ ฅ๋์ด ์์ ๊ฒฝ์ฐ ์ฒ์์ผ๋ก ๋์๊ฐ๊ฒ ์ค์
// if ์กฐ๊ฑด๋ฌธ์ผ๋ก ํ์ฌ ์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๊ฐ ํ์ธ ํ ๊ฒฐ์
if (secondNumber == 0 && operator == '/') {
System.out.println("๋๋์
์ฐ์ฐ์์ ๋ถ๋ชจ(๋ ๋ฒ์งธ ์ ์)์ 0์ด ์
๋ ฅ๋ ์ ์์ต๋๋ค.");
continue;
}
// ์
๋ ฅ ๋ฐ์ ์์ ์ ์์ ์ฌ์น์ฐ์ฐ ๊ธฐํธ๋ฅผ ์ฌ์ฉํด์ if ์กฐ๊ฑด๋ฌธ์ ํตํด ๊ณ์ฐ์ ์ํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ result ๋ณ์์ ์ ์ฅ
int result = calculatorLv2.operate(firstNumber, secondNumber, operator);
- ๊ฒฐ๋ก
- ๋ฉ์๋ ํธ์ถ ์ ์ ๋ถ๋ชจ๊ฐ 0์ด๊ณ ์ฐ์ฐ์๊ฐ ๋๋์ (/)์ธ ๊ฒฝ์ฐ๋ฅผ ์กฐ๊ฑด๋ฌธ์ผ๋ก ์ฌ์ ์ ํ์ธํ๋ค.
- ์๋ชป๋ ์ ๋ ฅ์ ๋ฐ๊ฒ ๋๋ฉด ์ฌ์ฉ์์๊ฒ ์๋ด ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๊ณ ๋ค์ ์ ๋ ฅ๋ฐ๋๋ค.
'ํ๋ก์ ํธ > ๊ฐ์ธ ํ๋ก์ ํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ผ์ ๊ด๋ฆฌ ์ฑ Develop_ํธ๋ฌ๋ธ ์ํ (0) | 2024.12.19 |
---|---|
์ผ์ ๊ด๋ฆฌ ์ฑ ๋ง๋ค๊ธฐ ๊ณผ์ _KPT ํ๊ณ (0) | 2024.12.10 |
์ผ์ ๊ด๋ฆฌ ์ฑ ๊ณผ์ _ํธ๋ฌ๋ธ ์ํ (0) | 2024.12.10 |
ํค์ค์คํฌ ๊ณผ์ _KPT ํ๊ณ (0) | 2024.11.28 |
ํค์ค์คํฌ ๊ณผ์ _ํธ๋ฌ๋ธ ์ํ (0) | 2024.11.28 |