์๋ฐ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ฉด ๋ณดํต ๋ช ๋ น์ ์์ฐจ์ ์ผ๋ก(์ฝ๋๋ฅผ ์์์ ์๋๋ก) ์คํํ๋ค. ํ์ง๋ง ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ช ๋ น์ ์ํํ๊ฑฐ๋ ์ํํ์ง ์์์ผ ํ ๋๊ฐ ์๋ค. ์ด๋ด ๋ ์ฐ๋ฆฌ๋ ์กฐ๊ฑด๋ฌธ์ ์ฌ์ฉํ๋ฉฐ, ์ด ์ฅ์์๋ ์กฐ๊ฑด๋ฌธ์ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง ๊ทธ๋ฆฌ๊ณ ์กฐ๊ฑด๋ฌธ์ ์ข ๋ฅ๋ก๋ ๋ฌด์์ด ์๋์ง ์ดํด๋ณผ ๊ฒ์ด๋ค.
4.1. ์กฐ๊ฑด์ด ํ๋์ผ ๋: if-else
์กฐ๊ฑด๋ฌธ์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์คํํ๋ ๋ช ๋ น์ด ๋ฌ๋ผ์ง๋ค. ๊ธฐ๋ณธ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด if ๋ธ๋ก์ ์คํ๋ฌธ์ด ์ถ๋ ฅ๋๊ณ , ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฉด else ๋ธ๋ก์ ์คํ๋ฌธ์ด ์ถ๋ ฅ๋๋ค.
if ([์กฐ๊ฑด]) {
[์คํ๋ฌธ]; //์กฐ๊ฑด์ ๋ง์กฑํ ๋ ์คํํ ๋ช
๋ น๋ฌธ
}
else{
[์คํ๋ฌธ]; //์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ ๋ ์คํํ ๋ช
๋ น๋ฌธ
}
if-else ๋ฌธ์์ ์ค๊ดํธ{}๋ ์คํํ ๋ช ๋ น๋ฌธ์ ๋ฒ์๋ฅผ ๋ช ์ํ๋ฉฐ, ์คํํ ๋ช ๋ น๋ฌธ์ด ํ๋์ผ ๊ฒฝ์ฐ ์ค๊ดํธ๋ฅผ ์๋ตํด๋ ๋๋ค. ํ์ง๋ง ์ ๋ฌธ์๋ ํ์์ ์ตํ๋ ๊ฒ์ด ์ค์ํ๋ฏ๋ก ์์ผ๋ก์ ์ฝ๋์์๋ ์ค๊ดํธ๋ฅผ ์๋ตํ์ง ์๊ณ ๋ชจ๋ ํ์ํ ๊ฒ์ด๋ค.
4.1.1. ์กฐ๊ฑด์ ๋ง์กฑํ ๋(if) / ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ ๋(else) โ
public class Main {
public static void main(String[] args) {
int score = 90;
if (score >= 90) {
System.out.println("Aํ์ ์
๋๋ค.");
}
else{
System.out.println("Aํ์ ์ด ์๋๋๋ค.");
}
}
}
// Aํ์ ์
๋๋ค.
// int score = 90;
score๋ผ๋ ์ ์ํ ๋ณ์๋ฅผ ์ ์ธํ๊ณ , ์ ์๋ฅผ ๋ฃ์ด ๋ณ์๋ฅผ ์ด๊ธฐํํ๋ค.
// if (score >= 90)
"score๊ฐ 90 ์ด์"์ ์กฐ๊ฑด์ผ๋ก ํ๋ค. >=๋ ์ด์์ ๋ํ๋ด๋ ์ฐ์ฐ์์ด๋ค. score์ ํ์ฌ ๊ฐ์ 90์ด๊ณ , if๋ฌธ์ ์กฐ๊ฑด์์ score์ ๊ฐ์ด 90 ์ด์์ธ์ง ํ์ธํ๋ค. ์ฌ๊ธฐ์๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฏ๋ก if๋ฌธ์ ๋ช ๋ น๋ฌธ์ ์คํํ๋ค.
//else
๋ง์ฝ score๊ฐ 90์ด ์๋ 80์ด๋ผ๊ณ ํ๋ค๋ฉด, ์ด๋ฒ์๋ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฏ๋ก else๋ฌธ์ ๋ช ๋ น๋ฌธ์ด ์คํ๋ ๊ฒ์ด๋ค.
์ด์ฒ๋ผ ์กฐ๊ฑด๋ฌธ์ ์กฐ๊ฑด์ ๋ง์กฑํ ๋, ํ๋จ ๊ฒฐ๊ณผ๊ฐ ์ฐธ์ผ ๋๋ฅผ true๋ผ๊ณ ํ๊ณ ๋ง์กฑํ์ง ์์ ๋, ์ฆ ๊ฑฐ์ง์ผ ๋๋ฅผ false๋ผ๊ณ ํ๋ค. ์์๋์ ํจ๊ป ์ดํดํด๋ณด์. ๋ง๋ฆ๋ชจ๋ ํ๋จ์ ์๋ฏธํ๋ฉฐ, ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ถ๊ธฐ๋๋ค. ์ง์ฌ๊ฐํ์ ์ฐ์ฐ์ด๋ ์ฒ๋ฆฌ ๊ณผ์ ์ ๋ํ๋ด๊ณ , ํ์ดํ๋ ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ๋ํ๋ด๋ ์ ์ด๋ค.
์์๋๋ฅผ ์์ฑํ๋ฉด ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ํ๋์ ๋ณผ ์ ์์ผ๋ฏ๋ก, ํ๋ก๊ทธ๋จ์ ์์ฑํ๊ธฐ ์ ์ ๊ทธ๋ ค๋ณด๋ฉด ๋์์ด ๋๋ค.
4.1.2. ๋น๊ต ์ฐ์ฐ์
๊ฐ์ ๋น๊ตํ๋ ์ฐ์ฐ์๋ฅผ ๋น๊ต ์ฐ์ฐ์๋ผ๊ณ ํ๋ค. ์์์ ๋ดค๋ >=๋ ๋น๊ต ์ฐ์ฐ์์ด๋ค. ์๋ฐ์์ ์ฌ์ฉํ๋ ๋น๊ต ์ฐ์ฐ์๋ ๋ค์๊ณผ ๊ฐ๋ค.
์ฐ์ฐ์ | ์ค๋ช |
== | ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์ด ๊ฐ์ผ๋ฉด ์ฐธ |
!= | ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์ด ๊ฐ์ง ์์ผ๋ฉด ์ฐธ |
> | ์ผ์ชฝ์ด ์ค๋ฅธ์ชฝ๋ณด๋ค ํฌ๋ฉด ์ฐธ |
< | ์ผ์ชฝ์ด ์ค๋ฅธ์ชฝ๋ณด๋ค ์์ผ๋ฉด ์ฐธ |
>= | ์ผ์ชฝ์ด ์ค๋ฅธ์ชฝ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ์ฐธ |
<= | ์ผ์ชฝ์ด ์ค๋ฅธ์ชฝ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ผ๋ฉด ์ฐธ |
4.1.3. QUIZ
๋ฌธ์ ์ค๋ช )
๋ค์ ์ฝ๋๋ ์ ๋ ฅ๋ฐ์ ์ ์๊ฐ ์ง์๋ฉด '์ง์'๋ผ๊ณ ์ถ๋ ฅํ๊ณ , ํ์์ด๋ฉด 'ํ์'๋ผ๊ณ ์ถ๋ ฅํ๋ค. ๋น์นธ์ ์๋ง์ ์ฝ๋๋ฅผ ์์ฑํ์์ค.
๋ด๊ฐ ์ง ์ฝ๋) - ๋ง์. ์ ๋ต ์ฝ๋์๋ num%2 == 1๋ก ์กฐ๊ฑด์ ์์ฑํจ
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
if (num%2 != 0){ //์กฐ๊ฑด๋ฌธ์ด ๋น์นธ
System.out.println("ํ์");
}
else{
System.out.println("์ง์");
}
}
}
/*7
ํ์*/
4.2. ์กฐ๊ฑด์ด ์ฌ๋ฌ ๊ฐ์ผ ๋: else if โ
- if-else๋ฌธ: ์กฐ๊ฑด์ด ํ๋๊ณ , ์ด๋ฅผ ๋ง์กฑํ๋ ๊ฒฝ์ฐ์ ์๋ ๊ฒฝ์ฐ๋ก ๋๋ ๋ ์ฌ์ฉ(true or false)
- else if๋ฌธ: ์กฐ๊ฑด์ด ์ฌ๋ฌ๊ฐ์ผ ๋ ์ฌ์ฉ
else if ๋ธ๋ก์ ์ฌ์ฉํ๋ ์กฐ๊ฑด๋ฌธ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค. ๊ฐ๊ฐ์ ์กฐ๊ฑด๋ฌธ์ true์ผ ๋ ์ง์ ํ๋ฉฐ, false์ผ ๊ฒฝ์ฐ ์กฐ๊ฑด์ ๋ง๋ ์กฐ๊ฑด๋ฌธ์ด ์์ ๋๊น์ง ๋ด๋ ค๊ฐ๋ค. ์กฐ๊ฑด์ ๋ง๋ ์กฐ๊ฑด๋ฌธ์ด ์๋ค๋ฉด else์ ๋ช ๋ น๋ฌธ์ด ์ถ๋ ฅ๋๋ค. ๊ฐ์ฅ ๋จผ์ if๋ฌธ์ด ์ค๋ฉฐ, else if ๋ธ๋ก์ ์กฐ๊ฑด ๊ฐ์์ ๋ฐ๋ผ n๋ฒ ์ฌ์ฉํ ์ ์๋ค. ๋จ, if๋ฌธ ์์ด ๋จ๋ ์ผ๋ก ์ฌ์ฉํ ์๋ ์๋ค.
if ([์กฐ๊ฑด1]) {
[์คํ๋ฌธ1]; //์กฐ๊ฑด1์ ๋ง์กฑํ ๋ ์คํํ ๋ช
๋ น๋ฌธ
}
else if ([์กฐ๊ฑด2]) {
[์คํ๋ฌธ2]; //์กฐ๊ฑด2๋ฅผ ๋ง์กฑํ ๋ ์คํํ ๋ช
๋ น๋ฌธ
}
else if ([์กฐ๊ฑด3]) {
[์คํ๋ฌธ3]; //์กฐ๊ฑด3์ ๋ง์กฑํ ๋ ์คํํ ๋ช
๋ น๋ฌธ
}
...
else {
[์คํ๋ฌธn]; //๋ชจ๋ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ ๋ ์คํํ ๋ช
๋ น๋ฌธ
}
ํ์์ ๋ง์ถฐ ํ์ ์ถ๋ ฅ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์. ์กฐ๊ฑด์ "90์ ์ด์(A), 80์ ์ด์(B), 70์ ์ด์(C), ๊ทธ ์ธ(D)" 4๊ฐ์ง์ด๋ค. ๊ตฌ์กฐ๊ฐ ๋ณต์กํ๋ ์๊ธฐ ์ฝ๊ฒ ๋จผ์ ์์๋๋ก ํํํด ๋ณด๊ฒ ๋ค.
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("score์ ์
๋ ฅํ์ธ์:");
int score = scan.nextInt();
if (score >= 90){
System.out.println("Aํ์ ์
๋๋ค.");
}
else if (score<90 && score>=80){
System.out.println("Bํ์ ์
๋๋ค.");
}
else if (score<80 && score>=70){
System.out.println("Cํ์ ์
๋๋ค.");
}
else{
System.out.println("Dํ์ ์
๋๋ค.");
}
}
}
/*
score์ ์
๋ ฅํ์ธ์:88
Bํ์ ์
๋๋ค.
*/
โป์ํ์์๋ '80์ ์ด์ 90์ ๋ฏธ๋ง'์ด๋ผ๋ ์กฐ๊ฑด์ '80 <= score < 90'์ผ๋ก ํ ๋ฒ์ ์ธ ์ ์์ง๋ง ์๋ฐ์์๋ ๊ทธ๋ ์ง ์๋ค.
์๋ฐ์์๋ ์กฐ๊ฑด์ ๋๋ ์ 'score >= 80'๊ณผ 'score < 90'์ผ๋ก ์จ์ผํ๋ฉฐ, ์กฐ๊ฑด์ด 2๊ฐ ์ด์์ผ ๊ฒฝ์ฐ์๋ ์ฌ๋ฌ ์กฐ๊ฑด์ ๋์์ ํ๋จํ๋ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ค. ์ฌ๊ธฐ์์๋ && ๋ ผ๋ฆฌ ์ฐ์ฐ์๊ฐ ์ฌ์ฉ๋์๋ค.
4.2.1. ๋ ผ๋ฆฌ ์ฐ์ฐ์
์๋์ ์ธ ์ฐ์ฐ์๋ฅผ ํฉ์ณ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ผ๊ณ ํ๋ค.
์ฐ์ฐ์ | ์ค๋ช |
&& | ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ๋ชจ๋ ์ฐธ์ด๋ฉด ์ฐธ(TT๋ฅผ ์ฐพ์) |
|| | ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์ค ํ๋๋ผ๋ ์ฐธ์ด๋ฉด ์ฐธ(FF๋ฅผ ์ฐพ์) |
! | ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ๊ฑฐ์ง, ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฉด ์ฐธ |
4.2.2. QUIZ
๋ฌธ์ ์ค๋ช )
ํ์ ์ ์ถ๋ ฅํ๋ ์ฝ๋์์ else if ๋ธ๋ก์ ์กฐ๊ฑด์ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ง ์๋๋ก ๋ฐ๊ฟ ์ ์๋ค. if ๋ฌธ์ ์กฐ๊ฑด์ ์ฐธ๊ณ ํด ๋น์นธ์ ์๋ง์ ๋ด์ฉ์ ์์ฑํ์ธ์.
๋ด๊ฐ ์ง ์ฝ๋) - ์ ๋ต
if๋ฌธ์ ์กฐ๊ฑด(90์ด์)์ ์ถฉ์กฑํ์ง ๋ชปํด else if๋ก ๋ด๋ ค์จ ๊ฑฐ๋(score < 90์์ ์๋ฏธ), ๊ตณ์ด 90๋ณด๋ค ์๋ค๋ ์กฐ๊ฑด์ ์ถ๊ฐ๋ก ์ ์ด์ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉ ํ ํ์๊ฐ ์๋ค.
public class Main {
public static void main(String[] args){
int score = 80;
if (score >= 90){
System.out.println("Aํ์ ์
๋๋ค.");
}
else if (score >= 80){ //(1)
System.out.println("Bํ์ ์
๋๋ค.");
}
else if (score >= 70){ //(2)
System.out.println("Cํ์ ์
๋๋ค.");
}
else{
System.out.println("Dํ์ ์
๋๋ค.");
}
}
}
4.3. ์กฐ๊ฑด๋ฌธ ์์ ์กฐ๊ฑด๋ฌธ์ด ์์ ๋: ์ค์ฒฉ ์กฐ๊ฑด๋ฌธ
4ํ๋ ์๊ฒ ์ ์๊ฐ 90์ ์ด์์ด๋ฉด ์ฅํ๊ธ์ ์ง๊ธํ๋ค๊ณ ํ๋ค. ํ๋ ๊ณผ ์ ์๋ฅผ ์ ๋ ฅ๋ฐฉ์ ์ฅํ๊ธ ์ง๊ธ ๋์์์ธ์ง ํ์ธํ๋ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์.
(1) 4ํ๋ ์ธ์ง ํ๋ณ -> true, false
(2) (1)์ ๊ฒฐ๊ณผ๊ฐ true์ธ ๊ฒ ์ค, ์ ์๊ฐ 90์ ์ด์์ธ์ง ์๋์ง ํ๋ณ
public class Main {
public static void main(String[] args){
System.out.print("ํ๋
์ ์
๋ ฅํ์ธ์:");
Scanner scanGrade = new Scanner(System.in); //scanGrade
int grade = scanGrade.nextInt();
if (grade == 4){
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ธ์:");
Scanner scanScore = new Scanner(System.in); //scanScore
int score = scanScore.nextInt();
if (score >= 90){
System.out.print("์ฅํ๊ธ ์ง๊ธ ๋์์
๋๋ค.");
}
else {
System.out.print("์ฅํ๊ธ ์ง๊ธ ๋์์ด ์๋๋๋ค.");
}
}
else {
System.out.print("์ฅํ๊ธ ์ง๊ธ ํ๋
์ด ์๋๋๋ค.");
}
}
}
์กฐ๊ฑด์ ๋ฒ์๋ฅผ ์ ํ์ ํ๋ฉด ์ค์ฒฉ ์กฐ๊ฑด๋ฌธ์ ์ฝ๊ฒ ์์ฑํ ์ ์๋ค. ๊ทธ๋ฌ๋ ์ค์ฒฉ์ด ๋ฐ๋ณต๋๋ฉด ์ฝ๋๊ฐ ๋ณต์กํด์ง๋ฏ๋ก 3๊ฐ ์ด์์ ์ฌ์ฉํ์ง ์๋๊ฒ์ด ์ข๋ค.
4.3.1. QUIZ โ
์กฐ๊ฑด)
์ซ์๋ฅผ ์ ๋ ฅ๋ฐ์ ์์์ธ์ง ํ์ธํ๋ค. ์์๋ผ๋ฉด ํ์์ธ์ง ์ง์์ธ์ง ํ์ธํ๋ค. ํ์ธ ๊ฒฐ๊ณผ ํ์์ด๋ฉด 'ํ์'๋ผ๊ณ ์ถ๋ ฅํ๊ณ , ์ง์๋ฉด '์ง์'๋ผ๊ณ ์ถ๋ ฅํ๋ค. ์์๊ฐ ์๋๋ผ๋ฉด ์์๋ฅผ ์ ๋ ฅํ๋ผ๊ณ ์ถ๋ ฅํ๋ค.
์ฝ๋ฆ ํ๋ฆ๋ ์์ฑ) - ์ ใท๋ต
(1) ์์์ธ์ง ํ๋จ -> true, false
(2) (1)์ true์์ ํ์์ธ์ง ์ง์์ธ์ง ํ๋จ -> true, false/ ํ์์ ์ง์๋ 2๋ก ๋๋ ๋๋จธ์ง๊ฐ 1์ด๋ 0์ด๋์ ์ฐจ์ด
public class Main {
public static void main(String[] args){
System.out.print("์์๋ฅผ ์
๋ ฅํ์ธ์:");
Scanner scanNum = new Scanner(System.in);
int Num = scanNum.nextInt();
if (Num > 0){
if (Num % 2 == 1){
System.out.print("ํ์์
๋๋ค."); //๋๋จธ์ง๊ฐ 1์ด๋ฉด ํ์
}
else{
System.out.print("์ง์์
๋๋ค."); //
}
}
else{
System.out.print("์์๋ฅผ ์
๋ ฅํ์ธ์.");
}
}
}
4.4. ์กฐ๊ฑด๊ณผ ์ผ์นํ๋ ๊ฐ ์ฐพ๊ธฐ: switch
4.4.1. switch๋ฌธ โ
์กฐ๊ฑด๋ฌธ์๋ if-else ๋ฌธ ์ธ์๋ switch๋ฌธ์ด ์กด์ฌํ๋ค. switch๋ฌธ๋ if-else ๋ฌธ์ฒ๋ผ ์กฐ๊ฑด์ ๋ฐ๋ผ ์คํํ ๋ช ๋ น์ด ๋ฌ๋ผ์ง๋ค. ๊ธฐ๋ณธ ํ์์ ์๋์ ๊ฐ๋ค.
switch ([์กฐ๊ฑด]) {
case ([๊ฐ1]): //;๊ฐ ์๋ :์
[์คํ๋ฌธ1];
break;
...
default: //์๋ต ๊ฐ๋ฅ
[์คํ๋ฌธ];
break;
}
case ๋ฏ๋ก์ ์๋ ๋น๊ตํ ๊ฐ์ ๊ฐ์์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋ฉฐ, ๊ฐ์ ์กฐ๊ฑด๊ณผ ๊ฐ์ ์๋ฃํ์ด์ด์ผ ํ๋ค. ๋ํ case ๋ธ๋ก ๋์๋ break ๋ฌธ์ด ๋ค์ด๊ฐ๋๋ฐ, break๋ ํด๋น case ๋ธ๋ก์ด ์กฐ๊ฑด์ ๋ง์กฑํ ๋ switch ๋ฌธ์ ํ์ถํ๊ฒ ํ๋ ์ญํ ์ ํ๋ค.
switch๋ฌธ์ ์คํํ๋ฉด '์กฐ๊ฑด'๊ณผ 'case ๋ธ๋ก์ ๊ฐ'์ ์์๋๋ก ๋น๊ตํ๋ค. ๊ทธ๋ฌ๋ค ๊ฐ์ด ์ผ์นํ๋ case ๋ธ๋ก์ ๋ง๋๋ฉด ํด๋น case ๋ธ๋ก์ ์ํ ๋ช ๋ น๋ฌธ์ ์คํํ๋ค. ๋ง์ฝ ๊ฐ์ด ์ผ์นํ๋ case ๋ธ๋ก์ด ์๋ค๋ฉด default ๋ธ๋ก์ผ๋ก ๊ฐ์ ๋ช ๋ น๋ฌธ์ ์คํํ๋ค. default ๋ธ๋ก์ ์๋ต ๊ฐ๋ฅํ๋ค. default๋ ์กฐ๊ฑด๊ณผ ์ผ์นํ๋ case ๋ธ๋ก์ด ์์ ๋ ์คํ๋๋ฏ๋ก switch๋ฌธ ์ด๋๋ ์์ฑํด๋ ๋์ง๋ง, ์ผ๋ฐ์ ์ผ๋ก ์ฝ๋ ํ๋ฆ์ ํ์ ํ๊ธฐ ์ฝ๋๋ก ์ฝ๋์ ๋ง์ง๋ง์ ์์ฑํ๋ ํธ์ด๋ค.
ํ์ ์ ์ถ๋ ฅํ๋ ์์ ์ ํจ๊ป ์ดํดํด๋ณด์.
public class Main {
public static void main(String[] args){
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ธ์:");
Scanner scanScore = new Scanner(System.in);
int score = scanScore.nextInt();
switch (score){
case(90):
System.out.print("Aํ์ ์
๋๋ค.");
break;
case(80):
System.out.print("Bํ์ ์
๋๋ค.");
break;
case(70):
System.out.print("Cํ์ ์
๋๋ค.");
break;
default:
System.out.print("90, 80, 70 ์ค ํ๋๋ฅผ ์
๋ ฅํ์ธ์.");
}
}
}
/*์ ์๋ฅผ ์
๋ ฅํ์ธ์:77
90, 80, 70 ์ค ํ๋๋ฅผ ์
๋ ฅํ์ธ์.*/
// switch (score) {...}
์กฐ๊ฑด์ด score์ด๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ์ ๊ฐ๊ฐ 90, 80, 70์ด ์ ํ์๋ค.
-> score์ด 90, 80, 70์ผ ๋, ๊ฐ๊ฐ์ case ๋ธ๋ก์ ์ ํ์๋ ๋ช ๋ น๋ฌธ์ด ์ถ๋ ฅ๋๋ ๊ตฌ์กฐ์ด๋ค.
4.4.2. if๋ฌธ๊ณผ switch๋ฌธ โ
switch๋ฌธ์ผ๋ก ์ฝ๋๋ฅผ ์์ฑํ๋ฉด, if๋ฌธ์ ์ฌ์ฉํ ๊ฒฝ์ฐ๋ณด๋ค ์กฐ๊ฑด์ด ๋ช ํํ๊ณ ๋จ์ํด์ง๋ค.
- if๋ฌธ: ๋ฒ์์ ํด๋นํ๋ ๊ฐ์ ๋น๊ตํ ๋ ์ฌ์ฉ
- switch๋ฌธ: ์ ํํ๊ฒ ์ ํด์ง ๊ฐ์ ๋น๊ตํ ๋ ์ฌ์ฉ
4.4.3. switch ๋ฌธ์์ ์ฃผ์ํ ์ - break ์๋ต
๊ฐ case ๋ธ๋ก ๋์ ์๋ break๋ ์๋ต ๊ฐ๋ฅํ๋ค. ๋จ, ์ด ๊ฒฝ์ฐ(break์ ์๋ตํ๋ฉด) ์กฐ๊ฑด๋ฌธ์ ํ์ถํ์ง ์๊ณ ๋ค์ case ๋ธ๋ก์ผ๋ก ๋์ด๊ฐ๋ค. ์ฆ, case ๋ธ๋ก์ break๋ฅผ ๋ฃ์ง ์์ผ๋ฉด switch ๋ฌธ์ ์ข ๋ฃํ์ง ์๊ณ ๋ค์ case๋ธ๋ก๋ ๊ณ์ ์คํํ๋ฏ๋ก ์ด ์ ์ ์ฃผ์ํด์ผํ๋ค.
public class Main {
public static void main(String[] args){
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ธ์:");
Scanner scanScore = new Scanner(System.in);
int score = scanScore.nextInt();
switch (score){
case(90):
System.out.print("Aํ์ ์
๋๋ค.");
// break; ์ฃผ์์ฒ๋ฆฌํ๋ฉด??
case(80):
System.out.print("Bํ์ ์
๋๋ค.");
break;
case(70):
System.out.print("Cํ์ ์
๋๋ค.");
break;
default:
System.out.print("90, 80, 70 ์ค ํ๋๋ฅผ ์
๋ ฅํ์ธ์.");
}
}
}
/*์ ์๋ฅผ ์
๋ ฅํ์ธ์:90
Aํ์ ์
๋๋ค.Bํ์ ์
๋๋ค.*/
4.4.4. QUIZ
๋ค์ ์ฝ๋์ ์คํ ๊ฒฐ๊ณผ๋?
public class Main {
public static void main(String[] args){
int input = 1;
switch(input){
case (1):
System.out.print("1");
case (2):
System.out.print("2");
case (3):
System.out.print("3");
}
}
}
๋ต) 123
-> ๊ฐ case๋ฌธ์ break๊ฐ ์๊ธฐ ๋๋ฌธ์ ํด๋น ๋ค์ case๋ฌธ์ผ๋ก ๊ณ์ ๋์ด๊ฐ๊ธฐ ๋๋ฌธ์ด๋ค.
4.5. ์ผํญ ์ฐ์ฐ์
4.5.1. ์ผํญ ์ฐ์ฐ์ โ
if๋ฌธ, switch๋ฌธ์ ์กฐ๊ฑด์ ์์ฑํ๋ค ๋ณด๋ฉด ์ฝ๋๊ฐ ์๋นํ ๊ธธ์ด์ง๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ์ด ๋ ์ผํญ ์ฐ์ฐ์(conditional operator)์ ์ฌ์ฉํ๋ฉด ํธํ๋ค. ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด ์กฐ๊ฑด์ ํ ์ค๋ก ์์ฑํ ์ ์์ด, ์กฐ๊ฑด๋ฌธ์ ์ฝ๋ ์ค ์๋ฅผ ์ค์ผ๋ ์ฌ์ฉ๋๋ค.
๊ธฐ๋ณธ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
([์กฐ๊ฑด])? A:B
๊ตฌ๋ถ | ์๋ฏธ |
์กฐ๊ฑด | true ๋๋ false ๊ฐ์ ๋ฐํํ๋ ์กฐ๊ฑด์ด ๋ค์ด๊ฐ๋ค |
A | ์กฐ๊ฑด์ ๊ฒฐ๊ณผ๊ฐ true์ผ ๋ ์ ํ๋๋ ๊ฒ |
B | ์กฐ๊ฑด์ ๊ฒฐ๊ณผ๊ฐ false์ผ ๋ ์ ํ๋๋ ๊ฒ |
-> ์กฐ๊ฑด์ ๊ฒฐ๊ณผ๋ true ๋๋ false์ด๊ธฐ ๋๋ฌธ์, 2๊ฐ ์ด์์ ์กฐ๊ฑด์ ํ๋ณํด์ผ ํ๋ ์ํฉ์์๋ ์ผํญ ์ฐ์ฐ์ ์ฌ์ฉ์ ์ ํฉํ์ง ์๋ค.
์์์ ํจ๊ป ์ดํดํด๋ณด์.
public class Main {
public static void main(String[] args){
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ธ์:");
Scanner scanScore = new Scanner(System.in);
int score = scanScore.nextInt();
String grade = (score >= 90)?"Aํ์ ์
๋๋ค":"Bํ์ ์
๋๋ค";
System.out.println(grade);
System.out.println(grade + "-> ๋ผ๊ณ ํ๋ค์");
}
}
/*์ ์๋ฅผ ์
๋ ฅํ์ธ์:98
Aํ์ ์
๋๋ค
Aํ์ ์
๋๋ค-> ๋ผ๊ณ ํ๋ค์*/
// String grade = (score >= 90)?"Aํ์ ์ ๋๋ค":"Bํ์ ์ ๋๋ค";
์ฌ์ฉ์๋ก๋ถํฐ score์ ์ ๋ ฅ ๋ฐ๊ณ , ๋ง์ฝ score๊ฐ์ด 90 ์ด์์ด๋ฉด ์กฐ๊ฑด์ ๊ฒฐ๊ณผ๊ฐ true์ผ ๋ ์ถ๋ ฅ๋๋ "Aํ์ ์ ๋๋ค"๊ฐ ์ถ๋ ฅ๋๋ค. ๋ง์ฝ score๊ฐ์ด 90 ์ดํ์ด๋ฉด ์กฐ๊ฑด์ ๊ฒฐ๊ณผ๊ฐ false์ผ ๋ ์ถ๋ ฅ๋๋ "Bํ์ ์ ๋๋ค"๊ฐ ์ถ๋ ฅ๋๋ค.
โปํท๊ฐ๋ฆฐ์
: score >= 90์ case(90)์ผ๋ก ์ดํดํด์, ๋ง์ฝ 98์ score์ ์ ๋ ฅํ๋ฉด ์๋ฌด ๋ช ๋ น์ด๋ ์ถ๋ ฅ๋์ง ์์ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค.
-> score >= 90์ ๊ฒฐ๊ณผ๋ ๋ฌด์กฐ๊ฑด true ๋๋ false์ด๋ค! ์ ํท๊ฐ๋ ธ๋์ง๋ ์ ๋ชจ๋ฅด๊ฒ ์ง๋ง ์์ผ๋ก ์ฃผ์ํ์.
4.5.2. QUIZ
๋ฌธ์ )
๋ค์ ์ฝ๋๋ ์ ๋ ฅ๋ฐ์ ์ ์๊ฐ ์ง์๋ฉด '์ง์'๋ผ๊ณ ์ถ๋ ฅํ๊ณ ํ์๋ฉด 'ํ์'๋ผ๊ณ ์ถ๋ ฅํ๋ค. ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ๋๋ฅผ ๋ง๋ค์ด๋ผ
๋ด๊ฐ ์ง ์ฝ๋) - ์ ๋ต
String string_num์ ํตํด, ์ผํญ์ฐ์ฐ ๊ฒฐ๊ณผ(true, fasle)๋ฅผ string_Num์ด๋ผ๋ String ์๋ฃํ ๋ณ์์ ์ ์ฅํ๋ค. ์ดํ System.out.print(string_Num)์ ํตํด string_Num(ํ์ ๋๋ ์ง์)์ ์ถ๋ ฅํ๋๋ก ํ๋ค.
public class Main {
public static void main(String[] args){
System.out.print("์ ์๋ฅผ ์
๋ ฅํ์ธ์:");
Scanner scanNum = new Scanner(System.in);
int Num = scanNum.nextInt();
String string_Num = (Num % 2 == 1)?"ํ์":"์ง์";
System.out.print(string_Num);
}
}
/*์ ์๋ฅผ ์
๋ ฅํ์ธ์:216
์ง์*/
๋ง๋ฌด๋ฆฌ
1. if๋ฌธ
(1) ๋ ์ด์์ ์กฐ๊ฑด์ ํ๋จํ๊ฑฐ๋, ์กฐ๊ฑด์ ์ฐธ๊ณผ ๊ฑฐ์ง์ ๋ถ์ ํ ๋๋ ๋ค์๊ณผ ๊ฐ์ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ค.
- && (๋ ผ๋ฆฌ ๊ณฑ): ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ๋ชจ๋ ์ฐธ์ด๋ฉด ์ฐธ
- || (๋ ผ๋ฆฌ ํฉ): ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์ค ํ๋๋ผ๋ ์ฐธ์ด๋ฉด ์ฐธ
- ! (๋ ผ๋ฆฌ ๋ถ์ ์ฐ์ฐ์): ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ๊ฑฐ์ง, ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฉด ์ฐธ -> reverse
2. ์ค์ฒฉ ์กฐ๊ฑด๋ฌธ
(1) ์กฐ๊ฑด๋ฌธ ์์ ์กฐ๊ฑด๋ฌธ์ด ์์ ๋ ์ด๋ฅผ ์ค์ฒฉ ์กฐ๊ฑด๋ฌธ์ด๋ผ๊ณ ํ๋ค
(2) ๋ด๋ถ ์กฐ๊ฑด๋ฌธ์ ์ธ๋ถ ์กฐ๊ฑด๋ฌธ์ด ์ฐธ(ture)์ผ ๋๋ง ์คํ๋๋ค
3. switch๋ฌธ
(1) ์ ํํ ์ ํด์ง ๊ฐ์ ๋น๊ตํ ๋ ์ฌ์ฉ
(2) ๊ฐ์ด ์ผ์นํ๋ case๋ฌธ์ ๋ง๋๋ฉด, ํด๋น case๋ฌธ์ ์คํ๋ฌธ์ ์คํํ ๋ค break๋ฌธ์ ๋ง๋๋ฉฐ switch๋ฌธ์ ํ์ถํ๋ค. ๋ง์ฝ ์กฐ๊ฑด๊ณผ ์ผ์นํ๋ case ๋ธ๋ก์ด ์๋ค๋ฉด default ๋ธ๋ก์ผ๋ก ์ด๋ํด default ๋ธ๋ก์ ์คํ๋ฌธ์ ์คํํ๊ณ switch๋ฌธ์ ํ์ถํ๋ค
(3) case ๋ธ๋ก ๋์ break๊ฐ ์จ๋ค. ์ด๋ break๋ ์๋ต ๊ฐ๋ฅํ์ง๋ง.... ์๋ตํ ์ผ์ด ์์๊น ์ถ๋ค
4. ์ผํญ ์ฐ์ฐ์
(1) ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ฉด if-else ๋ฌธ์ ์กฐ๊ฑด ๋ถ๋ถ์ ํ ์ค๋ก ์์ฑํ ์ ์๋ค. ์ฆ, ์กฐ๊ฑด๋ฌธ์ ์ฝ๋ ์ค ์๋ฅผ ์ค์ด๋ ์ญํ ์ ํ๋ค.
(2) (์กฐ๊ฑด)?"A":"B"์ ํ์์ด๋ฉฐ, String grade = (score >= 90) ? "Aํ์ ์ ๋๋ค" : "Bํ์ ์ ๋๋ค";๋ฅผ ์์ ๋ก ๋ค ์ ์๋ค.
๋ง๋ฌด๋ฆฌ Test
์กฐ๊ฑด)
1. ์ํ๋ฒณ ์๋ฌธ์๋ฅผ ์ ๋ ฅ๋ฐ์ ๋๋ฌธ์๋ก ๋ณํํด ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ switch๋ฌธ์ผ๋ก ์์ฑํด๋ผ
2. a, b, c ์ธ ๋ค๋ฅธ ๋ฌธ์๋ฅผ ์ ๋ ฅ๋ฐ์ผ๋ฉด ์ผ์นํ๋ ์ํ๋ฒก์ ์๋ค๊ณ ์ถ๋ ฅํ๊ณ switch๋ฌธ์ ์ข ๋ฃํ๋ค. ๊ทธ ๋ฐ์ ์์ธ ์ฌํญ์ ๊ณ ๋ คํ์ง ์๋๋ค
๋ด๊ฐ ์ง ์ฝ๋) - ๊ฐ๋ฒฝํจ
public class Main {
public static void main(String[] args){
System.out.print("์ํ๋ฒณ์ ์
๋ ฅํ์ธ์(a,b,c์ค ํ๋):");
Scanner scan = new Scanner(System.in);
String str = scan.nextLine();
switch(str){
case("a"):
System.out.print("A");
break;
case("b"):
System.out.print("B");
break;
case("c"):
System.out.print("C");
break;
default:
System.out.print("์ผ์นํ๋ ์ํ๋ฒณ์ด ์์ต๋๋ค.");
}
scan.close(); //์์ฑํ๋ฉด ์ปดํจํฐ ํ๊ฒฝ์ ์ข์
}
}
/*์ํ๋ฒณ์ ์
๋ ฅํ์ธ์(a,b,c์ค ํ๋):f
์ผ์นํ๋ ์ํ๋ฒณ์ด ์์ต๋๋ค.*/
'๐ฆ Private > Java Language' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
6์ฅ - ์ฌ๋ฌ ๊ฐ ํ ๋ฒ์ ์ ์ฅํ๊ธฐ: ๋ฐฐ์ด (0) | 2025.03.05 |
---|---|
5์ฅ - ๊ฐ์ ์์ ๋ฐ๋ณตํ๊ธฐ: ๋ฐ๋ณต๋ฌธ (1) | 2025.02.19 |
3์ฅ - ๊ธฐ์ด ๋ฌธ๋ฒ ๋ฐฐ์ฐ๊ธฐ (0) | 2025.02.13 |
2์ฅ - ์ ์ถ๋ ฅ ๋ค๋ฃจ๊ธฐ (1) | 2025.02.11 |
1์ฅ - Hello, Java! (1) | 2025.02.11 |