๐ฉท ์ด์ ์ Multiplication ํด๋์ค๋ ์์ฑ๋์๊ณ , Main ํด๋์ค๋ฅผ ์ด์ด์ ์์ฑํ๊ฒ ์ต๋๋ค.
Main ํด๋์ค๋ฅผ ์์ฑํ๊ฒ ์ต๋๋ค.
์ฐ์ ์ฌ์ฉ์์๊ฒ ์ ๋ ฅ์ ๋ฐ๊ธฐ ์ํด Scanner ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ฒ ์ต๋๋ค.
Scanner sc = new Scanner(System.in);
Multiplication ํด๋์ค์ ๊ฐ์ฒด๋ ์์ฑํฉ๋๋ค. ์ด ๊ฐ์ฒด๋ ๊ตฌ๊ตฌ๋จ ๊ณ์ฐ์ ๋ด๋นํฉ๋๋ค.
Multiplication multiple = new Multiplication();
๋น ๋ฌธ์์ด msg๋ฅผ ์ ์ธํฉ๋๋ค. ์ด๋ ์ฌ์ฉ์๊ฐ ๊ตฌ๊ตฌ๋จ์ ๊ณ์ ์ด์ฉํ ๊ฑด์ง์ ๋ํ ๋ต๋ณ์ ์ป๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค.
๊ทธ ํ, ๊ตฌ๊ตฌ๋จ ํ๋ก๊ทธ๋จ์ ์์์ ์๋ฆฝ๋๋ค.
String msg = "";
System.out.println("=====๊ตฌ๊ตฌ๋จ ํ๋ก๊ทธ๋จ ์๋ ์์=====");
do {
System.out.println("1x1 ํํ๋ก ์
๋ ฅํด์ฃผ์ธ์.");
String input = sc.next();
String[] parts = input.split("x");
int x = Integer.parseInt(parts[0]);
int y = Integer.parseInt(parts[1]);
// ์๋ ์ฝ๋๋ฅผ ์ด์ด์ ์ค๋ช
๋๋ฆฌ๊ฒ ์ต๋๋ค.
do-while ๋ฃจํ๋ฅผ ์์ํฉ๋๋ค. ์ด ๋ฃจํ๋ ์ฌ์ฉ์๊ฐ "exit"๋ฅผ ์ ๋ ฅํ ๋๊น์ง ๋ฐ๋ณต๋ฉ๋๋ค.
Scanner๋ฅผ ํตํด ์ฌ์ฉ์์ ์ ๋ ฅ์ "1x1"ํํ๋ก ๋ฐ์ต๋๋ค.
๊ทธ ํ, "x'๋ฅผ ๊ธฐ์ค์ผ๋ก split ๋ฉ์๋๋ฅผ ํตํด ๋ฌธ์๋ฅผ ๋๋ ํ, parts์ ๋ฐฐ์ด์ ํ ๋นํฉ๋๋ค.
3x1์ธ ๊ฒฝ์ฐ, ์ด๋ 0๋ฒ์งธ index์๋ 1, 1๋ฒ์งธ index์๋ 1์ด ํ ๋น๋ฉ๋๋ค.
์ฌ๊ธฐ์ String์ split์ ํตํด ๋ฐฐ์ด์ ๊ฐ์ ๋ด๋ ๋ฐฉ๋ฒ์ ๋ถ๊ฐ ์ค๋ช ๋๋ฆฌ๊ฒ ์ต๋๋ค.
๋จผ์ , split ๋ฉ์๋์ ๊ธฐ๋ณธ ํ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
String[] parts = originalString.split(delimiter);
์ฌ๊ธฐ์ originalString์ ๋ถํ ํ ์๋ณธ ๋ฌธ์์ด์ด๊ณ , delimiter๋ ๋ถํ ๊ธฐ์ค์ด ๋๋ ๊ตฌ๋ถ์์
๋๋ค. ๋ฐํ๋๋ parts๋ ๋ถํ ๋ ๋ฌธ์์ด์ ํฌํจํ๋ ๋ฐฐ์ด์
๋๋ค.
์๋์ ๊ตฌ์ฒด์ ์ธ ์์ ๋ฅผ ํตํด ์ค๋ช
ํ๊ฒ ์ต๋๋ค:
์์ ) ์ฝค๋ง๋ก ๋ฌธ์์ด ๋ถํ
public class SplitExample {
public static void main(String[] args) {
String originalString = "apple,banana,orange";
String delimiter = ",";
String[] parts = originalString.split(delimiter);
for (String part : parts) {
System.out.println(part);
}
}
}
print >>
apple
banana
orange
์ด์ฒ๋ผ split ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๊ตฌ๋ถ์๋ฅผ ํตํด ๋ฐฐ์ด๋ก ๊ฐ์ ํ ๋นํ ์ ์๊ฒ๋ฉ๋๋ค.
์ค์ ํ๋ก๊ทธ๋๋ฐ์์๋ ์ ์ฉํ๊ฒ ์ฐ์ด๋ ๊ผญ ๊ธฐ์ตํด ์ฃผ์ธ์!
int result = multiple.getResult(x,y);
System.out.println(x+"x"+y+"="+result);
System.out.println("๊ณ์ํ์ค๊ฑฐ๋ฉด y, ์ข
๋ฃ๋ exit๋ฅผ ์
๋ ฅํด์ฃผ์ธ์");
msg = sc.next();
} while (!msg.equals("exit"));
๊ทธ๋ฌ๋ฉด ์ด์ parts ๋ฐฐ์ด์ 0๋ฒ์งธ Index์๋ ์ฌ์ฉ์๊ฐ ์ฒซ ๋ฒ์งธ ์ ๋ ฅํ ์ซ์,
parts ๋ฐฐ์ด์ 1๋ฒ์งธ Index์๋ ์ฌ์ฉ์๊ฐ ๋ ๋ฒ์งธ ์ ๋ ฅํ ์ซ์๊ฐ ์กด์ฌํ๊ฒ ๋ฉ๋๋ค.
๊ทธ ํ Multiplication ๊ฐ์ฒด์ ๋ฉ์๋์ธ getResult ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ, ํด๋น ๊ตฌ๊ตฌ๋จ์ ๊ฒฐ๊ด๊ฐ์ ์ ์ฅ ํ์ ์ถ๋ ฅํด ์ค๋๋ค.
์ฌ์ฉ์๊ฐ y๋ฅผ ์ ๋ ฅํ๋ฉด ํ๋ก๊ทธ๋จ์ ๋ฐ๋ณต๋๊ณ exit๋ฅผ ์ ๋ ฅ ์์ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋ฉ๋๋ค.
์คํํ์๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ์ค ์ ์์ต๋๋ค.
2์ฐจ์ ๋ฐฐ์ด์ ํ์ฉํ์ฌ ๊ตฌ๊ตฌ๋จ ๋ง๋ค๊ธฐ ์์ฑ์ ๋๋ค!
์๋๋ ์ ์ฒด ์ฝ๋์ ๋๋ค.
package multiplication;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Multiplication multiple = new Multiplication();
String msg = "";
System.out.println("=====๊ตฌ๊ตฌ๋จ ํ๋ก๊ทธ๋จ ์๋ ์์=====");
do {
System.out.println("1x1 ํํ๋ก ์
๋ ฅํด์ฃผ์ธ์.");
String input = sc.next();
String[] parts = input.split("x");
int x = Integer.parseInt(parts[0]);
int y = Integer.parseInt(parts[1]);
int result = multiple.getResult(x,y);
System.out.println(x+"x"+y+"="+result);
System.out.println("๊ณ์ํ์ค๊ฑฐ๋ฉด y, ์ข
๋ฃ๋ exit๋ฅผ ์
๋ ฅํด์ฃผ์ธ์");
msg = sc.next();
} while (!msg.equals("exit"));
}
}
๊ตฌ๊ตฌ๋จ ๋ง๋ค๊ธฐ ์์ ๋ฅผ ํตํด ๊ธฐ๋ณธ์ ์ธ ๋ฐฐ์ด ํ์ฉ์ ํด๋ณด์์ต๋๋ค.
์ด๋ฌํ ๊ธฐ์ด ์ง์์ ํ๋ก๊ทธ๋๋ฐ์ ํฐ ๋์์ด ๋ฉ๋๋ค.
๋ค์ ํฌ์คํ ์ผ๋ก ์ฐพ์๋ต๊ฒ ์ต๋๋ค
๊ถ๊ธํ์ ์ ์ ๋๊ธ์ ๋จ๊ฒจ์ฃผ์ธ์!
๐ฉต๐ฐ๐ฉต
'โJava' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java ์ดํดํ๊ธฐ] 17. Java์ this (1) | 2024.05.27 |
---|---|
[Java ์ดํดํ๊ธฐ] 16. Java์ ์์ฑ์ (2) | 2024.05.27 |
[Java ์ดํดํ๊ธฐ] 14. Java๋ก ๊ตฌ๊ตฌ๋จ ๋ง๋ค๊ธฐ (1) (1) | 2024.05.24 |
[Java ์ดํดํ๊ธฐ] 13. Java์ ๋ฐฐ์ด (2) (1) | 2024.05.24 |
[Java ์ดํดํ๊ธฐ] 12. Java์ ๋ฐฐ์ด (1) (0) | 2024.05.24 |