2021. 2. 7. 08:00ใ๊ฐ๋ ์ ๋ฆฌ ์์ ์ค/Java
๐ ๋ฐ๋ณต๋ฌธ
๐ while
while๋ฌธ์ ํ์์ ์๋์ ๊ฐ์ต๋๋ค.
while(์กฐ๊ฑด) {
๋ฐ๋ณต ์คํ ์์ญ
}
While๋ฌธ์์ ์ฃผ์ํ ์ ์ ์กฐ๊ฑด์ ๋ค์ด๊ฐ ํ์์ด Boolean Type์ด์ฌ์ผ ํ๋ค๋ ์ ์ด์์.
์ฆ, ์ฐธ์ด๋ผ๋ฉด? ๊ฑฐ์ง์ด๋ผ๋ฉด? ๋ฐ๋ณต์ ์คํํด!๋ก ์ดํด ํ์๋ฉด ๋๊ฒ ์ต๋๋ค.
๐ก ์์ ์ฝ๋
public class LoopExample1 {
public static void main(String[] args) {
// while ๋ฌธ ์
int i = 0; // ๋ณ์ i๋ฅผ 0์ผ๋ก ์ด๊ธฐํ
while (i < 10) { // i๊ฐ 10๋ณด๋ค ์๋ค๋ฉด? While์ {}์์ ๋ด์ฉ ์คํ.
System.out.print(i + " "); // i ๋ณ์์์ ๋ณ์๊ฐ์ ์ถ๋ ฅํ๊ณ , ๊ณต๋ฐฑ ์ถ๋ ฅํ๋ฉด์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ถ๋ ฅ(print)
i ++; // i๋ฅผ 1์ฉ ์ฆ๊ฐ
}
}
}
๐While๋ฌธ์ ์ฃผ์์ฌํญ
While๋ฌธ์ ๊ฐ์ ํน์ ํ์ ๋ฐ๋ณต์ ํฉ๋๋ค. ์ฆ, ๊ฐ์๋ ํ์๊ฐ ์ ํด์ ธ ์์ ๋ ์ฌ์ฉํ๊ฒ ๋ฉ๋๋ค.
๐ do - while
๐do-while๋ฌธ์ ์ฃผ์์ฌํญ
do-while๋ฌธ์ ์กฐ๊ฑด์ ๋์ค์ ์ฐธ๊ณ ํ๊ณ , ์ผ๋จ ์คํ์ ํ๋ฒ ๊ผญ ํ๊ฒ ๋๋ ๋ฐฉ์์ ๋๋ค.
do {} ์์ ์ค๋ ๋ด์ฉ์ ์กฐ๊ฑด์ ๋ค์ด๊ฐ์ง ์์ต๋๋ค.
do-while์ ์ฅ์ ์ ๊ฐ์ ๋ฐ๋ณต๋ฌธ๋ณด๋ค ์ค๋ณต ๋ถ๋ถ์ด ๋ํฉ๋๋ค. ๊ทธ๋์ ๋๊ฐ์ ์ฝ๋๊ฐ ์ฌ๋ฌ๋ฒ ๋์ด๋ ๋ ์ด๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํ์ฌ ์ฌ์ฉํฉ๋๋ค.
do-while์ ์คํ ๋ค ๊ฒ์ฌ๋ผ๊ณ ํฉ๋๋ค.
์ฆ, do-while๋ฌธ์ ๋จผ์ ๋ฃจํ๋ฅผ ํ๋ฒ ์คํํ ๋ค์ ์กฐ๊ฑด์์ ๊ฒ์ฌํ๋ ๊ฒ์ ๋๋ค. ์ฐธ๊ณผ ๊ฑฐ์ง ์ฌ๋ถ๋ฅผ ๋ ๋ ๋ฌด์กฐ๊ฑด ํ๋ฒ์ ์คํํ๋ค๋ ๊ฒ์ด์ง์
do-while์ ํ์์ ์๋์ ๊ฐ์ต๋๋ค.
int key; // key๋ผ๋ ์ ์ํ ๋ณ์ ์ ์ธ.
do {
์กฐ๊ฑด์ ๋ค์ด๊ฐ๊ธฐ ์ ๊ผญ ํ๋ฒ์ ์คํํด์ผ ๋ ๋ด์ฉ ์
๋ ฅ
} while (์กฐ๊ฑด๋ฌธ);
๋ฐ๋ณตํ ๋ด์ฉ
๐ก ์์ ์ฝ๋
import java.util.Scanner;
public class CheckInput {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int month;
do {
System.out.println("์ฌ๋ฐ๋ฅธ ๋ฌ์ ์
๋ ฅํ์ธ์ [ 1 ~ 12 ]: "); // ์กฐ๊ฑด์ ์ ๊ฒ์ฌํ๊ธฐ ์ ์ฌ์ฉ์์๊ฒ ๋ฌ์ ์๋ฅผ ์
๋ ฅ ๋ฐ๋๋ค.
month = input.nextInt(); // ์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๋ฌ์ ์๋ฅผ month๋ณ์์ ๋ฃ๋๋ค.
} while (month < 1 || month > 12); // month ๋ณ์๊ฐ 1๋ณด๋ค ์๊ฑฐ๋, 12๋ณด๋ค ํฌ๋ค๋ฉด while๋ฌธ์ {}์ ๋ด์ฉ ํ๋ฒ ์คํํ๊ณ ์ข
๋ฃ
System.out.println("์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๋ฌ์ " + month);
}
}
๐ for๋ฌธ
๐do-while๋ฌธ์ ์ฃผ์์ฌํญ
for๋ฌธ ์ญ์ while๋ฌธ๊ณผ ๋น์ทํ๊ฒ ๊ฐ์์ ํ์๋ฅผ ๋ฐ๋ณต ํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ , ๊ฐ์๊ฐ ์ ํด์ ธ ์์ ๋ ์ฌ์ฉํฉ๋๋ค.
for๋ฌธ์ ์์๋ ์๋์ ๊ฐ์ต๋๋ค.
/*
* ์ด๊ธฐ์: ์ด๋์๋ถํฐ ์์ํ๊ฒ ๋ค. (์๋ต๊ฐ๋ฅ)
* ์กฐ๊ฑด์: ์ด๋๊น์ง ํน์ ~์ด๋ผ๋ฉด (์๋ต๊ฐ๋ฅ)
* ์ฆ๊ฐ์: ์ด๊ธฐ์์์ ์ ์ธ๋ ๋ณ์์ ๊ฐ์ด ์ฆ๊ฐ ํน์ ๊ฐ์ ์ํค๋ฉด์ ๋ฐ๋ณต๋ฌธ ์งํ (์๋ต ๊ฐ๋ฅ)
*/
for(<์ด๊ธฐ์>; <์กฐ๊ฑด์>; <์ฆ๊ฐ์>) {
๋ฐ๋ณตํ ๋ด์ฉ
}
๐ก ์์ ์ฝ๋
//ํฉํ ๋ฆฌ์ผ์ ๊ตฌํ๋ ์์๋ก for๋ฌธ์ ์์ ๋ณด๊ฒ ์ต๋๋ค.
//ํฉํ ๋ฆฌ์ผ n!์ด๋ผ๋ ๊ฒ์ 1 * 2 * 3 * 4 * 5 * .... * n ์
๋๋ค.
import java.util.Scanner;
public class Factorial {
public static void main(String[] args) {
// TODO Auto-generated method stub
int fact = 1; // fact ์ด๋ผ๋ ๋ณ์์ ์ด๊ธฐ๊ฐ 1 ์ ์ธ.
int n; // n์ด๋ผ๋ ๋ณ์ ์ ์ธ
Scanner scan = new Scanner(System.in); // ์ฌ์ฉ์์๊ฒ ์
๋ ฅ๊ฐ์ ๋ฐ๊ธฐ ์ํด Scannerํจ์ ํธ์ถํ ๋ค scan์ด๋ผ๋ ๊ฐ์ฒด์ ๋ฃ์.
System.out.printf("์ ์๋ฅผ ์
๋ ฅํ์ธ์.: "); // ์ฌ์ฉ์์๊ฒ ์ ์๋ฅผ ์
๋ ฅํ๋ผ๊ณ ์์ฒญ์ ์ถ๋ ฅ
n = scan.nextInt(); // ์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๊ฐ์ scan์ด๋ผ๋ ๋ณ์ ์์์ nextInt()ํจ์๋ฅผ ํธ์ถํ์ฌ ์
๋ ฅ ๋ฐ์ ๋ฃ์.
for (int i = 1; i <= n; i++) { // for ๋ฌธ์ ์ด๊ธฐ์์ i๋ฅผ 1๋ก ๋ง๋ค๊ณ , i๊ฐ n(์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๊ฐ) ๋ณด๋ค ์๊ฑฐ๋, ๋ฐ๋ณต๋ฌธ์ ์คํํ๊ณ , ์คํ ๋ค i๋ฅผ 1์ฉ ์ฆ๊ฐํ๋ค.
fact = fact * i; // ๋ฐ๋ณต๋ฌธ ์คํ ๋ด์ฉ ( fact๋ผ๋ ๋ณ์์ ๊ธฐ์กด fact ๋ณ์ ๊ฐ ๊ณฑํ๊ธฐ i์ ๋ณ์ ๊ฐ์ ํด์ ๋ฃ์)
}
System.out.printf("ํฉํ ๋ฆฌ์ผ ๊ฐ์ %d ์
๋๋ค.", fact);
// printf๋ formatํ์์ ์ถ๋ ฅํ๊ฒ ๋ค๋ ์๋ฏธ. ๊ดํธ์์ %d๋ 10์ง์๋ฅผ ์
๋ ฅ ๋ฐ๊ฒ ๋ค๋ ๊ฒ์ด๊ณ , fact์ ๊ฐ์ ๋ฐ๋๋ค.
}
}
์ฃผ๋ํ๋์ ์ด๋ฒ ํฌ์คํ
์ด ์ด๋ ์
จ๋์? ๊ตฌ๋
, ๊ณต๊ฐ๊ณผ ๋๊ธ์ ์ฃผ๋ํ๋์๊ฒ ๋งค์ฐ ํฐ ํ์ด ๋ ๊ฒ์
๋๋ค!
'๊ฐ๋ ์ ๋ฆฌ ์์ ์ค > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ถ๋ก][JAVA] ํผํ๊ณ ๋ผ์ค์ ์ผ๊ฐํ (0) | 2021.02.09 |
---|---|
[JAVA] ๊ธฐํ ์ ์ด๋ฌธ (0) | 2021.02.08 |
[JAVA] ์กฐ๊ฑด๋ฌธ (0) | 2021.02.06 |
[JAVA] ํ๋ณํ(Type Conversion) (0) | 2021.02.05 |
[JAVA] ์ฐ์ฐ์(Operator) (0) | 2021.02.04 |