์ ํ๋ธ์์ ๊น์ํ์ ์๋ฐ ๋ฌด๋ฃ ์ ๋ฌธ - ์ฝ๋๋ก ์์ํ๋ Java ์ฒซ๊ฑธ์ 10์๊ฐ์ ์ฐธ๊ณ ํ์ฌ ๋ด์ฉ์ ์ ๋ฆฌํ๋ค๐
if๋ฌธ 1 - if, else
์กฐ๊ฑด๋ฌธ ์์
์ง๊ธ๊น์ง ์ดํด๋ณธ ํ๋ก๊ทธ๋จ์ ๋จ์ํ ์์์ ์๋๋ก ์์๋๋ก ํ ์ค์ฉ ์คํ๋์๋ค.
ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ์ ๋ค๋ฅธ ์ฝ๋๋ฅผ ์คํํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น? ์๋ฅผ ๋ค์ด์ ๋ง์ฝ 18์ด ์ด์์ด๋ฉด "์ฑ์ธ์ ๋๋ค"๋ฅผ ์ถ๋ ฅํ๊ณ , 18์ด ๋ฏธ๋ง์ด๋ผ๋ฉด "๋ฏธ์ฑ๋ ์์ ๋๋ค"๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค.
์๋ง๋ ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋ฉ์ ํด์ผํ ๊ฒ ๊ฐ๋ค.
๋ง์ฝ (๋์ด >= 18)์ด๋ฉด "์ฑ์ธ์
๋๋ค"
๋ง์ฝ (๋์ด < 18)์ด๋ฉด "๋ฏธ์ฑ๋
์์
๋๋ค"
์์ด๋ก ํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
if (age >= 18) "์ฑ์ธ์
๋๋ค"
if (age < 18) "๋ฏธ์ฑ๋
์์
๋๋ค"
์ด๋ ๊ฒ ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ์ ๋ค๋ฅธ ์ฝ๋๋ฅผ ์คํํ๋ ๊ฒ์ ์กฐ๊ฑด๋ฌธ์ด๋ผ ํ๋ค.
์กฐ๊ฑด๋ฌธ์๋ if ๋ฌธ, switch ๋ฌธ์ด ์๋ค. ๋ ๋ค ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ์ ๋ค๋ฅธ ์ฝ๋๋ฅผ ์คํํ๋ ๊ฒ์ด๋ผ ์๊ฐํ๋ฉด ๋๋ค.
if๋ฌธ
if ๋ฌธ์ ํน์ ์กฐ๊ฑด์ด ์ฐธ์ธ์ง ํ์ธํ๊ณ , ๊ทธ ์กฐ๊ฑด์ด ์ฐธ(true)์ผ ๊ฒฝ์ฐ ํน์ ์ฝ๋ ๋ธ๋ก์ ์คํํ๋ค.
if (condition) {
// ์กฐ๊ฑด์ด ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋
}
์ฝ๋ ๋ธ๋ก : { } (์ค๊ดํธ) ์ฌ์ด์ ์๋ ์ฝ๋
If1
package cond;
public class If1 {
public static void main(String[] args) {
int age = 20; //์ฌ์ฉ์ ๋์ด
if (age >= 18) {
System.out.println("์ฑ์ธ์
๋๋ค.");
}
if (age < 18) {
System.out.println("๋ฏธ์ฑ๋
์์
๋๋ค.");
}
}
}
์คํ ๊ฒฐ๊ณผ
์ฑ์ธ์
๋๋ค.
age = 20 ๊ฐ์ ์ฃผ๋ฉด ์ฒ์ if ๋ฌธ์์ ์ฐธ์ด ๋๋ค.
if (age >= 18) ๋ถ์
//age = 20
if (age >= 18) {"์ฑ์ธ์
๋๋ค"}
if (20 >= 18) {"์ฑ์ธ์
๋๋ค"} //age์ ๊ฐ์ 20์ด๋ค.
if true {"์ฑ์ธ์
๋๋ค"} //์กฐ๊ฑด์ด ์ฐธ์ผ๋ก ํ๋ช
๋๋ค.
{"์ฑ์ธ์
๋๋ค"} //if๋ฌธ์ ์๋ ์ฝ๋ ๋ธ๋ก์ด ์คํ๋๋ค.
์กฐ๊ฑด์ด ์ฐธ์ผ๋ฏ๋ก "์ฑ์ธ์ ๋๋ค." ๊ฐ ํ๋ฉด์ ์ถ๋ ฅ๋๋ค.
์ดํ์ ๋ค์ ์ฝ๋๊ฐ ์คํ๋๋ค.
if (age < 18) ๋ถ์
if (age < 18) {"๋ฏธ์ฑ๋
์์
๋๋ค."}
if (20 < 18) {"๋ฏธ์ฑ๋
์์
๋๋ค."} //age์ ๊ฐ์ 20์ด๋ค.
if (false) {"๋ฏธ์ฑ๋
์์
๋๋ค."} //์กฐ๊ฑด์ด ๊ฑฐ์ง์ผ๋ก ํ๋ช
๋๋ค.
// ํด๋น ์ฝ๋ ๋ธ๋ก์ ์คํ๋์ง ์๋๋ค.
์กฐ๊ฑด์ด ๊ฑฐ์ง์ด๋ฏ๋ก if ๋ฌธ ๋ธ๋ก์ ์คํํ์ง ์๊ณ ๋น ์ ธ๋์จ๋ค. ๋ฐ๋ผ์ "๋ฏธ์ฑ๋ ์์ ๋๋ค." ๋ ํ๋ฉด์ ์ถ๋ ฅ๋์ง ์๋๋ค.
int age = 20 ์ ๊ฐ์ 15๋ก ๋ณ๊ฒฝํ๋ฉด ๋ฏธ์ฑ๋ ์์ ๋๋ค. ๊ฐ ์ถ๋ ฅ๋๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
else๋ฌธ
else ๋ฌธ์ if ๋ฌธ์์ ๋ง์กฑํ๋ ์กฐ๊ฑด์ด ์์ ๋ ์คํํ๋ ์ฝ๋๋ฅผ ์ ๊ณตํ๋ค.
if (condition) {
//์กฐ๊ฑด์ด ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋
} else {
//๋ง์กฑํ๋ ์กฐ๊ฑด์ด ์์ ๋ ์คํ๋๋ ์ฝ๋
}
else ๋ฌธ์ ์ฌ์ฉํ๋ฉด ์์ ์งํํ๋ ํ๋ก๊ทธ๋จ์ ๋ค์๊ณผ ๊ฐ์ด ๋ ๊ฐ๋ตํ๊ฒ ๋ฐ๊ฟ ์๋ ์๋ค.
- ๊ธฐ์กด : ๋ง์ฝ 18์ด ์ด์์ด๋ฉด "์ฑ์ธ์ ๋๋ค."๋ฅผ ์ถ๋ ฅํ๊ณ , ๋ง์ฝ 18์ด ๋ฏธ๋ง์ด๋ผ๋ฉด "๋ฏธ์ฑ๋ ์์ ๋๋ค."๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค.
- ๋ณ๊ฒฝ : ๋ง์ฝ 18์ด ์ด์์ด๋ฉด "์ฑ์ธ์ ๋๋ค."๋ฅผ ์ถ๋ ฅํ๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด "๋ฏธ์ฑ๋ ์์ ๋๋ค."๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค.
์ฝ๊ฒ ์ด์ผ๊ธฐํด์ 18์ด์ด ๋์ผ๋ฉด ์ฑ์ธ์ด๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด ๋ชจ๋ ๋ฏธ์ฑ๋ ์์ด๋ค.
์๋ง๋ ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋ฉ์ ํด์ผํ ๊ฒ ๊ฐ๋ค.
๋ง์ฝ (๋์ด >= 18)์ด๋ฉด "์ฑ์ธ์
๋๋ค."
๊ทธ๋ ์ง ์์ผ๋ฉด "๋ฏธ์ฑ๋
์์
๋๋ค."
์์ด๋ก ํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
if (age >= 18) "์ฑ์ธ์
๋๋ค."
else "๋ฏธ์ฑ๋
์์
๋๋ค."
If2
package cond;
public class If2 {
public static void main(String[] args) {
int age = 20;
if (age >= 18) {
System.out.println("์ฑ์ธ์
๋๋ค."); //์ฐธ์ผ ๋ ์คํ
} else {
System.out.println("๋ฏธ์ฑ๋
์์
๋๋ค."); //๋ง์กฑํ๋ ์กฐ๊ฑด์ด ์์ ๋ ์คํ
}
}
}
์คํ ๊ฒฐ๊ณผ
์ฑ์ธ์
๋๋ค.
int age = 20 ์ ๊ฐ์ 15 ๋ก ๋ณ๊ฒฝํ๋ฉด ๋ฏธ์ฑ๋ ์์ ๋๋ค. ๊ฐ ์ถ๋ ฅ๋๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
if๋ฌธ 2 - else if
๋ฌธ์
๋น์ ์ ์ฐ๋ น์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด์ผ ํ๋ค.
์ด ํ๋ก๊ทธ๋จ์ int age ๋ผ๋ ๋ณ์๋ฅผ ์ฌ์ฉํด์ผ ํ๋ฉฐ, ์ฐ๋ น์ ๋ฐ๋ผ ๋ค์์ ์ถ๋ ฅ์ ํด์ผ ํ๋ค.
- 7์ธ ์ดํ์ผ ๊ฒฝ์ฐ "๋ฏธ์ทจํ"
- 8์ธ ์ด์ 13์ธ ์ดํ์ผ ๊ฒฝ์ฐ "์ด๋ฑํ์"
- 14์ธ ์ด์ 16์ธ ์ดํ์ผ ๊ฒฝ์ฐ "์คํ์"
- 17์ธ ์ด์ 19์ธ ์ดํ์ผ ๊ฒฝ์ฐ "๊ณ ๋ฑํ์"
- 20์ธ ์ด์์ผ ๊ฒฝ์ฐ "์ฑ์ธ"
if ๋ฌธ์ ์ฌ์ฉํด์ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์.
If3
package cond;
public class If3 {
public static void main(String[] args) {
int age = 14;
if (age <= 7) { //~7 : ๋ฏธ์ทจํ
System.out.println("๋ฏธ์ทจํ");
}
if (8 <= age && age <= 13) { //8~13 : ์ด๋ฑํ์
System.out.println("์ด๋ฑํ์");
}
if (14 <= age && age <= 16) { //14~16 : ์คํ์
System.out.println("์คํ์");
}
if (17 <= age && age <= 19) { //17~19 : ๊ณ ๋ฑํ์
System.out.println("๊ณ ๋ฑํ์");
}
if (age >= 20) { //20~ : ์ฑ์ธ
System.out.println("์ฑ์ธ");
}
}
}
์ด ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ ๋จ์ ์ด ์๋ค.
- ๋ถํ์ํ ์กฐ๊ฑด ๊ฒ์ฌ : ์ด๋ฏธ ์กฐ๊ฑด์ ๋ง์กฑํด๋ ๋ถํ์ํ ๋ค์ ์กฐ๊ฑด์ ๊ณ์ ๊ฒ์ฌํ๋ค. ์๋ฅผ ๋ค์ด์ ๋์ด๊ฐ 5์ด์ด๋ผ๋ฉด ๋ฏธ์ทจํ์ด ์ด๋ฏธ ์ถ๋ ฅ์ด ๋๋ค. ๊ทธ๋ฐ๋ฐ ๋๋จธ์ง if ๋ฌธ์ ํตํ ์กฐ๊ฑด ๊ฒ์ฌ๋ ๋ชจ๋ ์คํํด์ผ ํ๋ค.
- ์ฝ๋ ํจ์จ์ฑ : ์๋ฅผ ๋ค์ด์ ๋์ด๊ฐ 8์ด์ธ ์ด๋ฑํ์์ด๋ผ๋ฉด ๋ฏธ์ทจํ์ ์ฒดํฌํ๋ ์กฐ๊ฑด์ธ age <= 7 ์ ํตํด ๋์ด๊ฐ ์ด๋ฏธ 8์ด์ด ๋๋๋ค๋ ์ฌ์ค์ ์ ์ ์๋ค. ๊ทธ๋ฐ๋ฐ ๋ฐ๋ก ๋ค์์ ์๋ ์ด๋ฑํ์์ ์ฒดํฌํ๋ ์กฐ๊ฑด์์ age >= 8 && age <= 13 ๋ผ๋ 2๊ฐ์ง ์กฐ๊ฑด์ ๋ชจ๋ ์ํํ๋ค. ์ฌ๊ธฐ์ age >= 8 ์ด๋ผ๋ ์กฐ๊ฑด์ ์ด๋ฏธ ์์ age <= 7 ์ด๋ผ๋ ์กฐ๊ฑด๊ณผ ๊ด๋ จ์ด ์๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์กฐ๊ฑด์ ์ค๋ณต ์ฒดํฌํ ๊ฒ์ด๋ค.
์ด๋ฐ ์ฝ๋์ else if ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ถํ์ํ ์กฐ๊ฑด ๊ฒ์ฌ๋ฅผ ํผํ๊ณ ์ฝ๋์ ํจ์จ์ฑ์ ํฅ์์ํฌ ์ ์๋ค.
else if
else if ๋ฌธ์ ์์ if ๋ฌธ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ผ ๋ ๋ค์ ์กฐ๊ฑด์ ๊ฒ์ฌํ๋ค. ๋ง์ฝ ์์ if ๋ฌธ์ด ์ฐธ์ด๋ผ๋ฉด else if ๋ฅผ ์คํํ์ง ์๋๋ค.
if - else ์ฝ๋
if (condition) {
//์กฐ๊ฑด 1์ด ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋
} else if (condition2) {
//์กฐ๊ฑด 1์ด ๊ฑฐ์ง์ด๊ณ , ์กฐ๊ฑด 2๊ฐ ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋
} else if (condition3) {
//์กฐ๊ฑด 2๊ฐ ๊ฑฐ์ง์ด๊ณ , ์กฐ๊ฑด 3์ด ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋
} else {
//๋ชจ๋ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ผ ๋ ์คํ๋๋ ์ฝ๋
}
์ฝ๊ฒ ์ด์ผ๊ธฐํด์ ์ด๋ ๊ฒ ์ ์ฒด if ๋ฌธ์ ํ๋๋ก ๋ฌถ๋๋ค๊ณ ๋ณด๋ฉด ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ํน์ ์กฐ๊ฑด์ด ๋ง์กฑํ๋ฉด ํด๋น ์ฝ๋๋ฅผ ์คํํ๊ณ if ๋ฌธ ์ ์ฒด๋ฅผ ๋น ์ ธ๋์จ๋ค. ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฉด ๋ค์ ์กฐ๊ฑด์ ๊ฒ์ฌํ๋ค. ์ฌ๊ธฐ์ ํต์ฌ์ ์์๋๋ก ๋ง๋ ์กฐ๊ฑด์ ์ฐพ์๋ณด๊ณ , ๋ง๋ ์กฐ๊ฑด์ด ์์ผ๋ฉด ๋ฑ 1๊ฐ๋ง ์คํ์ด ๋๋ ๊ฒ์ด๋ค.
โ๏ธ์ฐธ๊ณ
else ๋ ์๋ตํ ์ ์๋ค.
else ์๋ต ์ฝ๋
if (condition1) {
//์กฐ๊ฑด 1์ด ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋
} else if (condition2) {
//์กฐ๊ฑด 1์ด ๊ฑฐ์ง์ด๊ณ , ์กฐ๊ฑด 2๊ฐ ์ฐธ์ผ ๋ ์คํ๋๋ ์ฝ๋
}
If4
package cond;
public class If4 {
public static void main(String[] args) {
int age = 14;
if (age <= 7) { //~7 : ๋ฏธ์ทจํ
System.out.println("๋ฏธ์ทจํ");
} else if (age <= 13) { //8~13 : ์ด๋ฑํ์
System.out.println("์ด๋ฑํ์");
} else if (age <= 16) { //14~16 : ์คํ์
System.out.println("์คํ์");
} else if (age <= 19) { //17~19 : ๊ณ ๋ฑํ์
System.out.println("๊ณ ๋ฑํ์");
} else if (age >= 20) { //20~ : ์ฑ์ธ
System.out.println("์ฑ์ธ");
}
}
}
age = 7 ์ธ ๊ฒฝ์ฐ
if (age <= 7) ์ ์กฐ๊ฑด์ด ์ฐธ์ด๋ค. "๋ฏธ์ทจํ"์ ์ถ๋ ฅํ๊ณ ์ ์ฒด if ๋ฌธ ๋ฐ์ผ๋ก ๋๊ฐ๋ค.
age = 13์ธ ๊ฒฝ์ฐ
if (age <= 7) ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ด๋ค. ๋ค์ ์กฐ๊ฑด์ผ๋ก ๋์ด๊ฐ๋ค.
else if (age <= 13) ์ ์กฐ๊ฑด์ด ์ฐธ์ด๋ค. "์ด๋ฑํ์"์ ์ถ๋ ฅํ๊ณ ์ ์ฒด if ๋ฌธ ๋ฐ์ผ๋ก ๋๊ฐ๋ค.
age = 50์ธ ๊ฒฝ์ฐ
if (age <= 7) ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ด๋ค. ๋ค์ ์กฐ๊ฑด์ผ๋ก ๋์ด๊ฐ๋ค.
else if (age <= 13) ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ด๋ค. ๋ค์ ์กฐ๊ฑด์ผ๋ก ๋์ด๊ฐ๋ค.
else if (age <= 16) ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ด๋ค. ๋ค์ ์กฐ๊ฑด์ผ๋ก ๋์ด๊ฐ๋ค.
else if (age <= 19) ์ ์กฐ๊ฑด์ด ๊ฑฐ์ง์ด๋ค. ๋ค์ ์กฐ๊ฑด์ผ๋ก ๋์ด๊ฐ๋ค.
else ๋ง์กฑํ๋ ์กฐ๊ฑด ์์ด else ๊น์ง ์๋ค. else ์ ์๋ "์ฑ์ธ"์ ์ถ๋ ฅํ๊ณ if ๋ฌธ ๋ฐ์ผ๋ก ๋๊ฐ๋ค.
if๋ฌธ 3 - if๋ฌธ๊ณผ else if๋ฌธ
if ๋ฌธ์ else if ๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ ๊ฒ์ ์๋ก ์ฐ๊ด๋ ์กฐ๊ฑด์ผ ๋ ์ฌ์ฉํ๋ค. ๊ทธ๋ฐ๋ฐ ์๋ก ๊ด๋ จ์ด ์๋ ๋ ๋ฆฝ ์กฐ๊ฑด์ด๋ฉด else if ๋ฅผ ์ฌ์ฉํ์ง ์๊ณ if ๋ฌธ์ ๊ฐ๊ฐ ๋ฐ๋ก ์ฌ์ฉํด์ผ ํ๋ค.
์์
//์์ 1. if-else ์ฌ์ฉ : ์๋ก ์ฐ๊ด๋ ์กฐ๊ฑด์ด์ฌ์, ํ๋๋ก ๋ฌถ์ ๋
if (condition) {
//์์
1 ์ํ
} else if (condition2) {
//์์
2 ์ํ
}
//์์ 2. if ๊ฐ๊ฐ ์ฌ์ฉ : ๋
๋ฆฝ ์กฐ๊ฑด์ผ ๋
if (condition) {
//์์
1 ์ํ
}
if (condition2) {
//์์
2 ์ํ
}
์์ 1์ ์์ 1, ์์ 2 ๋ ์ค ํ๋๋ง ์ํ๋๋ค. ๊ทธ๋ฐ๋ฐ ์์ 2๋ ์กฐ๊ฑด๋ง ๋ง๋ค๋ฉด ๋ ๋ค ์ํ๋ ์ ์๋ค.
if ๋ฌธ์ ์ฌ๋ฌ ์กฐ๊ฑด์ด ์๋ค๊ณ ํญ์ if - else ๋ก ๋ฌถ์ด์ ์ฌ์ฉํ ์ ์๋ ๊ฒ์ ์๋๋ค. ์กฐ๊ฑด์ด ์๋ก ์ํฅ์ ์ฃผ์ง ์๊ณ ๊ฐ๊ฐ ์ํํด์ผ ํ๋ ๊ฒฝ์ฐ์๋ else if ๋ฌธ์ ์ฌ์ฉํ๋ฉด ์๋๊ณ , ๋์ ์ ์ฌ๋ฌ if ๋ฌธ์ ๋ถ๋ฆฌํด์ ์ฌ์ฉํด์ผ ํ๋ค.
์ฌ๋ฌ ๋ ๋ฆฝ์ ์ธ ์กฐ๊ฑด์ ๊ฒ์ฌํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๊ทธ๋ฐ ์ํฉ์ ๋ํ์ ์ธ ์์์ด๋ค. ์ฆ, ๊ฐ ์กฐ๊ฑด์ด ๋ค๋ฅธ ์กฐ๊ฑด๊ณผ ์ฐ๊ด๋์ง ์๊ณ , ๊ฐ๊ฐ์ ์กฐ๊ฑด์ ๋ํด ๋ณ๋์ ์์ ์ ์ํํด์ผ ํ ๋ ์ด๋ฐ ์ํฉ์ด ๋ฐ์ํ๋ค.
๋ฌธ์
์จ๋ผ์ธ ์ผํ๋ชฐ์ ํ ์ธ ์์คํ ์ ๊ฐ๋ฐํด์ผ ํ๋ค. ํ ์ฌ์ฉ์๊ฐ ์ด๋ค ์ํ์ ๊ตฌ๋งคํ ๋, ๋ค์ํ ํ ์ธ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ด ํ ์ธ ๊ธ์ก์ด ๋ฌ๋ผ์ง ์ ์๋ค.
๊ฐ๊ฐ์ ํ ์ธ ์กฐ๊ฑด์ ๋ค์๊ณผ ๊ฐ๋ค.
- ์์ดํ ๊ฐ๊ฒฉ์ด 10,000์ ์ด์์ผ ๋, 1,000์ ํ ์ธ
- ๋์ด๊ฐ 10์ด ์ดํ์ผ ๋ 1,000์ ํ ์ธ
์ด ํ ์ธ ์์คํ ์ ํต์ฌ์ ํ ์ฌ์ฉ์๊ฐ ๋์์ ์ฌ๋ฌ ํ ์ธ์ ๋ฐ์ ์ ์๋ค๋ ์ ์ด๋ค.
์๋ฅผ ๋ค์ด, 10,000์์ง๋ฆฌ ์์ดํ ์ ๊ตฌ๋งคํ ๋ 1,000์ ํ ์ธ์ ๋ฐ๊ณ , ๋์์ ๋์ด๊ฐ 10์ด ์ดํ์ด๋ฉด ์ถ๊ฐ๋ก 1,000์ ๋ ํ ์ธ์ ๋ฐ๋๋ค.
๊ทธ๋์ ์ด 2,000์๊น์ง ํ ์ธ์ ๋ฐ์ ์ ์๋ค.
If5
package cond;
public class If5 {
public static void main(String[] args) {
int price = 10000;
int age = 10;
int discount = 0;
if (price >= 10000) {
discount += 1000;
System.out.println("10000์ ์ด์ ๊ตฌ๋งค,1000์ ํ ์ธ");
}
if (age <= 10) {
discount += 1000;
System.out.println("์ด๋ฆฐ์ด 1000์ ํ ์ธ");
}
System.out.println("์ด ํ ์ธ๊ธ์ก : " + discount + "์");
}
}
์คํ ๊ฒฐ๊ณผ
//price = 10000, age = 10
10000์ ์ด์ ๊ตฌ๋งค,1000์ ํ ์ธ
์ด๋ฆฐ์ด 1000์ ํ ์ธ
์ด ํ ์ธ๊ธ์ก : 2000์
- ์ด ์ฝ๋์์๋ ๊ฐ๊ฐ ๋ ๋ฆฝ๋ if ๋ฌธ์ด ์๋ค. ๋ฐ๋ผ์ ํด๋นํ๋ ๋ชจ๋ ํ ์ธ์ ์ ์ฉํ๋ค.
- ๋ง์ฝ else if ๋ฅผ ์ฐ๋ฉด , ์ฒซ ๋ฒ์งธ๋ก ์ถฉ์กฑํ๋ ์กฐ๊ฑด๋ง ํ ์ธ์ด ์ ์ฉ๋๊ณ ๋๋จธ์ง๋ ๋ฌด์๋๋ค. ๋ฐ๋ผ์ ์ฌ์ฉ์๋ ํ ์ธ์ ๋์น ์ ์๋ค.
if ๋ฌธ์ ์ฌ์ฉํด์ผ ํ๋ ๊ณณ์ else if ๋ฅผ ์ฌ์ฉํด์ ์ด๋ค ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋์ง ํ์ธํด๋ณด์.
If6
package cond;
public class If6 {
public static void main(String[] args) {
int price = 10000;
int age = 10;
int discount = 0;
if (price >= 10000) {
discount += 1000;
System.out.println("10000์ ์ด์ ๊ตฌ๋งค,1000์ ํ ์ธ");
} else if (age <= 10) {
discount += 1000;
System.out.println("์ด๋ฆฐ์ด 1000์ ํ ์ธ");
} else {
System.out.println("ํ ์ธ ์์");
}
System.out.println("์ด ํ ์ธ๊ธ์ก : " + discount + "์");
}
}
์คํ ๊ฒฐ๊ณผ
//price = 10000, age = 10
10000์ ์ด์ ๊ตฌ๋งค,1000์ ํ ์ธ
์ด ํ ์ธ๊ธ์ก : 1000์
- ์ฒซ ๋ฒ์งธ๋ก ์ถฉ์กฑ๋๋ ์กฐ๊ฑด์ธ 1000์ ํ ์ธ๋ง ์ ์ฉ๋๊ณ , if ๋ฌธ์ ๋น ์ ธ๋์จ๋ค. ๋ฐ๋ผ์ ์ฌ์ฉ์๋ ๋๋จธ์ง ํ ์ธ์ ๋์น๊ฒ ๋๋ค.
์ ๋ฆฌ
if ๋ฌธ์ ๊ฐ๊ฐ ์ฌ์ฉํ ์ง, if ์ else if ๋ฅผ ํจ๊ป ๋ฌถ์ด์ ์ฌ์ฉํ ์ง๋ ์๊ตฌ์ฌํญ์ ๋ฐ๋ผ ๋ค๋ฅด๋ค. ๋์ ์ฐจ์ด๋ฅผ ์ดํดํ๊ณ ์ ์ ํ๊ฒ ์ฌ์ฉํ๋ฉด ๋๋ค.
โ๏ธ์ฐธ๊ณ - if ๋ฌธ { } ์ค๊ดํธ ์๋ต
๋ค์๊ณผ ๊ฐ์ด if ๋ฌธ ๋ค์์ ์คํํ ๋ช ๋ น์ด ํ๋๋ง ์์ ๊ฒฝ์ฐ์๋ { } ์ค๊ดํธ๋ฅผ ์๋ตํ ์ ์๋ค. else if , else ๋ ๋ง์ฐฌ๊ฐ์ง์ด๋ค.
if (true) System.out.println("if๋ฌธ์์ ์คํ๋จ");โ
๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์๋ ๋ ๋ฒ์งธ ๋ฌธ์ฅ์ if ๋ฌธ๊ณผ ๋ฌด๊ดํ๋ค. ๋ง์ฝ if ๋ฌธ์ ํฌํจํ๋ ค๋ฉด { } ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
if (true) System.out.println("if๋ฌธ์์ ์คํ๋จ"); System.out.println("if๋ฌธ์์ ์คํ ์๋จ");
์คํ ๊ฒฐ๊ณผ
if๋ฌธ์์ ์คํ๋จ
๋ง์ฝ ๋ ๋ค if ๋ฌธ ์์ ํฌํจํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด { } ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.if (true) { System.out.println("if๋ฌธ์์ ์คํ๋จ"); System.out.println("if๋ฌธ์์ ์คํ ์๋จ"); }
ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ง๋ง, ์ผ๋ฐ์ ์ผ๋ก if ๋ฌธ์ ๋ช ๋ น์ด ํ ๊ฐ๋ง ์์ ๊ฒฝ์ฐ์๋ ๋ค์๊ณผ ๊ฐ์ ์ด์ ๋ก ์ค๊ดํธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
- ๊ฐ๋ ์ฑ : ์ค๊ดํธ๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋๋ฅผ ๋ ์ฝ๊ธฐ ์ฝ๊ฒ ๋ง๋ค์ด ์ค๋ค. ์กฐ๊ฑด๋ฌธ์ ๋ฒ์๊ฐ ๋ช ํํ๊ฒ ํ์๋๋ฏ๋ก ์ฝ๋์ ํ๋ฆ์ ๋ ์ฝ๊ฒ ์ดํดํ ์ ์๋ค.
- ์ ์ง๋ณด์์ฑ : ์ค๊ดํธ๋ฅผ ์ฌ์ฉํ๋ฉด ๋์ค์ ์ฝ๋๋ฅผ ์์ ํ ๋ ์ค๋ฅ๋ฅผ ๋ ๋ฐ์์ํฌ ์ ์๋ค. ์๋ฅผ ๋ค์ด, if ๋ฌธ์ ๋ ๋ค๋ฅธ ์ฝ๋๋ฅผ ์ถ๊ฐํ๋ ค๊ณ ํ ๋, ์ค๊ดํธ๊ฐ ์์ผ๋ฉด ์ด ์ฝ๋๊ฐ if ๋ฌธ์ ์ผ๋ถ๋ผ๋ ๊ฒ์ด ๋ช ํํ์ง ์๋ค.
switch๋ฌธ
๋ฌธ์
๋น์ ์ ํ์ ๋ฑ๊ธ์ ๋ฐ๋ผ ๋ค๋ฅธ ์ฟ ํฐ์ ๋ฐ๊ธํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด์ผ ํ๋ค.
์ด ํ๋ก๊ทธ๋จ์ int grade ๋ผ๋ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ฉฐ, ํ์ ๋ฑ๊ธ(grade)์ ๋ฐ๋ผ ๋ค์์ ์ฟ ํฐ์ ๋ฐ๊ธํด์ผ ํ๋ค.
- 1๋ฑ๊ธ : ์ฟ ํฐ 1000
- 2๋ฑ๊ธ : ์ฟ ํฐ 2000
- 3๋ฑ๊ธ : ์ฟ ํฐ 3000
- ์์ ๋ฑ๊ธ์ด ์๋ ๊ฒฝ์ฐ : ์ฟ ํฐ 500
๊ฐ ์ฟ ํฐ์ด ํ ๋น๋ ํ์๋ "๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ" + ์ฟ ํฐ๊ฐ ์ ์ถ๋ ฅํด์ผ ํ๋ค.
2๋ฑ๊ธ ์ฌ์ฉ์ ์ถ๋ ฅ ์)
๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ 2000
if ๋ฌธ์ ์ฌ์ฉํด์ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์.
Switch1
package cond;
public class Switch1 {
public static void main(String[] args) {
int grade = 2;
int coupon;
if (grade == 1) {
coupon = 1000;
} else if (grade == 2) {
coupon = 2000;
} else if (grade == 3) {
coupon = 3000;
} else {
coupon = 500;
}
System.out.println("๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ " + coupon);
}
}
์คํ ๊ฒฐ๊ณผ
๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ 2000
switch ๋ฌธ
switch ๋ฌธ์ ์์ ๋ฐฐ์ด if ๋ฌธ์ ์กฐ๊ธ ๋ ํธ๋ฆฌํ๊ฒ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฅ์ด๋ค.
์ฐธ๊ณ ๋ก if ๋ฌธ์ ๋น๊ต ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ์ ์์ง๋ง, switch ๋ฌธ์ ๋จ์ํ ๊ฐ์ด ๊ฐ์์ง๋ง ๋น๊ตํ ์ ์๋ค.
switch ๋ฌธ์ ์กฐ๊ฑด์์ ํด๋นํ๋ ํน์ ๊ฐ์ผ๋ก ์คํํ ์ฝ๋๋ฅผ ์ ํํ๋ค.
switch (์กฐ๊ฑด์) {
case value1:
//์กฐ๊ฑด์์ ๊ฒฐ๊ณผ ๊ฐ์ด value1์ผ ๋ ์คํ๋๋ ์ฝ๋
break;
case value2:
//์กฐ๊ฑด์์ ๊ฒฐ๊ณผ ๊ฐ์ด value2์ผ ๋ ์คํ๋๋ ์ฝ๋
break;
default:
//์กฐ๊ฑด์์ ๊ฒฐ๊ณผ ๊ฐ์ด ์์ ์ด๋ค ๊ฐ์๋ ํด๋นํ์ง ์์ ๋ ์คํ๋๋ ์ฝ๋
}
- ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ ๊ฐ์ด ์ด๋ค case ์ ๊ฐ๊ณผ ์ผ์นํ๋ฉด ํด๋น case์ ์ฝ๋๋ฅผ ์คํํ๋ค.
- break ๋ฌธ์ ํ์ฌ ์คํ ์ค์ธ ์ฝ๋๋ฅผ ๋๋ด๊ณ switch ๋ฌธ์ ๋น ์ ธ๋๊ฐ๊ฒ ํ๋ ์ญํ ์ ํ๋ค.
- ๋ง์ฝ break ๋ฌธ์ด ์์ผ๋ฉด, ์ผ์นํ๋ case ์ดํ์ ๋ชจ๋ case ์ฝ๋๋ค์ด ์์๋๋ก ์คํ๋๋ค.
- default ๋ ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ ๊ฐ์ด ๋ชจ๋ case ์ ๊ฐ๊ณผ ์ผ์นํ์ง ์์ ๋ ์คํ๋๋ค. if ๋ฌธ์ else์ ๊ฐ๋ค. default ๊ตฌ๋ฌธ์ ์ ํ์ด๋ค.
- if ,else - if, else ๊ตฌ์กฐ์ ๋์ผํ๋ค.
Switch2
package cond;
public class Switch2 {
public static void main(String[] args) {
//grade 1:1000, 2:2000, 3:3000, ๋๋จธ์ง:500
int grade = 2;
int coupon;
switch (grade) {
case 1:
coupon = 1000;
break;
case 2:
coupon = 2000;
break;
case 3:
coupon = 3000;
break;
default:
coupon = 500;
}
System.out.println("๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ " + coupon);
}
}
์คํ ๊ฒฐ๊ณผ
๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ 2000
break ๋ฌธ์ด ์๋ค๋ฉด?
๋ง์ฝ break ๋ฌธ์ด ์์ผ๋ฉด ์ด๋ป๊ฒ ๋๋์ง ํ์ธํ๊ธฐ ์ํด ์กฐ๊ฑด์ ๋ณ๊ฒฝํด๋ณด์.
๋น์ฆ๋์ค ์๊ตฌ์ฌํญ์ด ๋ณ๊ฒฝ๋์๋ค. 2๋ฑ๊ธ๋ 3๋ฑ๊ธ๊ณผ ๊ฐ์ด 3000์ ์ฟ ํฐ์ ์ค๋ค๊ณ ํด๋ณด์.
Switch3
package cond;
public class Switch2 {
public static void main(String[] args) {
//grade 1:1000, 2:3000(๋ณ๊ฒฝ), 3:3000, ๋๋จธ์ง:500
int grade = 2;
int coupon;
switch (grade) {
case 1:
coupon = 1000;
break;
case 2:
case 3:
coupon = 3000;
break;
default:
coupon = 500;
}
System.out.println("๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ " + coupon);
}
}
- ์๋ฅผ ๋ค์ด์ grade ๊ฐ 2๋ฑ๊ธ์ด๋ฉด ๋จผ์ case 2 ๊ฐ ์คํ๋๋ค.
- ๊ทธ๋ฐ๋ฐ case 2 ์๋ break ๋ฌธ์ด ์๋ค. ๊ทธ๋ฌ๋ฉด ์ค๋จํ์ง ์๊ณ ๋ฐ๋ก ๋ค์์ ์๋ case 3 ์ ์ฝ๋๋ฅผ ์คํํ๋ค. ์ฌ๊ธฐ์ coupon = 3000; ์ ์ํํ๊ณ break ๋ฌธ์ ๋ง๋์ switch ๋ฌธ ๋ฐ์ผ๋ก ๋น ์ ธ๋๊ฐ๋ค.
- "๋ฐ๊ธ๋ฐ์ ์ฟ ํฐ 3000" ์ด ์ถ๋ ฅ๋๋ค.
if๋ฌธ vs switch๋ฌธ
switch ๋ฌธ์ ์กฐ๊ฑด์์ ๋ฃ๋ ๋ถ๋ถ์ ์ ๋ณด๋ฉด x > 10 ๊ณผ ๊ฐ์ ์ฐธ ๊ฑฐ์ง์ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋ ์กฐ๊ฑด์ด ์๋๋ผ, ๋จ์ํ ๊ฐ๋ง ๋ฃ์ ์ ์๋ค. switch ๋ฌธ์ ์กฐ๊ฑด์์ด ํน์ case ์ ๊ฐ์์ง๋ง ์ฒดํฌํ ์ ์๋ค. ์ฝ๊ฒ ์ด์ผ๊ธฐํด์ ๊ฐ์ด ๊ฐ์์ง ํ์ธํ๋ ์ฐ์ฐ๋ง ๊ฐ๋ฅํ๋ค. (๋ฌธ์๋ ๊ฐ๋ฅ)
๋ฐ๋ฉด์ if ๋ฌธ์ ์ฐธ ๊ฑฐ์ง์ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋ ์กฐ๊ฑด์์ ์์ ๋กญ๊ฒ ์ ์ ์ ์๋ค. ์) x > 10, x == 10
์ ๋ฆฌํ์๋ฉด switch ๋ฌธ ์์ด if ๋ฌธ๋ง ์ฌ์ฉํด๋ ๋๋ค. ํ์ง๋ง ํน์ ๊ฐ์ ๋ฐ๋ผ ์ฝ๋๋ฅผ ์คํํ ๋๋ switch ๋ฌธ์ ์ฌ์ฉํ๋ฉด if ๋ฌธ๋ณด๋ค ๊ฐ๊ฒฐํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
์ผํญ ์ฐ์ฐ์
if ๋ฌธ์ ์ฌ์ฉํ ๋ ๋ค์๊ณผ ๊ฐ์ด ๋จ์ํ ์ฐธ๊ณผ ๊ฑฐ์ง์ ๋ฐ๋ผ ํน์ ๊ฐ์ ๊ตฌํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค.
CondOp1
package cond;
public class CondOp1 {
public static void main(String[] args) {
int age = 18;
String status;
if (age >= 18) {
status = "์ฑ์ธ";
} else {
status = "๋ฏธ์ฑ๋
์";
}
System.out.println("age = " + age + ", status = " + status);
}
}
์คํ ๊ฒฐ๊ณผ, age = 18
age = 18, status = ์ฑ์ธ
์คํ ๊ฒฐ๊ณผ, age = 17
age = 17, status = ๋ฏธ์ฑ๋
์
์ด ์์ ๋ ์ฐธ๊ณผ ๊ฑฐ์ง์ ๋ฐ๋ผ status ๋ณ์์ ๊ฐ์ด ๋ฌ๋ผ์ง๋ค.
์ด๋ ๊ฒ ๋จ์ํ ์ฐธ๊ณผ ๊ฑฐ์ง์ ๋ฐ๋ผ์ ํน์ ๊ฐ์ ๊ตฌํ๋ ๊ฒฝ์ฐ ์ผํญ ์ฐ์ฐ์ ๋๋ ์กฐ๊ฑด ์ฐ์ฐ์๋ผ๊ณ ๋ถ๋ฆฌ๋ ? : ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
์ด ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด if ๋ฌธ๊ณผ ๋น๊ตํด์ ์ฝ๋๋ฅผ ๋จ์ํ ํ ์ ์๋ค.
CondOp2
package cond;
public class CondOp2 {
public static void main(String[] args) {
int age = 18;
String status = (age >= 18) ? "์ฑ์ธ" : "๋ฏธ์ฑ๋
์";
System.out.println("age = " + age + ", status = " + status);
}
}
์คํ ๊ฒฐ๊ณผ ๋ถ์
String status = (age >= 18) ? "์ฑ์ธ" : "๋ฏธ์ฑ๋
์"; //age=18
String status = (true) ? "์ฑ์ธ" : "๋ฏธ์ฑ๋
์"; //์กฐ๊ฑด์ด ์ฐธ์ด๋ฏ๋ก ์ฐธ ํํ์ ๋ถ๋ถ์ด ์ ํ๋๋ค.
String status = "์ฑ์ธ"; //๊ฒฐ๊ณผ
์ผํญ ์ฐ์ฐ์
(์กฐ๊ฑด) ? ์ฐธ_ํํ์ : ๊ฑฐ์ง_ํํ์
- ์ผํญ ์ฐ์ฐ์๋ ํญ์ด 3๊ฐ๋ผ๋ ๋ป์ด๋ค. ์กฐ๊ฑด, ์ฐธ_ํํ์, ๊ฑฐ์ง_ํํ์ ์ด๋ ๊ฒ ํญ์ด 3๊ฐ์ด๋ค. ์๋ฐ์์ ์ ์ผํ๊ฒ ํญ์ด 3๊ฐ์ธ ์ฐ์ฐ์์ฌ์ ์ผํญ ์ฐ์ฐ์๋ผ๊ณ ํ๋ค. ๋๋ ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋์ค๊ธฐ ๋๋ฌธ์ ์กฐ๊ฑด ์ฐ์ฐ์๋ผ๊ณ ๋ ํ๋ค.
- ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์ฐธ_ํํ์ ์ด ์คํ๋๊ณ , ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฉด ๊ฑฐ์ง_ํํ์ ์ด ์คํ๋๋ค. ์์ if, else ๋ฌธ๊ณผ ์ ์ฌํ๋ค.
- if ๋ฌธ์ฒ๋ผ ์ฝ๋ ๋ธ๋ญ์ ๋ฃ์ ์ ์๋ ๊ฒ์ด ์๋๋ผ ๋จ์ํ ํํ์๋ง ๋ฃ์ ์ ์๋ค.
์ผํญ ์ฐ์ฐ์ ์์ด if ๋ฌธ๋ง ์ฌ์ฉํด๋ ๋๋ค. ํ์ง๋ง ๋จ์ํ ์ฐธ๊ณผ ๊ฑฐ์ง์ ๋ฐ๋ผ์ ํน์ ๊ฐ์ ๊ตฌํ๋ ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด if ๋ฌธ๋ณด๋ค ๊ฐ๊ฒฐํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
๋ฌธ์ ์ ํ์ด 1
๋ฌธ์ : "ํ์ ๊ณ์ฐํ๊ธฐ"
ํ์์ ์ ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ ์ ์ถ๋ ฅํ๋ ์๋ฐ ํ๋ก๊ทธ๋จ์ ์์ฑํ์. ๋ค์๊ณผ ๊ฐ์ ๊ธฐ์ค์ ๋ฐ๋ฅธ๋ค.
- 90์ ์ด์ : "A"
- 80์ ์ด์ 90์ ๋ฏธ๋ง : "B"
- 70์ ์ด์ 80์ ๋ฏธ๋ง : "C"
- 60์ ์ด์ 70์ ๋ฏธ๋ง : "D"
- 60์ ๋ฏธ๋ง "F"
์ ์๋ ๋ณ์(int score)๋ก ์ง์ ํ๊ณ , ํด๋น ๋ณ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ ์ ์ถ๋ ฅํ์.
์ ๋ต : "ํ์ ๊ณ์ฐํ๊ธฐ"
package cond.ex;
public class ScoreEx {
public static void main(String[] args) {
int score = 55;
if (score >= 90) {
System.out.println("ํ์ ์ A์
๋๋ค.");
} else if (score >= 80) {
System.out.println("ํ์ ์ B์
๋๋ค.");
} else if (score >= 70) {
System.out.println("ํ์ ์ C์
๋๋ค.");
} else if (score >= 60) {
System.out.println("ํ์ ์ D์
๋๋ค.");
} else {
System.out.println("ํ์ ์ F์
๋๋ค.");
}
}
}
๋ฌธ์ : "๊ฑฐ๋ฆฌ์ ๋ฐ๋ฅธ ์ด์ก ์๋จ ์ ํํ๊ธฐ"
์ฃผ์ด์ง ๊ฑฐ๋ฆฌ์ ๋ฐ๋ผ ๊ฐ์ฅ ์ ํฉํ ์ด์ก ์๋จ์ ์ ํํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์. ๋ค์๊ณผ ๊ฐ์ ๊ธฐ์ค์ ๋ฐ๋ฅธ๋ค.
- ๊ฑฐ๋ฆฌ๊ฐ 1km ์ดํ์ด๋ฉด : "๋๋ณด"
- ๊ฑฐ๋ฆฌ๊ฐ 10km ์ดํ์ด๋ฉด : "์์ ๊ฑฐ"
- ๊ฑฐ๋ฆฌ๊ฐ 100km ์ดํ์ด๋ฉด : "์๋์ฐจ"
- ๊ฑฐ๋ฆฌ๊ฐ 100km ์ด๊ณผ์ด๋ฉด : "๋นํ๊ธฐ"
๊ฑฐ๋ฆฌ๋ ๋ณ์(int distance)๋ก ์ง์ ํ๊ณ , ํด๋น ๋ณ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ด์ก ์๋จ์ ์ถ๋ ฅํ์.
์ ๋ต : "๊ฑฐ๋ฆฌ์ ๋ฐ๋ฅธ ์ด์ก ์๋จ ์ ํํ๊ธฐ"
package cond.ex;
public class DistanceEx {
public static void main(String[] args) {
int distance = 20;
if (distance <= 1) {
System.out.println("๋๋ณด๋ฅผ ์ด์ฉํ์ธ์.");
} else if (distance <= 10) {
System.out.println("์์ ๊ฑฐ๋ฅผ ์ด์ฉํ์ธ์.");
} else if (distance <= 100) {
System.out.println("์๋์ฐจ๋ฅผ ์ด์ฉํ์ธ์.");
} else {
System.out.println("๋นํ๊ธฐ๋ฅผ ์ด์ฉํ์ธ์.");
}
}
}
๋ฌธ์ : "ํ์จ ๊ณ์ฐํ๊ธฐ"
ํน์ ๊ธ์ก์ ๋ฏธ๊ตญ ๋ฌ๋ฌ์์ ํ๊ตญ ์์ผ๋ก ๋ณํํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์. ํ์จ์ 1๋ฌ๋ฌ๋น 1300์์ด๋ผ๊ณ ๊ฐ์ ํ๋ค. ๋ค์๊ณผ ๊ฐ์ ๊ธฐ์ค์ ๋ฐ๋ฅธ๋ค.
- ๋ฌ๋ฌ๊ฐ 0 ๋ฏธ๋ง์ด๋ฉด : "์๋ชป๋ ๊ธ์ก์ ๋๋ค."
- ๋ฌ๋ฌ๊ฐ 0์ผ ๋ : "ํ์ ํ ๊ธ์ก์ด ์์ต๋๋ค."
- ๋ฌ๋ฌ๊ฐ 0 ์ด๊ณผ์ผ ๋ : "ํ์ ๊ธ์ก์ (๊ณ์ฐ๋ ์ํ ๊ธ์ก)์์ ๋๋ค."
๊ธ์ก์ ๋ณ์ (int dollar)๋ก ์ง์ ํ๊ณ , ํด๋น ๋ณ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๊ตญ ์์ผ๋ก์ ํ์ ๊ธ์ก์ ์ถ๋ ฅํ์.
์ ๋ต : "ํ์จ ๊ณ์ฐํ๊ธฐ"
package cond.ex;
public class DollarEx {
public static void main(String[] args) {
int dollar = 5;
if (dollar < 0) {
System.out.println("์๋ชป๋ ๊ธ์ก์
๋๋ค.");
} else if (dollar == 0) {
System.out.println("ํ์ ํ ๊ธ์ก์ด ์์ต๋๋ค.");
} else {
int won = dollar * 1300;
System.out.println("ํ์ ๊ธ์ก์ " + won + "์์
๋๋ค.");
}
}
}
๋ฌธ์ ์ ํ์ด 2
๋ฌธ์ : "ํ์ ์ ๋ฐ๋ฅธ ์ํ ์ถ์ฒํ๊ธฐ"
์์ฒญํ ํ์ ์ด์์ ์ํ๋ฅผ ์ฐพ์์ ์ถ์ฒํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์.
- ์ด๋ฐ์ํ์ - ํ์ 9
- ํ ์ด ์คํ ๋ฆฌ - ํ์ 8
- ๊ณ ์ง๋ผ - ํ์ 7
ํ์ ๋ณ์๋ double rating ์ ์ฌ์ฉํ์ธ์. if ๋ฌธ์ ํ์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์.
์ ๋ต : "ํ์ ์ ๋ฐ๋ฅธ ์ํ ์ถ์ฒํ๊ธฐ"
package cond.ex;
public class MoveRateEx {
public static void main(String[] args) {
double rating = 7.1;
if (rating <= 9) {
System.out.println("'์ด๋ฐ์ํ์'์ ์ถ์ฒํฉ๋๋ค.");
}
if (rating <= 8) {
System.out.println("'ํ ์ด ์คํ ๋ฆฌ๋ฅผ ์ถ์ฒํฉ๋๋ค.");
}
if (rating <= 7) {
System.out.println("๊ณ ์ง๋ผ๋ฅผ ์ถ์ฒํฉ๋๋ค.");
}
}
}
๋ฌธ์ : "ํ์ ์ ๋ฐ๋ฅธ ์ฑ์ทจ๋ ์ถ๋ ฅํ๊ธฐ"
String grade ๋ผ๋ ๋ฌธ์์ด์ ๋ง๋ค๊ณ , ํ์ ์ ๋ฐ๋ผ ์ฑ์ทจ๋๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์. ๊ฐ ํ์ ์ ๋ค์๊ณผ ๊ฐ์ ์ฑ์ทจ๋๋ฅผ ๋ํ๋ธ๋ค.
- "A" : "ํ์ํ ์ฑ๊ณผ์ ๋๋ค."
- "B" : "์ข์ ์ฑ๊ณผ์ ๋๋ค."
- "C" : "์ค์ํ ์ฑ๊ณผ์ ๋๋ค."
- "D" : "ํฅ์์ด ํ์ํฉ๋๋ค."
- "F" : "๋ถํฉ๊ฒฉ์ ๋๋ค."
- ๋๋จธ์ง : "์๋ชป๋ ํ์ ์ ๋๋ค."
switch ๋ฌธ์ ์ฌ์ฉํด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์.
์ ๋ต : "ํ์ ์ ๋ฐ๋ฅธ ์ฑ์ทจ๋ ์ถ๋ ฅํ๊ธฐ"
package cond.ex;
public class GradeSwitchEx {
public static void main(String[] args) {
String grade = "A";
switch (grade){
case "A":
System.out.println("ํ์ํ ์ฑ๊ณผ์
๋๋ค.");
break;
case "B":
System.out.println("์ข์ ์ฑ๊ณผ์
๋๋ค.");
break;
case "C":
System.out.println("์ค์ํ ์ฑ๊ณผ์
๋๋ค.");
break;
case "D":
System.out.println("ํฅ์์ด ํ์ํฉ๋๋ค.");
break;
case "F":
System.out.println("๋ถํฉ๊ฒฉ์
๋๋ค.");
break;
default:
System.out.println("์๋ชป๋ ํ์ ์
๋๋ค.");
}
}
}
๋ฌธ์ : "๋ ํฐ ์ซ์ ์ฐพ๊ธฐ"
์ฌ๋ฌ๋ถ์ ๋ ๊ฐ์ ์ ์ ๋ณ์ a ์ b ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. a ์ ๊ฐ์ 10 ์ด๊ณ , b ์ ๊ฐ์ 20 ์ด๋ค. ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ ์ซ์ ์ค ๋ ํฐ ์ซ์๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์์ฑํ์.
์ ๋ต : "๋ ํฐ ์ซ์ ์ฐพ๊ธฐ"
package cond.ex;
public class CondEx {
public static void main(String[] args) {
int a = 10;
int b = 20;
int max = (a < b) ? b : a;
System.out.println("๋ ํฐ ์ซ์๋ " + max + "์
๋๋ค.");
}
}
๋ฌธ์ : "ํ์ ์ง์ ์ฐพ๊ธฐ"
์ ์ x ๊ฐ ์ฃผ์ด์ง๋ฉด x ๊ฐ ์ง์์ด๋ฉด "์ง์"๋ฅผ, x ๊ฐ ํ์์ด๋ฉด "ํ์"๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์.
์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
์ฐธ๊ณ ๋ก x % 2๋ฅผ ์ฌ์ฉํ๋ฉด ํ์, ์ง์๋ฅผ ์ฝ๊ฒ ๊ณ์ฐํ ์ ์๋ค.
์ ๋ต : "ํ์ ์ง์ ์ฐพ๊ธฐ"
package cond.ex;
public class EvenOddEx {
public static void main(String[] args) {
int x = 2;
String result = (x % 2 == 0) ? "์ง์" : "ํ์";
System.out.println("x = " + x + ", " + result);
}
}
'๐ Java > ๐ Java ๊ฐ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Java ์ ๋ฌธ ๊ฐ์_์ค์ฝํ, ํ๋ณํ (6) | 2024.11.01 |
---|---|
Java ์ ๋ฌธ ๊ฐ์_๋ฐ๋ณต๋ฌธ (1) | 2024.10.29 |
Java ์ ๋ฌธ ๊ฐ์_์ฐ์ฐ์ (9) | 2024.10.24 |
Java ์ ๋ฌธ ๊ฐ์_๋ณ์ (5) | 2024.10.23 |
Java ์ ๋ฌธ ๊ฐ์_Hello World (8) | 2024.10.23 |