Java ๋ฐ๋ณต๋ฌธ ์ฝ๋ฉ ๊ฐ์ ์์ฝ
์ด ์์์ Java์์ ๋ฐ๋ณต๋ฌธ์ ํ์ฉํ๋ ๋ค์ํ ๋ฐฉ๋ฒ์ ์ค์ตํ๋ฉฐ ๋ฐฐ์ฐ๋ ๊ฐ์์
๋๋ค. 1๋ถํฐ 10๊น์ง ์ซ์ ์ถ๋ ฅ, ํฉ๊ณ ๊ตฌํ๊ธฐ, ์ง์/ํ์ ํฉ๊ณ, ๋ฉ๋ดํ ์ฃผ๋ฌธ ํ๋ก๊ทธ๋จ, ๊ตฌ๊ตฌ๋จ ์ถ๋ ฅ, ๊ทธ๋ฆฌ๊ณ ๋ฐ๋ณต๋ฌธ ์ ์ด๋ฌธ์ธ continue์ break ์ฌ์ฉ๋ฒ๊น์ง ๋จ๊ณ๋ณ๋ก ์์ธํ ์ค๋ช
ํฉ๋๋ค.
๋ชฉ์ฐจ
1.
2.
3.
4.
5.
6.
7.
8.
๋ฐ๋ณต๋ฌธ ๊ธฐ๋ณธ - 1๋ถํฐ 10๊น์ง ์ถ๋ ฅํ๊ธฐ [00:00:01]
โข
๋ฐ๋ณต๋ฌธ์ ๊ฐ์ ์ฝ๋๋ฅผ ์ฌ๋ฌ ๋ฒ ์คํํ ๋ ์ฌ์ฉํด์.
โข
์๋ฅผ ๋ค์ด, 1๋ถํฐ 10๊น์ง ์ซ์๋ฅผ ์ถ๋ ฅํ๋ ค๋ฉด ์ผ์ผ์ด ์ฐ๋ ๋์ ๋ฐ๋ณต๋ฌธ์ ์ฐ๋ฉด ํธํด์.
โข
while ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํด ๋ณ์ a๋ฅผ 1๋ถํฐ 10๊น์ง 1์ฉ ์ฆ๊ฐ์ํค๋ฉฐ ์ถ๋ ฅํฉ๋๋ค.
โข
์ค์ํ ์ : ๋ฐ๋ณต๋ฌธ ์์์ ๋ณ์ ๊ฐ์ ๊ผญ ์ฆ๊ฐ์์ผ์ผ ๋ฌดํ๋ฃจํ์ ๋น ์ง์ง ์์์!
โข
์)
int a = 1;
while(a <= 10) {
System.out.print(a + " ");
a++;
}
Java
๋ณต์ฌ
ํฉ๊ณ ๊ตฌํ๊ธฐ - 1๋ถํฐ 1000๊น์ง ํฉ๊ณ ๊ณ์ฐ [00:07:22]
โข
1๋ถํฐ 1000๊น์ง ์ซ์๋ฅผ ๋ชจ๋ ๋ํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด ๋ด
๋๋ค.
โข
๋ณ์๋ฅผ ๋ ๊ฐ ์ฌ์ฉํด์:
1.
๋ฐ๋ณต ๋ณ์ a (1๋ถํฐ 1000๊น์ง ์ฆ๊ฐ)
2.
ํฉ๊ณ๋ฅผ ์ ์ฅํ ๋ณ์ sum (์ฒ์์ 0์ผ๋ก ์ด๊ธฐํ)
โข
๋ฐ๋ณต๋ฌธ ์์์ sum์ a๋ฅผ ๊ณ์ ๋ํด์ค๋๋ค.
โข
์)
int a = 1;
int sum = 0;
while(a <= 1000) {
sum += a;
a++;
}
System.out.println("ํฉ๊ณ: " + sum);
Java
๋ณต์ฌ
์ง์์ ํ์ ํฉ๊ณ ๊ตฌํ๊ธฐ [00:18:06]
โข
1๋ถํฐ 20๊น์ง ์ซ์ ์ค ์ง์์ ํ์์ ํฉ์ ๊ฐ๊ฐ ๊ตฌํ๋ ๋ฐฉ๋ฒ์
๋๋ค.
โข
๋ฐ๋ณต๋ฌธ ์์์ if ์กฐ๊ฑด๋ฌธ์ผ๋ก ์ง์์ธ์ง ํ์์ธ์ง ํ๋จํด์.
โข
์ง์๋ 2๋ก ๋๋์์ ๋ ๋๋จธ์ง๊ฐ 0, ํ์๋ ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ์
๋๋ค.
โข
๊ฐ๊ฐ์ ํฉ๊ณ๋ฅผ ์ ์ฅํ๋ ๋ณ์๋ฅผ ๋ฐ๋ก ๋๊ณ ๋ํด์ค๋๋ค.
โข
์)
int evenSum = 0;
int oddSum = 0;
for(int i = 1; i <= 20; i++) {
if(i % 2 == 0) evenSum += i;
else oddSum += i;
}
System.out.println("์ง์ ํฉ: " + evenSum);
System.out.println("ํ์ ํฉ: " + oddSum);
Java
๋ณต์ฌ
๋ฉ๋ดํ ์ฃผ๋ฌธ ํ๋ก๊ทธ๋จ ๋ง๋ค๊ธฐ (๋ฌดํ๋ฐ๋ณต๊ณผ ์ข
๋ฃ) [00:30:44]
โข
๋ฉ๋ดํ์ ๋ณด์ฌ์ฃผ๊ณ ๋ฒํธ๋ฅผ ์
๋ ฅ๋ฐ์ ์ฃผ๋ฌธํ๋ ํ๋ก๊ทธ๋จ์
๋๋ค.
โข
๋ฌดํ ๋ฐ๋ณต๋ฌธ(while true ๋๋ do-while)์ ์ฌ์ฉํด ์ฃผ๋ฌธ์ ๊ณ์ ๋ฐ๋ค๊ฐ,
โข
0์ ์
๋ ฅํ๋ฉด ๋ฐ๋ณต๋ฌธ์ ์ข
๋ฃํฉ๋๋ค.
โข
switch๋ฌธ์ผ๋ก ๋ฉ๋ด ๋ฒํธ์ ๋ฐ๋ผ ๋ฉ๋ด ์ด๋ฆ์ ์ ์ฅํ๊ณ ์ฃผ๋ฌธ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
โข
์ฃผ๋ฌธ ๊ฐ์๋ฅผ ์ธ๋ ๋ณ์๋ ๋ง๋ค์ด ์ ํจํ ์ฃผ๋ฌธ์ผ ๋๋ง๋ค 1์ฉ ์ฆ๊ฐ์ํต๋๋ค.
โข
break ํค์๋๋ก 0 ์
๋ ฅ ์ ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ๋๊ฐ๋๋ค.
โข
์)
Scanner sc = new Scanner(System.in);
int orderCount = 0;
while(true) {
System.out.println("๋ฉ๋ด ๋ฒํธ ์
๋ ฅ (0: ์ข
๋ฃ): ");
int menuNum = sc.nextInt();
if(menuNum == 0) break;
String menuName = "";
switch(menuNum) {
case 1: menuName = "๋๊ฐ์ค๋ฎ๋ฐฅ"; break;
case 2: menuName = "๋ง๋ผํ"; break;
// ... ๊ธฐํ ๋ฉ๋ด
default:
System.out.println("์ ํจํ ๋ฒํธ๋ฅผ ์
๋ ฅํ์ธ์.");
continue;
}
System.out.println(menuName + " ์ฃผ๋ฌธ๋์์ต๋๋ค.");
orderCount++;
}
System.out.println(orderCount + "๊ฐ์ ๋ฉ๋ด๋ฅผ ์ฃผ๋ฌธํ์
จ์ต๋๋ค.");
Java
๋ณต์ฌ
for๋ฌธ์ผ๋ก ๋ฐ๋ณต๋ฌธ ์ฐ์ต (์ซ์ ์ถ๋ ฅ, ์ง์/ํ์ ์ถ๋ ฅ) [01:14:00]
โข
for๋ฌธ์ ๋ฐ๋ณต ํ์๊ฐ ์ ํด์ ธ ์์ ๋ ์ฃผ๋ก ์ฌ์ฉํฉ๋๋ค.
โข
๊ธฐ๋ณธ ๊ตฌ์กฐ: ์ด๊ธฐ์; ์กฐ๊ฑด์; ์ฆ๊ฐ์
โข
์: 1๋ถํฐ 10๊น์ง ์ถ๋ ฅ
for(int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
Java
๋ณต์ฌ
โข
์ง์๋ง ์ถ๋ ฅํ๋ ค๋ฉด:
1.
2๋ถํฐ ์์ํด์ 2์ฉ ์ฆ๊ฐํ๊ฑฐ๋
2.
1๋ถํฐ ์์ํด์ if๋ฌธ์ผ๋ก ์ง์์ธ์ง ๊ฒ์ฌ ํ ์ถ๋ ฅ
โข
ํ์๋ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์์ฉ ๊ฐ๋ฅํด์.
๊ตฌ๊ตฌ๋จ ์ถ๋ ฅ - ์ค์ฒฉ ๋ฐ๋ณต๋ฌธ ์ฌ์ฉํ๊ธฐ [01:25:16]
โข
๊ตฌ๊ตฌ๋จ์ ์ถ๋ ฅํ๋ ค๋ฉด 1๋จ๋ถํฐ 9๋จ๊น์ง, ๊ฐ ๋จ๋ง๋ค 1๋ถํฐ 9๊น์ง ๊ณฑํ๋ ๋ฐ๋ณต๋ฌธ์ด ํ์ํด์.
โข
์ด์ค ๋ฐ๋ณต๋ฌธ(์ค์ฒฉ ๋ฐ๋ณต๋ฌธ)์ ์ฌ์ฉํฉ๋๋ค.
โข
๋ฐ๊นฅ ๋ฐ๋ณต๋ฌธ: ๋จ ๋ฒํธ (1~9)
โข
์์ชฝ ๋ฐ๋ณต๋ฌธ: ๊ณฑํ๋ ์ (1~9)
โข
์)
for(int i = 1; i <= 9; i++) {
for(int j = 1; j <= 9; j++) {
System.out.print(i + "x" + j + "=" + (i*j) + "\t");
}
System.out.println();
}
Java
๋ณต์ฌ
โข
"\t"๋ ํญ(๊ฐ๊ฒฉ) ๋ฌธ์๋ก ๋ณด๊ธฐ ์ข๊ฒ ์ ๋ ฌํด ์ค๋๋ค.
continue ํค์๋ - ํน์ ์กฐ๊ฑด ๊ฑด๋๋ฐ๊ธฐ [02:00:02]
โข
๋ฐ๋ณต๋ฌธ ๋ด์์ continue๋ฅผ ๋ง๋๋ฉด ๊ทธ ์๋ ์ฝ๋๋ ์คํํ์ง ์๊ณ ๋ฐ๋ก ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ๋๋ค.
โข
์: 5๊ฐ์ ์ซ์๋ฅผ ์
๋ ฅ๋ฐ์ ์์๋ง ๋ํ ๋, ์์๋ continue๋ก ๊ฑด๋๋๋๋ค.
โข
์ด๋ ๊ฒ ํ๋ฉด ์์๋ ํฉ๊ณ์ ํฌํจ๋์ง ์์์.
โข
์)
int sum = 0;
for(int i = 0; i < 5; i++) {
int num = sc.nextInt();
if(num < 0) continue; // ์์๋ฉด ๋ค์ ๋ฐ๋ณต์ผ๋ก ๊ฑด๋๋
sum += num;
}
System.out.println("์์ ํฉ: " + sum);
Java
๋ณต์ฌ
break ํค์๋ - ๋ฐ๋ณต๋ฌธ ์ฆ์ ์ข
๋ฃํ๊ธฐ [02:07:31]
โข
break๋ ๋ฐ๋ณต๋ฌธ์ ์ฆ์ ์ข
๋ฃ์ํค๋ ํค์๋์
๋๋ค.
โข
์: ๋ฌดํ ๋ฐ๋ณต๋ฌธ์์ ํน์ ์
๋ ฅ("์คํฑ")์ ๋ฐ์ผ๋ฉด ๋ฐ๋ณต์ ๋ฉ์ถ๊ณ ๋๊ฐ๋๋ค.
โข
break๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ฐ๋ณต๋ฌธ๋ง ์ข
๋ฃํฉ๋๋ค.
โข
์)
while(true) {
String input = sc.nextLine();
if(input.equals("์คํฑ")) break; // "์คํฑ" ์
๋ ฅ ์ ์ข
๋ฃ
System.out.println("์
๋ ฅ: " + input);
}
System.out.println("ํ๋ก๊ทธ๋จ ์ข
๋ฃ");
Java
๋ณต์ฌ
๋ง๋ฌด๋ฆฌ ์์ฝ
์ด๋ฒ ์์์์๋ Java ๋ฐ๋ณต๋ฌธ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ถํฐ ์์ํด, while๊ณผ for ๋ฐ๋ณต๋ฌธ์ ์ฐจ์ด, ์ค์ฒฉ ๋ฐ๋ณต๋ฌธ ํ์ฉ๋ฒ, ๊ทธ๋ฆฌ๊ณ continue์ break ๊ฐ์ ๋ฐ๋ณต๋ฌธ ์ ์ด ํค์๋๊น์ง ์ค์ต๊ณผ ํจ๊ป ๋ฐฐ์ ์ด์. ๋ฐ๋ณต๋ฌธ์ ํ๋ก๊ทธ๋๋ฐ์์ ๋งค์ฐ ์ค์ํ๊ณ ๊ฐ๋ ฅํ ๋๊ตฌ์ด๋, ๋ค์ํ ์์ ๋ฅผ ์ง์ ์ฝ๋ฉํด๋ณด๋ฉฐ ์ตํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์์! ์ฆ๊ฒ๊ฒ ์ฐ์ตํ์๊ธธ ๋ฐ๋๋๋ค! 