๐ ์ฐ์ฐ์์ ์ฐ์ฐ์
- ์ฐ์ฐ(operations) : ํ๋ก๊ทธ๋จ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์ถํ๋ ๊ฒ
- ์ฐ์ฐ์(operator) : ์ฐ์ฐ์ ์ฌ์ฉ๋๋ ํ์๋ ๊ธฐํธ
- ํผ์ฐ์ฐ์(operand) : ์ฐ์ฐ๋๋ ๋ฐ์ดํฐ
- ์ฐ์ฐ์(expressions) : ์ฐ์ฐ์์ ํผ์ฐ์ฐ์๋ฅผ ์ด์ฉํด ์ฐ์ฐ์ ๊ณผ์ ์ ๊ธฐ์ ํ ๊ฒ. ์ฐ์ฐ์์ ๋ฐ๋์ ํ๋์ ๊ฐ์ ์ฐ์ถํ๋ค.
์๋ฐ์์ ์ ๊ณตํ๋ ๋ค์ํ ์ฐ์ฐ์๋ค
์ฐ์ฐ์์ ์ฐ์ฐ ๋ฐฉํฅ๊ณผ ์ฐ์ ์์
๐ ์ฆ๊ฐ ์ฐ์ฐ์
- ์ฆ๊ฐ ์ฐ์ฐ์๋ ๋ณ์์ ๊ฐ์ 1 ์ฆ๊ฐ (++) ์ํค๊ฑฐ๋ 1 ๊ฐ์ (—) ์ํค๋ ์ฐ์ฐ์๋ฅผ ๋งํ๋ค. boolean ํ์ ์ ์ ์ธํ ๋ชจ๋ ๊ธฐ๋ณธ ํ์ ์ ํผ์ฐ์ฐ์์ ์ฌ์ฉํ ์ ์๋ค.
int a = 1;
int b = 1;
int result1 = ++a + 10; // 10 ์ ๋ํ๊ธฐ ์ a์ ๊ฐ์ 2๋ก ๋ณ๊ฒฝ
int result2 = b++ + 10; // 10์ ๋ํ๊ณ ๋์ b์ ๊ฐ์ 2๋ก ๋ณ๊ฒฝ
System.out.println(result1); // 12
System.out.println(result2); // 11
๐ ๋ ผ๋ฆฌ ์ฐ์ฐ์
- ๋ ผ๋ฆฌ์ฐ์ฐ์๋ ๋ ผ๋ฆฌ๊ณฑ(&&) , ๋ ผ๋ฆฌํฉ(||), ๋ฐฐํ์ ๋ ผ๋ฆฌํฉ(^), ๋ ผ๋ฆฌ๋ถ์ (!)
- ๋ ผ๋ฆฌ์ฐ์ฐ์์ ํผ์ฐ์ฐ์๋ boolean ํ์ ๋ง ์ฌ์ฉํ ์ ์๋ค.
๐ ๋นํธ ์ฐ์ฐ์
- ๋นํธ ์ฐ์ฐ์๋ ๋ฐ์ดํฐ๋ฅผ ๋นํธ ๋จ์๋ก ์ฐ์ฐํ๋ค. ์ฆ 0๊ณผ 1์ด ํผ์ฐ์ฐ์๊ฐ ๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ 0๊ณผ 1๋ก ํํ์ด ๊ฐ๋ฅํ ์ ์ ํ์ ๋ง ๋นํธ์ฐ์ฐ์ ํ ์ ์๋ค. (์ค์ ํ์ ์ธ float์ double ์ ๋นํธ ์ฐ์ฐ์ ํ ์ ์๋ค)
- ๋นํธ ์ฐ์ฐ์๋ ๊ธฐ๋ฅ์ ๋ฐ๋ผ ๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ์(&,|,^,~) ์ ๋นํธ ์ด๋ ์ฐ์ฐ์ (>>, <<, >>>) ๋ก ๊ตฌ๋ถํ๋ค.
- ์ผ๋ฐ ๋ ผ๋ฆฌ ์ฐ์ฐ์๊ฐ true ์ false๋ก ์ฐ์ฐํ๋ค๋ฉด, ๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ 0๊ณผ 1์ ์ฐ์ฐํ๋ค.
- ๋นํธ ์ด๋ ์ฐ์ฐ์๋ ๋นํธ๋ฅผ ์ข์ธก ๋๋ ์ฐ์ธก์ผ๋ก ์ด๋์ํค๋ ์ฐ์ฐ์์ด๋ค.
๋นํธ ๋ ผ๋ฆฌ ์ฐ์ฐ์
๋นํธ ์ด๋ ์ฐ์ฐ์
๐ ์ผํญ ์ฐ์ฐ์
- ์ผํญ ์ฐ์ฐ์(?:)๋ ์ธ ๊ฐ์ ํผ์ฐ์ฐ์๊ฐ ํ์๋ก ํ๋ ์ฐ์ฐ์๋ฅผ ๋งํ๋ค. ์ผํญ ์ฐ์ฐ์๋ ? ์์ ์กฐ๊ฑด์์ ๋ฐ๋ผ ์ฝ๋ก (:) ์๋ค์ ํผ์ฐ์ฐ์๊ฐ ์ ํ๋๋ค๊ณ ํด์ ์กฐ๊ฑด ์ฐ์ฐ์์ด๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ ํ๋ค.
์กฐ๊ฑด์ ? ๊ฐ1 ๋๋ ์ฐ์ฐ์1 : ๊ฐ2 ๋๋ ์ฐ์ฐ์2(์กฐ๊ฑด์์ด true๋ฉด ๊ฐ1 ๋๋ ์ฐ์ฐ์1 , false๋ฉด ๊ฐ 2 ๋๋ ์ฐ์ฐ์2 )
- ์ผํญ ์ฐ์ฐ์๋ if ๋ฌธ์ผ๋ก ๋ณ๊ฒฝํด์๋ ์์ฑํ ์ ์์ง๋ง, ํ ์ค์ ๊ฐ๋จํ๊ฒ ์ฝ์ ํด์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ์ผํญ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ํจ์จ์ ์ด๋ค.
์ฐ์ฐ์ | ์ค๋ช |
++ ํผ์ฐ์ฐ์ | ๋ค๋ฅธ ์ฐ์ฐ์ ์ํํ๊ธฐ ์ ์ ํผ์ฐ์ฐ์์ ๊ฐ์ 1 ์ฆ๊ฐ์ํด |
- - ํผ์ฐ์ฐ์ | ๋ค๋ฅธ ์ฐ์ฐ์ ์ํํ๊ธฐ ์ ์ ํผ์ฐ์ฐ์์ ๊ฐ์ 1 ๊ฐ์์ํด |
ํผ์ฐ์ฐ์ ++ | ๋ค๋ฅธ ์ฐ์ฐ์ ์ํํ ํ์ ํผ์ฐ์ฐ์์ ๊ฐ์ 1 ์ฆ๊ฐ์ํด |
ํผ์ฐ์ฐ์ - - | ๋ค๋ฅธ ์ฐ์ฐ์ ์ํํ ํ์ ํผ์ฐ์ฐ์์ ๊ฐ์ 1 ๊ฐ์์ํด |
๐ ์ ์ด๋ฌธ
์ ์ด๋ฌธ : ์๋ฐ ํ๋ก๊ทธ๋จ์ ์คํ ํ๋ฆ์ ๊ฐ๋ฐ์๊ฐ ์ํ๋ ๋ฐฉํฅ์ผ๋ก ๋ฐ๊ฟ ์ ์๋๋ก ํด์ค
์ ์ด๋ฌธ์ 1) ์กฐ๊ฑด์ 2) ์ค๊ดํธ({}) ๋ธ๋ก์ผ๋ก ๊ตฌ์ฑ
- ์กฐ๊ฑด์์ ์ฐ์ฐ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ๋ธ๋ก ๋ด๋ถ์ ์คํ์ฌ๋ถ๊ฐ ๊ฒฐ์ ๋๋ค.
- ์ ์ด๋ฌธ์๋ ์กฐ๊ฑด๋ฌธ(if๋ฌธ / switch๋ฌธ)๊ณผ ๋ฐ๋ณต๋ฌธ(for๋ฌธ / while๋ฌธ / do-while๋ฌธ)์ด ์๋ค.
- ์กฐ๊ฑด๋ฌธ์ ๊ฒฝ์ฐ, ์ ์ด๋ฌธ ๋ธ๋ก์ ๋น ์ ธ๋์ ์ ์ ํ๋ฆ(์์์ ์๋)์ผ๋ก ๋์์จ๋ค.
- ๋ฐ๋ณต๋ฌธ์ ๊ฒฝ์ฐ, ์ ์ด๋ฌธ ๋ธ๋ก์ ๋น ์ ธ๋์ ์ฒ์์ผ๋ก ๋ค์ ๋๋์๊ฐ ๋ฐ๋ณต ์คํํ๋ค. (loop)
- ์ ์ด๋ฌธ์์ ๋๋ค๋ฅธ ์ ์ด๋ฌธ์ ๋ฃ์ ์ ์์ด์ ๊ฐ๋ฐ์๊ฐ ์ํ๋ ๋ณต์กํ ํ๋ฆ์ ์ด๋ ๊ฐ๋ฅ
๐ ์กฐ๊ฑด๋ฌธ
๐ if๋ฌธ
if (์กฐ๊ฑด์) {
์คํ๋ฌธ;
์คํ๋ฌธ;
}
if ๋ฌธ์ ์ค๊ดํธ ๋ธ๋ก์ ์ฌ๋ฌ๊ฐ์ ์คํ๋ฌธ์ ํ๋๋ก ๋ฌถ๊ธฐ ์ํด ์์ฑ๋๋ค, if ๋ค์ ๋์ค๋ ์กฐ๊ฑด์์ด ์ฐธ(true)์ด๋ฉด ์ค๊ดํธ ๋ธ๋ก ์์ ์คํ๋ฌธ์ ์คํํ๋ค.
int score = 95;
if (score > 90){ // ์กฐ๊ฑด์ (score > 90)์ด ์ฐธ์ด๋ฉด ์ค๊ดํธ ๋ธ๋ก ์คํ
System.out.println("์ ์๊ฐ 90๋ณด๋ค ํฌ๋ค");
System.out.println("A ์
๋๋ค");
}
๐ if-else๋ฌธ
- if๋ฌธ์ ์กฐ๊ฑด์์ด true๋ฉด if๋ฌธ์ ๋ธ๋ก์ด ์คํ๋๊ณ , ์กฐ๊ฑด์์ด false๋ฉด else ๋ธ๋ก์ด ์คํ๋๋ค. ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ์ด ๋ ๊ฐ์ ๋ธ๋ก ์ค ์ด๋ ํ ๋ธ๋ก์ ๋ด์ฉ๋ง ์คํํ๊ณ ์ ์ฒด if๋ฌธ์ ๋ฒ์ด๋๊ฒ ๋๋ค.
int score = 95;
if (score > 90){ // ์กฐ๊ฑด์ (score > 90)์ด ์ฐธ์ด๋ฉด if ๋ธ๋ก ์คํ
System.out.println("์ ์๊ฐ 90๋ณด๋ค ํฌ๋ค");
System.out.println("A ์
๋๋ค");
}
else { // if์ ์กฐ๊ฑด์(score > 90)์ด ๊ฑฐ์ง์ด๋ฉด else ๋ธ๋ก ์คํ
System.out.println("์ ์๊ฐ 90๋ณด๋ค ์์ต๋๋ค");
System.out.println("B ์
๋๋ค");
}
๐ if - else if - else๋ฌธ
- ์กฐ๊ฑด๋ฌธ์ด ์ฌ๋ฌ๊ฐ์ธ if๋ฌธ๋ ๊ฐ๋ฅํ๋ค. ์ฒ์ if๋ฌธ์ ์กฐ๊ฑด์์ด false์ผ ๊ฒฝ์ฐ, ๋ค๋ฅธ ์กฐ๊ฑด์์ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ์คํ ๋ธ๋ก์ ์ ํํ ์๋ ์๋๋ฐ if๋ฌธ ๋์ else if๋ฌธ์ ๋ถ์ด๋ฉด ๋๋ค.
- else if๋ฌธ์ ์์ ์ ํ์ด ์๋ค.
- else if๋ฌธ ๋ค์๋ else ๋ธ๋ก์ ์ถ๊ฐํ ์ ์๋๋ฐ ์์ ์๋ ๋ชจ๋ ์กฐ๊ฑด์์ด ๊ฑฐ์ง(false)์ธ ๊ฒฝ์ฐ์ else์ ๋ธ๋ก์ ์คํํ๋ค.
int score = 95;
if (score > 90){ // ์กฐ๊ฑด์ (score > 90)์ด ์ฐธ์ด๋ฉด if ๋ธ๋ก ์คํ
System.out.println("์ ์๊ฐ 90๋ณด๋ค ํฌ๋ค");
System.out.println("A ์
๋๋ค");
}
else if(score>= 80) { // ์ if๋ฌธ ์กฐ๊ฑด์๋ ๋ถํฉํ์ง ์์ง๋ง else if๋ฌธ์๋ ๋ถํฉํ๋ ๊ฒฝ์ฐ
System.out.println("์ ์๊ฐ 80~89์
๋๋ค");
System.out.println("B ์
๋๋ค");
}
else if(score>= 70) {
System.out.println("์ ์๊ฐ 70~79์
๋๋ค");
System.out.println("C ์
๋๋ค");
}
else { // ์ ์กฐ๊ฑด ์ค ํ๋๋ ํด๋นํ์ง ์๋๋ค๋ฉด, score ๊ฐ 70 ์ดํ๋ผ๋ฉด
System.out.println("์ ์๊ฐ 70๋ณด๋ค ์์ต๋๋ค");
System.out.println("D ์
๋๋ค");
}
๐ ์ค์ฒฉ if๋ฌธ
- if๋ฌธ ์์ ๋๋ค๋ฅธ if๋ฌธ์ ์ฌ์ฉํ ์ ์๋ค. ์ด๊ฒ์ ์ค์ฒฉ if๋ฌธ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์ค์ฒฉ์ ๋จ๊ณ๋ ์ ํ์ด ์๊ณ if๋ฌธ ๋ฟ๋ง ์๋๋ผ ์ ์ด๋ฌธ์ ๊ฒฝ์ฐ ๋ค ์ค์ฒฉํ ์ ์๋ค.
int score = 95;
if (score > 90){
if (score >= 95){
System.out.println("์ ์๊ฐ 95์ด๊ฑฐ๋ ๊ทธ๋ณด๋ค ํฌ๋ค");
System.out.println("A+ ์
๋๋ค");
}else{
System.out.println("์ ์๊ฐ 90๋ณด๋ค ํฌ๋ค");
System.out.println("A ์
๋๋ค"); }
}
๐ switch๋ฌธ
- switch๋ฌธ๋ if๋ฌธ๊ณผ ๊ฐ์ ์กฐ๊ฑด์ ์ด๋ฌธ์ ํด๋นํ๋ค.
- switch๋ฌธ์ ๋ณ์๊ฐ ์ด๋ค ๊ฐ์ ๊ฐ๋๋์ ๋ฐ๋ผ ์คํ๋ฌธ์ด ์ ํ๋๋ค. (if๋ฌธ๊ณผ์ ์ฐจ์ด์ )
- switch๋ฌธ์ ๊ดํธ ์์ ๊ฐ๊ณผ ๋์ผํ ๊ฐ์ ๊ฐ๋ case๋ก ๊ฐ์ ์คํ๋ฌธ์ ์คํ์ํจ๋ค. ๊ดํธ ์์ ๊ฐ๊ณผ ๋์ผํ ๊ฐ์ ๊ฐ๋ case๊ฐ ์์ผ๋ฉด default๋ก ๊ฐ์ ์คํ๋ฌธ์ ์ํจ๋ค. (default๋ ์๋ต๊ฐ๋ฅ)
- case์๋ ์ซ์๋ ๊ฐ๋ฅํ๊ณ ๋ฌธ์, ๋ฌธ์์ด๋ ๊ฐ๋ฅํ๋ค .
int num = (int)(Math.random()*6)+1;
switch(num){
case 1 : // num์ ๊ฐ์ด 1์ธ ๊ฒฝ์ฐ,
System.out.println("1์ด ๋์์ต๋๋ค");
break;
case 2 :
System.out.println("2๊ฐ ๋์์ต๋๋ค");
break;
case 3 :
System.out.println("3์ด ๋์์ต๋๋ค");
break;
case 4 :
System.out.println("4๊ฐ ๋์์ต๋๋ค");
break;
case 5 :
System.out.println("5๊ฐ ๋์์ต๋๋ค");
break;
default: //default๋ฅผ ์์ฐ๋ฉด ์๋ฌด๊ฒ๋ ์ถ๋ ฅ์๋จ
System.out.println("6์ด ๋์์ต๋๋ค");
break;
}
๐ ๋ฐ๋ณต๋ฌธ
๋ฐ๋ณต๋ฌธ์ ์ด๋ค ์์ (์ฝ๋)๋ค์ ๋ฐ๋ณต์ ์ผ๋ก ์คํํด์ผํ ๋ ์ฌ์ฉํ๋ค.
๐ for๋ฌธ
- for๋ฌธ์ ์ ํด์ง ํ์๋งํผ ๋ฐ๋ณตํด์ผํ ๋ ์ฌ์ฉํ๋ค.
int sum = 0 ;
for (int i = 1; i <= 100; i++){ // i๊ฐ 1๋ถํฐ 100์ผ๋๊น์ง ์ค๊ดํธ ๋ธ๋ก์ ์คํ๋ฌธ์ ๋ฐ๋ณตํ๋ค.
sum += i ;
}
System.out.println(sum);
for๋ฌธ์ ๊ตฌ์กฐ๋ฅผ ์ดํด๋ณด๋ฉด for (์ด๊ธฐํ์ ; ์กฐ๊ฑด์ ; ์ฆ๊ฐ์) { ์คํ๋ฌธ } ์ผ๋ก ๊ตฌ์ฑ๋์ด ์๋ค.
- ์ด๊ธฐํ์์์ ์ ์ธ๋ ๋ณ์๋ for๋ฌธ ๋ธ๋ก ๋ด์์ ์ฌ์ฉ๋๋ ๋ก์ปฌ ๋ณ์์ด๋ค. ๋ฐ๋ผ์ for๋ฌธ ๋ฐ๊นฅ์์ ์ฌ์ฉํ ์ ์๋ค.
- ์กฐ๊ฑด์์ด true๋ฉด ์คํ๋ฌธ์ ์คํ์ํค๊ณ false๋ฉด for๋ฌธ ๋ธ๋ก์ ์คํ์ํค์ง ์๊ณ ๋๋๋ค.
- ๋ง์ฝ ์ด๊ธฐํ์์ด ํ์์๋ ๊ฒฝ์ฐ ์๋ตํ ์ ์๋ค. ex) for ( ; i≤100 ; i++)
- for๋ฌธ ์์ฑ์ , ์ด๊ธฐํ ์์์ ๋ฃจํ ์นด์ดํธ ๋ณ์๋ฅผ ์ ์ธํ ๋ ๋ถ๋์์์ ํ์ ์ ์ฌ์ฉํ์ง ๋ง์์ผํ๋ค. → ๋ฃจํ ์คํ ์ ์ง์ ๋ ํ์๋งํผ ์คํ ์๋ ์ ์์.
๐ while๋ฌธ
- for๋ฌธ์ด ์ ํด์ง ํ์๋งํผ ๋ฐ๋ณตํ๋ค๋ฉด while๋ฌธ์ ์กฐ๊ฑด์์ด true์ธ ๊ฒฝ์ฐ ๊ณ์ํด์ ๋ฐ๋ณตํ๋ค.
- ์กฐ๊ฑด์์๋ ๋น๊ต or ๋ ผ๋ฆฌ์ฐ์ฐ์์ด ์ฃผ๋ก ์ค๋๋ฐ, ์กฐ๊ฑด์์ด false๊ฐ ๋๋ฉด ๋ฐ๋ณตํ์๋ฅผ ๋ฉ์ถ๊ณ while๋ฌธ์ ์ข ๋ฃํ๋ค.
int i = 1; //์นด์ดํฐ ๋ณ์ i
while (i<=10) { //i๊ฐ 10๊ณผ ๊ฐ๊ฑฐ๋ ์์ ๋๊น์ง
System.out.println(i);
i++ ; // i+=1
}
- ์กฐ๊ฑด์์๋ boolean ๋ณ์๋ true/false ๊ฐ์ ์ฐ์ถํ๋ ์ฐ์ฐ์์ด ์ฌ ์๋ ์์
- ๋ง์ฝ ์กฐ๊ฑด์์ true๊ฐ ๋ค์ด๊ฐ๋ฉด (while (true) {} ) ํญ์ ์กฐ๊ฑด์์ด true๊ฐ ๋๋ฉด์ ๋ฌดํ๋ฃจํ๋ฅผ ๋๋ค.
- ๋ฌดํ๋ฃจํ๋ ๋ฌดํํ ๋ฐ๋ณตํ๊ธฐ ๋๋ฌธ์ ์ธ์ ๊ฐ๋ while๋ฌธ์ ๋น ์ ธ๋๊ฐ๊ธฐ ์ํ ์ฝ๋๊ฐ ํ์ํ๋ค. (if)
int i = 1;
while (i>0) {
System.out.println(i); // i๋ ํญ์ 0๋ณด๋ค ํฌ๊ธฐ๋๋ฌธ์ ๋ฌดํ๋ฃจํ๋ฅผ ๋๊ฒ๋๋ค.
i++;
}
// ๋ฌดํ๋ฃจํ๋ฅผ ๋น ์ ธ๋์ค๊ธฐ ์ํ ์ฝ๋ ์ถ๊ฐ
int i = 1;
while (i>0) {
if(i==10) {
System.out.println(i);
System.out.println("Finished!");
break; // while๋ฌธ์ ๋น ์ ธ๋์ค๊ธฐ ์ํ break ์ถ๊ฐ
}
System.out.println(i);
i++;
}
๐ do-while๋ฌธ
do-while๋ฌธ์ ์กฐ๊ฑด์์ ์ํด ๋ฐ๋ณต ์คํ๋๋ค๋ ์ ์์๋ while๋ฌธ๊ณผ ๋์ผํ๋ค.
- while๋ฌธ์ ์์ํ ๋๋ถํฐ ์กฐ๊ฑด์์ ๊ฒ์ฌํ์ฌ ๋ธ๋ก ๋ด๋ถ๋ฅผ ์คํํ ์ง ๊ฒฐ์ ํ์ง๋ง ๊ฒฝ์ฐ์ ๋ฐ๋ผ์๋ ๋ธ๋ก ๋ด๋ถ์ ์คํ๋ฌธ์ ์ฐ์ ์คํ์ํค๊ณ ์คํ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ์ ๋ฐ๋ณต ์คํ์ ๊ณ์ํ ์ง ๊ฒฐ์ ํ๋ ๊ฒฝ์ฐ๋ ์๊ธด๋ค. → ์ด๋ด ๋ do-while๋ฌธ์ ์ฌ์ฉํ ์ ์๋ค.
- ์ฆ , do-while๋ฌธ์ ๋ฌด์กฐ๊ฑด ํ ๋ฒ ์ด์ ์คํ๋๋ ๋ฐ๋ณต๋ฌธ์ด๋ค.
int i = 10;
do {
System.out.println(i);
i--;
} while(i > 1);
- ์คํ๋ฌธ์ ๋จผ์ ์คํํ ๋ do-while๋ฌธ์ ์ฃผ๋ก ์ฌ์ฉํ๋ค.