1) ์ ์ด๋ฌธ
: ์คํ๋ฌธ์ ์ํ ์์๋ฅผ ๋ณ๊ฒฝํ๋ ๊ฒ (์กฐ๊ฑด๋ฌธ, ๋ฐ๋ณต๋ฌธ, ๋ถ๊ธฐ๋ฌธ์ผ๋ก ๊ตฌ๋ถ)
- ์กฐ๊ฑด๋ฌธ : ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ์ฌ๋ฌ ์คํ ๊ฒฝ๋ก ์ค ํ๋๋ฅผ ์ ํํ๋ค. ์ ํ๋ฌธ์ด๋ผ๊ณ ๋ ํ๋ค. ex) ๋ค์ํ ์ข ๋ฅ์ if ๋ฌธ, switch ๋ฌธ
- ๋ฐ๋ณต๋ฌธ : ์กฐ๊ฑด์ ๋ฐ๋ผ ๊ฐ์ ์ฒ๋ฆฌ๋ฅผ ๋ฐ๋ณตํ๋ค ex) for ๋ฌธ, while ๋ฌธ, do~while ๋ฌธ
- ๋ถ๊ธฐ๋ฌธ : ์คํ ํ๋ฆ์ ๋ฌด์กฐ๊ฑด ๋ณ๊ฒฝํ๋ break ๋ฌธ๊ณผ continue ๋ฌธ์ด ์๋ค.
- ์ ์ด๋ฌธ ๋ด๋ถ์ ๋ค๋ฅธ ์ ์ด๋ฌธ์ ํฌํจํ ์ ์์ด ์ ์ด๋ฌธ์ ์ฌ์ฉํ๋ฉด ํ๋ฆ์ด ๋ณต์กํ ํ๋ก๊ทธ๋จ๋ ๊ฐ๋ฐํ ์ ์๋ค.
2) ์กฐ๊ฑด๋ฌธ
2-1) ๋จ์ if ๋ฌธ
- ์กฐ๊ฑด์์ด true์ผ ๋๋ง ์คํ๋ฌธ์ ์ํํ๋ค
- ์กฐ๊ฑด์์ด true์ผ ๋ ์คํ๋ฌธ์ด ํ๋๋ผ๋ฉด { } ๋ฅผ ์๋ตํ ์ ์๋ค
2-2) if~else ๋ฌธ
- ์กฐ๊ฑด์์ true๋ false์ ๋ฐ๋ผ ๋ค๋ฅธ ์คํ๋ฌธ์ ์ํํ ๋ ์ฌ์ฉํ๋ค
import java.util.Scanner;
public class java0402 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("์ซ์๋ฅผ ์ ๋ ฅํ์ธ์:");
int number = in.nextInt();
if (number % 2 == 0)
System.out.println("์ง์!");
else
System.out.println("ํ์!");
System.out.println("์ข ๋ฃ");
}
}
9~12ํ๊ณผ ๊ฐ์ด ๋จ์ํ if~else ๋ฌธ์ ์กฐ๊ฑด ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด ๋ ๊ฐ๊ฒฐํ๊ฒ ํํํ ์ ์๋ค
=> System.out.println(number % 2 == 0 ? "์ง์!" : "ํ์!");
2-3) ๋ค์ค if ๋ฌธ
- ์กฐ๊ฑด์ด ๋ค์ํ ๋๋ ๋ค์ค if ๋ฌธ์ผ๋ก ํํํ๋ฉด ์ข๋ค
- if ๋ฌธ ๋ค์์ else if ๋ฌธ์ ์ฐ์ ์ถ๊ฐํด ๊ฐ ์กฐ๊ฑด์ ์ฐจ๋ก๋๋ก ์ ๊ฒํ ํ ๋ง์กฑํ๋ ์คํ๋ฌธ์ ์ํํ๋ค
- ๋ค์ค if ๋ฌธ์ ์ฌ๋ฌ ์กฐ๊ฑด ์ค ํ๋๋ง ture๋ก์จ ํด๋น ์คํ๋ฌธ์ ์ํํ๊ณ , ๋๋จธ์ง๋ ๋ ์ด์ ๋น๊ตํ์ง ์๋๋ค.
2-4) ์ค์ฒฉ if ๋ฌธ
- if ๋ฌธ์ ๋ค๋ฅธ if ๋ฌธ์ด ํฌํจ๋๋ ๊ฒ
- ์ค์ฒฉ if ๋ฌธ์๋ if ์ ๊ณผ else ์ ์ ๊ด๋ จ๋ ์คํ๋ฌธ์ด ๋ช ํํ๊ฒ ํ์๋๋๋ก ์ค๊ดํธ๋ฅผ ์ฌ์ฉํ๋ฉด ์ข๋ค.(์ฌ์ฉ ์ํด๋ ์คํ์ ๊ฐ๋ฅํ์ง๋ง ํผ๋์ค๋ฌ์ธ ์ ์๋ค)
3) ๋ฐ๋ณต๋ฌธ
3-1) while ๋ฌธ
- ๋ฐ๋ณตํ ํ์๋ ๋ฏธ๋ฆฌ ์ ์ ์์ง๋ง ์กฐ๊ฑด์ ์ ์ ์์ ๋ ์ฃผ๋ก ์ฌ์ฉํ๋ ๋ฐ๋ณต๋ฌธ
- ์กฐ๊ฑด์์ด true ์ผ ๋์ ๋ณธ์ฒด ์คํ๋ฌธ์ ๋ฐ๋ณต์ ์ผ๋ก ์ํํ๋ค.
- ์กฐ๊ฑด์์ด false์ด๋ฉด while ๋ฌธ ๋ค์ ์คํ๋ฌธ์ ์ํํ๋ค.
public class WhileDemo_2 {
public static void main(String[] args) {
int i = 1;
while (i < 5) {
System.out.print(i);
i++;
}
}
}
i ๊ฐ์ด 5๋ณด๋ค ์์ ๋์ ๋ฐ๋ณตํด ์คํํ๋ฏ๋ก
๊ฒฐ๊ณผ๋
1234
3-2) do~while ๋ฌธ
- while ๋ฌธ๊ณผ ๋น์ทํ์ง๋ง ์กฐ๊ฑด์ ํ๊ฐ์ ๋ณธ์ฒด ์คํ ์์๊ฐ ๋ค๋ฅด๋ค
- ๋ฐ๋ณต๋ฌธ ๋ณธ์ฒด๋ฅผ ๋จผ์ ์คํํ ํ ์กฐ๊ฑด์์ ํ๊ฐํ๋ค(์ต์ํ ํ ๋ฒ์ ๋ฐ๋ณต๋ฌธ ๋ณธ์ฒด๋ฅผ ์คํํ๋ค)
- ์ธ๋ฏธ์ฝ๋ก ์ผ๋ก ๋๋ด์ผ ํ๋ฉฐ, while ๋ฌธ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์กฐ๊ฑด์์ด ์์ ๋๋ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
- ๊ทผ๋ฐ ์ฝ๋ ๋ณผ๋ ์ ๋ณธ์ ์ด ์๋๊ฒ ๊ฐ์.. ๊ฑฐ์ ๋ฐ๋ณต๋ฌธํ๋ฉด while์ด๋ for์ ์ฌ์ฉํ๋ ๋ฏํจ..
public class DoWhile1Demo {
public static void main(String[] args) {
int i = 1;
do {
System.out.print(i);
i++;
} while(i<5);
}
}
์ฐ์ ์ซ์๋ฅผ ์ถ๋ ฅํ๋ ์์ ๋ while ๋ฌธ์ ์ฌ์ฉํ๋ do~while ๋ฌธ์ ์ฌ์ฉํ๋ ๊ฐ์ ๊ฒฐ๊ณผ๋ ๊ฐ๋ค.
=> ์คํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด, do~while ๋ฌธ์ ๋ณธํ ๋ฅผ ํ ๋ฒ ์คํํ์ง๋ง, while ๋ฌธ์ ๋ณธ์ฒด๋ฅผ ํ ๋ฒ๋ ์คํํ์ง ์์ ์ฑ๋ก ์ข ๋ฃํ ๊ฒ์ ์ ์ ์๋ค.
3-3) for ๋ฌธ
- ๋ฐ๋ณตํ ํ์๋ฅผ ๋ฏธ๋ฆฌ ์ ์ ์์ ๋ ์ฃผ๋ก ์ฌ์ฉํ๋ ๋ฐ๋ณต๋ฌธ
- ์กฐ๊ฑด์์ด true์ด๋ฉด ๋ณธ์ฒด ์คํ๋ฌธ์ ๋ฐ๋ณต์ ์ผ๋ก ์ํํ๋ค.
- ๋ค๋ฅธ ๋ฐ๋ณต๋ฌธ์ ๋นํด ์ฝ๋์ ๊ธธ์ด๊ฐ ์งง์!!(๋ด๊ฐ ๋๋ผ๊ธฐ์), ๊ฐ์ฅ ํจ์จ์ ์
public class For1Demo {
public static void main(String[] args) {
for (int i = 1; i < 5; i++)
System.out.print(i);
}
}
- for ๋ฌธ์ ์ด๊ธฐ์, ์กฐ๊ฑด์, ์ฆ๊ฐ์๋ ์๋ตํ ์ ์๋๋ฐ, ์ด๋๋ ๋ฌดํ ๋ฐ๋ณต๋ฌธ์ด ๋๋ค.
- for ๋ฌธ์์ ์ด๊ธฐ์์ด๋ ์ฆ๊ฐ์์ด 2๊ฐ ์ด์ ํ์ํ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝํ๋ก ๊ตฌ๋ถํด์ ์์ฑํ๋ค.
4) ๋ถ๊ธฐ๋ฌธ **๋ถ๊ธฐ๋ฌธ์ ์ฌ์ฉํ๋ฉด ํ๋ก๊ทธ๋จ ํ๋ฆ์ด ๋ณต์กํด์ง๊ธฐ ๋๋ฌธ์ ๊ผญ ํ์ํ ๋๋ฅผ ์ ์ธํ๊ณ ๋ 3๊ฐํ3
4-1) break ๋ฌธ
- ๋ฐ๋ณต๋ฌธ์ด๋ switch ๋ฌธ์ ๋ณธ์ฑ๋ฅผ ๋ฒ์ด๋๋ ค๊ณ ์ฃผ๋ก ์ฌ์ฉ๋๋ค
- ๋ ์ด๋ธ๊ณผ ํจ๊ป ์ฌ์ฉํ ์๋ ์๋ค.
- ๋ ์ด๋ธ์ด ์๋ค๋ฉด break ๋ฌธ์ ํฌํจํ๋ ๋งจ ์์ชฝ ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ๊ณ , ๋ ์ด๋ธ์ด ์๋ค๋ฉด ๋ ์ด๋ธ๋ก ํ์๋ ์ธ๋ถ ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃ
public class BreakDemo {
public static void main(String[] args) {
int i = 1, j = 5;
while (true) {
System.out.println(i++);
if (i >= j)
break;
}
}
}
๋ต์
1
2
3
4
4-2) continue ๋ฌธ
- ๋ฐ๋ณต๋ฌธ์์๋ง ์ฌ์ฉ
- continue๋ฌธ๋ break ๋ฌธ์ฒ๋ผ ๋ ์ด๋ธ์ ๋ถ์ผ ์ ์๋ค
public class ContinueDemo {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0)
continue;
System.out.print(i);
}
}
}
๋ต์
1
3
5
7
9