[์๋ฐํ๋ก๊ทธ๋๋ฐ1] 6์ฃผ์ฐจ ๊ฐ์_ํ๊ธฐ
ํค์ ๋ ฅ, ์๊ณผ ์ฐ์ฐ์, ์ ์ด๋ฌธ
1์ฐจ์ ํค์ ๋ ฅ(System.in, Scanner)
System.in // ํ์ค ์
๋ ฅ
ํค๋ณด๋๋ก๋ถํฐ ์ง์ ์ฝ๋ ์๋ฐ์ ํ์ค ์
๋ ฅ ์คํธ๋ฆผ
ํค ๊ฐ์ ๋ฐ์ดํธ ๋จ์๋ก ๋ฆฌํด // 1byte์ด๋ฏ๋ก ๋ฌธ์ ์๋
๊ทธ๋ฌ๋ฏ๋ก ์์ฉ ํ๋ก๊ทธ๋จ์ด ๋ฌธ์ ์ ๋ณด๋ก ๋ณํํด์ผ ํ๋ ๋ฌธ์ ์ ์ด ์์
Scanner ํด๋์ค
System.in์๊ฒ ํค๋ฅผ ์ฝ๊ฒ ํ๊ณ , ๋ค์ํ ํ์
์ผ๋ก ๋ณํํ์ฌ ๋ฆฌํด
import java.util.Scanner; // ๋ค๋ฅธ ํจํค์ง์ ์๋ ํด๋์ค ์ฌ์ฉํ๋ฏ๋ก import๋ฌธ ์ ์ธ ํ์
Scanner scanner = new Scanner(System.in); // scanner ๊ฐ์ฒด ์์ฑ
์
๋ ฅ๋ ํค ๊ฐ์ ๊ณต๋ฐฑ๋ฌธ์๋ก ๊ตฌ๋ถ๋๋ ํ ํฐ ๋จ์๋ก ์ฝ์ // ‘\t’, ‘\f’, ‘\r’, ‘ ‘, ‘\n’
next() // ๋ค์ ํ ํฐ์ ๋ฌธ์์ด๋ก ๋ฆฌํด
nextLine() // \n์ ํฌํจํ๋ ํ ์ค์ ์ฝ์ด๋ค์ธ ๋ค, \n์ ์ ์ธํ ๋ฌธ์์ด ๋ฆฌํด
nextInt() // ๋ค์ ํ ํฐ์ intํ์ผ๋ก ๋ฆฌํด
close() // ์ฌ์ฉ ์ข
๋ฃ
hasNext() // ํ์ฌ ์ ๋ ฅ๋ ํ ํฐ์ด ์์ผ๋ฉด true๋ฅผ ๋ฆฌํด, ์๋๋ฉด ๋ฌดํ์ ๋๊ธฐ, ctrl+z ํค๊ฐ ์ ๋ ฅ๋๋ฉด ์ ๋ ฅ ๋์ด๋ฏ๋ก false ๋ฆฌํด
์๊ณผ ์ฐ์ฐ
์ // ํผ์ฐ์ฐ์์ ์ฐ์ฐ์๋ก ์ด๋ฃจ์ด์ง
์ฐ์ฐ // ์ฃผ์ด์ง ์์ ๊ณ์ฐํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ์ป์ด๋ด๋ ๊ณผ์
์ฐ์ฐ์์ ์ฐ์ ์์๋ ์์์ ์ผ๋ก ์๊ฐํ๋ฉด ๋จ
๋จํญ, ์ดํญ, ์ผํญ ์ฐ์ฐ์์
๋์
์ฐ์ฐ์๊ฐ ๊ฐ์ฅ ๋์ค
๊ดํธ๋ ์ต์ฐ์ ์์
์ผ๋ฐ์ ์ผ๋ก ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฐ์ฐ
์ฐ์ ์ฐ์ฐ์
์ค์น ์ฐ์ฐ, %๋ ๋๋จธ์ง ์ฐ์ฐ์
์ฆ๊ฐ ์ฐ์ฐ์
1 ์ฆ๊ฐ ๋๋ ๊ฐ์์ํค๋ ์ฐ์ฐ์
์ ์, ํ์ ์ฐ์ฐ์์ ๋ฐ๋ผ ์ฐ์ฐ ์์๊ฐ ๋ฌ๋ผ์ง๋ค. // ++a;๋ +1 ๋จผ์ , a++;์ +1 ๋์ค
๋์
์ฐ์ฐ์ // ์ค๋ฅธ์ชฝ ๊ฐ์ ์ผ์ชฝ์ ๋์
๋ณตํฉ ๋์
์ฐ์ฐ์ // ์ค๋ฅธ์ชฝ์ ๋์
์ฐ์ฐ์๊ฐ ์๋ค. ex) +=
๋์
์ฐ์ฐ์, ์ฆ๊ฐ์ฐ์ฐ์์ ์ฌ์ฉ -> ํท๊ฐ๋ฆผ // ๋ฐ๋์ ๊ทธ๋ฆผ์ ๊ทธ๋ ค์ ์๊ฐํด๋ณด๊ธฐ
2์ฐจ์ ์๊ณผ ์ฐ์ฐ์
int a = 3, b = 3, c= 3; // ์ฌ๋ฌ ๊ฐ์ ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ ์ฝค๋ง๋ก ๊ตฌ๋ถํ์ฌ ํ ์ค๋ก ์์ฑ ๊ฐ๋ฅ
๋
ผ๋ฆฌ ์ฐ์ฐ์
! not // true์ด๋ฉด false
&& and // ๋๋ค true์ฌ์ผ true
|| or // ๋ ์ค ํ๋๋ง true์ฌ๋ true
^ xor // ์๋ก ๋ฌ๋ผ์ผ true
๋น๊ต ์ฐ์ฐ์๋ ์ขํญ์ ๊ธฐ์ค์ผ๋ก ์ฝ์
๋น๊ต ์ฐ์ฐ์์ ๋
ผ๋ฆฌ ์ฐ์ฐ์์ ๋ณตํฉ์ฌ๋ก์์ ์ํ์ ์ผ๋ก ํํํ๋ฉด ์ปดํ์ผ ์๋ฌ // ๋ฌธ๋ฒ ์ค๋ฅ
์กฐ๊ฑด ์ฐ์ฐ์ // ํจ์ถ์ ์ผ๋ก ์์ฑํ๋ ๊ฒ์ด ๋ ์ข์ ์ฝ๋
๋นํธ ์ฐ์ฐ์ // ๋นํธ ๋จ์๋ก ์ฐ์ฐ, ๋นํธ ๋
ผ๋ฆฌ ์ฐ์ฐ๊ณผ ๋นํธ ์ํํธ ์ฐ์ฐ์ด ์์
๋นํธ ๋
ผ๋ฆฌ์ฐ์ฐ์๋ ์ฐ์ฐ์ 1๊ฐ๋ง ์ด๋ค. Ex) &, |, ~, ^
์ค๋ฅธ์ชฝ์ผ๋ก 2๊ฐ ์ํํธ ์ฐ์ฐ์ด๋ฉด ์ค๋ฅธ์ชฝ 2๊ฐ์ ๋นํธ๋ฅผ ์์ค๋ค. // a >> 2
์กฐ๊ฑด๋ฌธ
๋จ์ if๋ฌธ // if(์กฐ๊ฑด์) {์กฐ๊ฑด์์ด ์ฐธ์ด๋ฉด ์คํ๋ ๋ฌธ์ฅ}
if-else๋ฌธ // if() {} else {}
๋ค์ค if-else๋ฌธ // if() {} else if() {} else {}
์ค์ฒฉ if-else๋ฌธ // if() { if() {} else {} } else {}
if๋ฌธ์์ ๋ธ๋ก{}์ ์ง์ ํ์ง ์์ผ๋ฉด ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฒ๊ณผ ๊ด๋ จ๋์ด ์คํ๋จ
๋ค์ค if-else๋ฌธ์ switch๋ฌธ์ผ๋ก ๋ฐ๊พธ๋ ๊ฒ์ด ์ข์ // ๋ ํท๊ฐ๋ฆผ
3์ฐจ์ ์ ์ด๋ฌธ(์กฐ๊ฑด๋ฌธ, ๋ฐ๋ณต๋ฌธ)
switch๋ฌธ //
switch(์){
case ๊ฐ1:
์คํ๋ฌธ์ฅ1;
break;
case ๊ฐ2:
์คํ๋ฌธ์ฅ2;
break;
…
default:
์คํ๋ฌธ์ฅn;
}
break; // ํ๋ก๊ทธ๋จ์์ break;๋ฌธ์ ๋ง๋๋ฉด ์๊ธฐ์์ ์ ๋๋ฌ์ธ๊ณ ์๋ ๋ธ๋ก {} ์ผ๋ก๋ถํฐ ๋ฒ์ด๋๋ค.
switch๋ฌธ์์ case๋ฅผ ํ๋ฒ๋ง ๊ฒ์ฌํ๋ฏ๋ก break;๋ฌธ์ด ์๋ค๋ฉด break;๋ฌธ์ ๋ง๋ ๋๊น์ง ๋ค์ ์คํ๋ฌธ์ฅ๋ค์ ๊ณ์ ์คํํ๋ค.
case๋ฌธ์ ๊ฐ์ ์ค์ ๋ฆฌํฐ๋ด์ ํ์ฉ๋์ง ์์ // ์ ์, ๋ฌธ์, ๋ฌธ์์ด ๋ฆฌํฐ๋ด๋ง ๊ฐ๋ฅ
byte, short, int, char, String // ๊ฐ๋ฅ
long, float, double // ๋ถ๊ฐ๋ฅ, long์ ์ ์ ๋ฆฌํฐ๋ด ์ค์์ ์ ์ผํ๊ฒ ์๋๋ ํ์
3์ฅ ๋ฐ๋ณต๋ฌธ๊ณผ ๋ฐฐ์ด ๊ทธ๋ฆฌ๊ณ ์์ธ์ฒ๋ฆฌ
๋ฐ๋ณต๋ฌธ // for, while, do-while
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
๋ฌธ) {
์คํ๋ฌธ์ฅ;
}
์ด๊ธฐ๋ฌธ์ ๋ฐ๋ณต ์ ์ด ๋ณ์ ์ ์ธ ๊ฐ๋ฅ
์ด๊ธฐ๋ฌธ๊ณผ ๋ฐ๋ณต ํ ์์
๋ฌธ์ ,๋ก ๊ตฌ๋ถํ์ฌ ์ฌ๋ฌ ๋ฌธ์ฅ ๋์ด ๊ฐ๋ฅ
๋ฌดํ๋ฐ๋ณต
1. ์กฐ๊ฑด์์ ๋
ผ๋ฆฌ ๋ฆฌํฐ๋ด true;
2. ์กฐ๊ฑด์์ ๋น์๋ ; ;
while(์กฐ๊ฑด์){
์คํ๋ฌธ์ฅ;
}
do
{
์คํ๋ฌธ์ฅ;
} while(์กฐ๊ฑด์);
while๋ฌธ ๋์๋ ์ธ๋ฏธ์ฝ๋ก ์ด ์์ง๋ง, do while๋ฌธ ๋์๋ ์ธ๋ฏธ์ฝ๋ก ์ด ์์ด์ผ ํจ
while, do-while๋ฌธ ์กฐ๊ฑด์์ ์ฌ์ฉ๋ ๋ฐ๋ณต ์ ์ด ๋ณ์๋ ๊ทธ ์ ์ ์ ์ธ๋์ด ์์ด์ผ ํจ
while, do-while๋ฌธ ๋ฌดํ๋ฐ๋ณต์ ํํํ๊ธฐ ์ํด ์กฐ๊ฑด์์ ๋น์๋๋ฉด ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์
'1. Java ์๋ฐ > 1_0. ์ฑ , ๊ฐ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๋ฐํ๋ก๊ทธ๋๋ฐ1] 9์ฃผ์ฐจ ๊ฐ์_ํ๊ธฐ (0) | 2022.04.24 |
---|---|
[์๋ฐํ๋ก๊ทธ๋๋ฐ1] 7์ฃผ์ฐจ ๊ฐ์_ํ๊ธฐ (0) | 2022.04.23 |
[์๋ฐํ๋ก๊ทธ๋๋ฐ1] 5์ฃผ์ฐจ ๊ฐ์_ํ๊ธฐ (0) | 2022.04.23 |
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ1] 4์ฃผ์ฐจ ๊ฐ์_ํ๊ธฐ (0) | 2022.04.23 |
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ1] 3์ฃผ์ฐจ ๊ฐ์_ํ๊ธฐ (0) | 2022.04.23 |