๋ณ์์ ๋ฆฌํฐ๋ด
int i=1; ์ ์ ํ์ ๋ณ์ i๋ฅผ ์ ์ธํจ๊ณผ ๋์์ 1๋ก ์ด๊ธฐํ
int : ์ ์ ํ์ (type)์ ๋ํ๋ด๋ ํค์๋
ํค์๋๋ java์ธ์ด์์ ์ ํ ์์ฝ์ด๋ฅผ ๋งํ๋ค.
class, public, static, while ๋ชจ๋ ํค์๋
i : ๋ณ์ i, ํ๋์ ๊ฐ์ ๊ฐ์ง ์ ์๋ ๊ณต๊ฐ
1: ์ ์ ๋ฆฌํฐ๋ด 1. ๋ฆฌํฐ๋ด์ด๋ ๋ณ์์ ์ ๋ ฅ๋๋ ๊ฐ
๊ธฐ๋ณธํ ํ์ : ์๋ฌธ์๋ก ์์, ๋ฉ๋ชจ๋ฆฌ ์์ ๊ฐ ์ ์ฅ
์ ์ํ์ (byte) : short(2), int(4), long(8)
์ค์ํ์ : float, double
๋ฌธ์ 1๊ฐ : char
boolean : ์ฐธ(true) or ๊ฑฐ์ง(false)
์ฐธ์กฐํ(reference)=๊ธฐ๋ณธํ์ด ์๋ ํ์ (๋๋ฌธ์๋ก ์์): class, interface,๋ฐฐ์ด ๋ฑ.. ๊ฐ์ ์ฐธ์กฐ
๋ณ์๋ช ๊ท์น
1. ํ๋ ์ด์์ ๊ธ์
2. ์ฒซ ๋ฒ์งธ ๊ธ์๋ ๋ฌธ์ ์ด๊ฑฐ๋ ‘$’ , ’_’
3. ๋๋ฒ์งธ ์ดํ ๊ธ์๋ ์ซ์, ๋ฌธ์, ‘$’ , ‘_’
4. ‘$’ , ‘_’ ์ด์ธ ํน์๋ฌธ์ ์ฌ์ฉ ๋ถ๊ฐ๋ฅ
5. ๊ธธ์ด ์ ํ ์์
6. ํค์๋๋ ๋ณ์๋ช ์ผ๋ก ์ฌ์ฉ๋ถ๊ฐ
7. ์์ ๊ฐ์ ํํํ๋ ๋จ์ด true, false, null์ ๋ณ์๋ช ์ผ๋ก ์ฌ์ฉ ๋ถ๊ฐ
์ฝ๋๋ ํ ์ค์ฉ ์ฐจ๋ก๋๋ก ์คํ๋๋ค.
print()๋ฉ์๋๋ ์ค๋ฐ๊ฟ์ ํ์ง ์๋๋ค.
println()๋ฉ์๋๋ ์ค๋ฐ๊ฟ์ ํ๋ค.
=:๊ฐ์ ๋์ , ==: ๊ฐ์ด ๊ฐ๋ค.
๋ ผ๋ฆฌํ ํ์ ๊ณผ ๋ ผ๋ฆฌ ์ฐ์ฐ์
๋ณ์ ์์ ํ์ ์ ์ด์ผํ๋ค.
๋ฉ์๋ ์์ ์ฌ์ฉ๋ ์ง์ญ๋ณ์๋ ๋ฐ๋์ ์ด๊ธฐํ ํด์ผํ์ง๋ง,
ํด๋์ค ์์ ์ ์ธ๋ ๋ณ์. ์ฆ, ํ๋๋ ์ด๊ธฐํ ํ์ง ์๊ณ ๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
ํ๋๋ ๊ฐ์ ์ ์ฅํ์ง ์์ผ๋ฉด ๊ธฐ๋ณธ์ ์ผ๋ก false๊ฐ์ ๊ฐ์ง๋ค.
^ : exclusive or (=xor)
ex) a ^ b : a์ b์ ๊ฐ์ด ๋ค๋ฅผ๋๋ง ์ฐธ
&& : and
|| : or
Tip
&&๊ฐ ์๊ณ , &๊ฐ ์๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก, ||๊ฐ ์๊ณ , |๊ฐ ์๋ค. ์ด ์ฐจ์ด๋ฅผ ์์๋ณด์
a && b ์์ a๊ฐ false์ด๋ฉด ๋ค์ ์คํํ์ง ์์
a & b์์ a๊ฐ true, false ์๊ด์์ด ๋๊น์ง ์คํ
a || b์์ a๊ฐ true์ด๋ฉด ๋ค์ ์คํํ์ง ์์
a | b์์ a๊ฐ true, false ์๊ด์์ด ๋๊น์ง ์คํ
๋ถ๋ฆฐํ ํ์ ์ 1byte(8bit)๋ฅผ ์ฌ์ฉ. ์ฌ์ค 1๋นํธ๋ง์ผ๋ก ์ฐธ๊ณผ ๊ฑฐ์ง์ ํํํ ์ ์์ง๋ง, ์ปดํจํฐ๋ ์๋ฃ ํํ ์ต์ ๋จ์๊ฐ 1byte์ด๋ฏ๋ก
๋ถ๋ฆฐํ ํ์ ์ 1byte ์ฌ์ฉ
์ ์, ์ค์
์ ์ํ ํ์ byte, short, int, long
byte: 1byte
short: 2byte
int: 4byte
long: 8byte
๋ฆฌํฐํธ ๊ฐ์ธ ์ซ์ 5๋ int ํ์
๋ฆฌํฐ๋ด ๊ฐ์ธ ์ซ์ 5L์ long ํ์
์ค์ํ ํ์ float, double
float: 4byte
double: 8byte
๋ฆฌํฐํธ ๊ฐ์ธ ์ซ์ 5๋ double ํ์
๋ฆฌํฐ๋ด ๊ฐ์ธ ์ซ์ 5L์ float ํ์
์ค๋ฒํ๋ก์ฐ: ๊ณ์ฐ ๊ฒฐ๊ณผ๊ฐ ์ต๋๊ฐ์ ๋๊ฑฐ๋, ์ต์๊ฐ๋ณด๋ค ์์ ๊ฒฝ์ฐ ์์๋ ์์๋ก, ์์๋ ์์๋ก ๋ฐ๋๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋๋ฐ
์ด๊ฒ์ ์ค๋ฒ ํ๋ก์ฐ๋ผ๊ณ ํ๋ค.
ํ์ ์ ๋ณํ
๋ฐ์ดํฐ ์์ค์ด ๋ฐ์ํ ์ ์๋ค. ์๋ฅผ ๋ค์ด, int๋ฅผ byte๋ก ๋ณํํ๋ฉด ๋ฐ์ดํฐ ์์ค์ด ๋ฐ์ํ ์ ์๋ค.
๋ฐํ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์๋ค. ์๋ฅผ ๋ค์ด, ์ซ์๊ฐ ์๋ ๋ฌธ์์ด์ int๋ก ๋ณํํ๋ ค๊ณ ํ๋ฉด NumberFormatException์ด ๋ฐ์ํ๋ค.
ํด๋์ค ๊ฐ์ ์์ ๊ด๊ณ๊ฐ ์๋ ๊ฒฝ์ฐ ๊ฐ์ ํ๋ณํ์ ์ํํ ์ ์๋ค. ์์ ๊ด๊ณ๊ฐ ์๋ ํด๋์ค ๊ฐ์ ํ๋ณํ์ ์๋ํ๋ฉด ClassCastException์ด ๋ฐ์ํ๋ค.
๊ฐ์ฒด๊ฐ null์ธ ๊ฒฝ์ฐ ๊ฐ์ ํ๋ณํ์ ์ํํ ์ ์๋ค. null์ ํ๋ณํํ๋ฉด NullPointerException์ด ๋ฐ์ํ๋ค.
๋ฐ๋ผ์ ๊ฐ์ ํ๋ณํ์ ์ํํ ๋์๋ ์ด๋ฌํ ์ฃผ์์ฌํญ์ ํญ์ ์ผ๋์ ๋์ด์ผ ํ๋ค.
๊ฐ๋ฅํ๋ค๋ฉด, ๋ช ์์ ์ธ ํ๋ณํ์ด ์๋ ์๋ ํ๋ณํ์ ์ฌ์ฉํ๋๋ก ํ๋ ๊ฒ์ด ์ข๋ค.
๋นํธ ์ฐ์ฐ์
๋ฌธ์ ํ์
๋ฌธ์์ด(String)์ ""๋ก ํ๊ธฐ, ๋ฌธ์(char)๋ ''๋ก ํ๊ธฐํ๋ฉฐ
๋ฌธ์ ํ์ ์ ์ ์ ํ์ ์ด๊ธฐ๋ ํ๊ธฐ ๋๋ฌธ์ 0~65535๊น์ง ์ ์ฅํ ์ ์๋ค.
๋ฌธ์๋ unsigned(๋ถํธ์๋, ์์๊ฐ ์๋)์ ์์ด๋ค.
bit : ์ปดํจํฐ๊ฐ ์ฒ๋ฆฌํ๋ ์ ๋ณด์ ์ต์ ๋จ์
byte : 1byte = 8bit, 00000000 ~ 11111111๊น์ง์ ๊ฐ ํํ์ด ๊ฐ๋ฅํ๊ณ ์ ์๋ก ํํํ๋ฉด 0๋ถํฐ 254๊น์ง์ด๋ค.
์ข์ธก ์ํํธ๋ 2^n์ผ๋ก ๋๋ ๊ฒฐ๊ณผ : ํ์ฌ ๊ฐ์ด 4์ด๊ณ 1๋งํผ <<ํ๋ฉด, 4 * (2^1) = 4 * 2 = 8
์ฐ์ธก ์ํํธ๋ 2^n์ผ๋ก ๊ณฑํ ๊ฒฐ๊ณผ : ํ์ฌ ๊ฐ์ด 4์ด๊ณ 1๋งํผ >>ํ๋ฉด, 4 / (2^1) = 4 / 2 = 2
int n = 8;์ผ ๋ <<, >> 3๋ฒ ์ํํธ์ ๊ฐ ๊ตฌํ๊ธฐ
<<(์ข์ธก) : n * (2^shift) = 8 * (2^3) = 8 * 8 = 64
>>(์ฐ์ธก) : n / (2^shifr) = 8 / (2^3) = 8 / 8 = 1
>>(์ฐ์ธก)์ผ๋ก ๊ณ์ ์ํํธ ํ๋ฉด 0์ด ๋๊ณ
<<(์ข์ธก)์ผ๋ก ๊ณ์ ์ํํธ ํ๋ฉด int๋ฒ์(~2,147,483,647)๋ฅผ ๋์ด์ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ๊ณ
-2,147,483,648์ด ๋์๋ค๊ฐ ๋ค์ ์์ ๋ฒ์์ shiftํ ๊ฐ๋ค ๋์จ๋ค. (๋ฌดํ ๋ฐ๋ณต)
์กฐ๊ฑด๋ฌธ if
if๋ ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ธ๋ก ๋ด ๋ฌธ์ฅ์ ์คํ์ํฌ ์ ์๋ ์กฐ๊ฑด๋ฌธ์ด๊ณ else if๋ฅผ ์ถ๊ฐํ์ฌ ์ฌ๋ฌ ์กฐ๊ฑด์ ๊ฑฐ์น ์ ์๋ค.
if๋ฌธ์ฅ์ ๋ธ๋ก์ด ์๋ ๊ฒฝ์ฐ ๋ฐ๋ก ์๋ ํ ๋ฌธ์ฅ๋ง ์กฐ๊ฑด์ ๋ง์กฑํ ๊ฒฝ์ฐ ์คํ๋๋ค.
์ผํญ์ฐ์ฐ์๋ ์กฐ๊ฑด์ ? ๋ฐํ๊ฐ 1 : ๋ฐํ๊ฐ 2
(์กฐ๊ฑด์์ด ์ฐธ์ผ ๊ฒฝ์ฐ ๋ฐํ๊ฐ 1 ์คํ, ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ ๋ฐํ๊ฐ 2 ์คํ)
์กฐ๊ฑด๋ฌธ switch
switch ๋ธ๋ก ์์๋ ์ฌ๋ฌ ๊ฐ์ case์ ํ๋์ default๋ฅผ ๋ฃ์ ์ ์๋ค.
switch ๋ธ๋ก ์์์ break๋ฅผ ๋ง๋๋ฉด switch ๋ธ๋ก์ด ์ข ๋ฃ๋๋ฉฐ
break๊ฐ ์๋ ๊ฒฝ์ฐ ๋ง์ง๋ง case๊น์ง ์ ๋ถ ์คํ๋๋ค.
switch (๋ณ์){
case ๊ฐ1:
๋ณ์๊ฐ ๊ฐ1์ผ๋ ์คํ
break;
case 2:
๋ณ์๊ฐ ๊ฐ2์ผ๋ ์คํ
break;
default:
๋ณ์์ ๊ฐ์ด ์ด๋ค case์๋ ํด๋น๋์ง ์์ ๊ฒฝ์ฐ ์คํ
}
๋ฐ๋ณต๋ฌธ while
while (ํ์ถ ์กฐ๊ฑด์){
ํ์ถ ์กฐ๊ฑด์์ด ์ฐธ์ผ ๊ฒฝ์ฐ ์คํ๋๋ ์ฝ๋;
๋ณ์์ ์ฆ๊ฐ์;
}
while๋ฌธ์ ํ์ถ ์กฐ๊ฑด์์ด false๋ฅผ ๋ฐํํ ๋ ์ข ๋ฃ๋๋ค.
while๋ฌธ์ ํ์ถ ์กฐ๊ฑด์์ด true์ธ ์ํ์์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ข ๋ฃํ๋ ค๋ฉด if์ break์ ์ฌ์ฉํ๋ฉด ๋๋ค.
๋ฐ๋ณต๋ฌธ do
๋ณ์์ ์ด๊ธฐํ
do{
ํ์ถ ์กฐ๊ฑด์์ด ์ฐธ์ผ ๊ฒฝ์ฐ ์คํ๋๋ ์ฝ๋;
๋ณ์์ ์ฆ๊ฐ์;
} while(ํ์ถ ์กฐ๊ฑด์);
do while๋ฌธ์ ๋ฌด์กฐ๊ฑด ํ๋ฒ์ ์คํํ๊ฒ ํ๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค๋ ์ ์ด while๊ฐ ๋ค๋ฆ
์ฆ, ๋ฌด์กฐ๊ฑด ํ๋ฒ์ ์คํํด์ผ ํ๋๋ฐ?๋ผ๋ ์๊ณ ๋ฆฌ์ฆ์ด ํ์ํ ๋ ์ฌ์ฉํ๋ค.
๋ฐ๋ณต๋ฌธ for
for(๋ณ์์ ์ด๊ธฐํ;ํ์ถ์กฐ๊ฑด์;์ฆ๊ฐ์){
ํ์ถ ์กฐ๊ฑด์์ด ์ฐธ์ธ ๊ฒฝ์ฐ ์คํ๋๋ ์ฝ๋
}
break์ continue๋ฌธ์ ํ๊ณ-> label
break๋ ํ์ฌ ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ๋๊ฐ๋๋ฐ ์ฌ์ฉ
continue๋ continue๋ฌธ ์๋ ๋ถ๋ถ ์คํํ์ง ์๊ณ ๋ค์ ๋ฐ๋ณต
์ค์ฒฉ๋ฐ๋ณต๋ฌธ์ ํ๋ฒ์ ๋๊ฐ๋ ค๋ฉด?
or
continue์ดํ๋ฅผ ์คํํ์ง ์๊ณ ํ๋ฒ์ ์ค์ฒฉ๋ฐ๋ณต๋ฌธ์ ๋ฐ๋ณตํ๋ ค๋ฉด?
->label ์ฌ์ฉ(goto์ ์ ์ฌ)
outter:
for(int i=0;i<3;i++){
for(int k=0;k<3;k++){
if(i==0 && k==2)
break outter;
System.out.println(i +k);
}
}
์ด ๊ฒฝ์ฐ ์์ ์๋ for๋ฌธ์ด ์๋ ๋ฐ๊นฅ for๋ฌธ์ ๋น ์ ธ๋๊ฐ ์ข ๋ฃ๋๋ค.
'๐ผ๋ฐฑ์ค๋ > Java ๋ฌธ๋ฒ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๊ฐ์ฒด ์งํฅ ๋ฌธ๋ฒ 2/3 (0) | 2023.08.20 |
---|---|
๊ฐ์ฒด ์งํฅ ๋ฌธ๋ฒ 1/3 (0) | 2023.08.20 |
05_02 ArrayLoop (0) | 2023.07.05 |
05_01 Array (0) | 2023.07.05 |
04_11 Continue (0) | 2023.07.05 |