Intro. ๋ณ์๋?
๋ณ์(variable)๋ ๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ์ ํน์ ๋ฒ์ง์ ๋ถ์ด๋ ์ด๋ฆ์ด๋ค. *ํ๋์ ๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ณต๊ฐ์ด๋ค. ํ๋ก๊ทธ๋จ์ ๋ณ์๋ฅผ ํตํด ๋ฉ๋ชจ๋ฆฌ์ ํน์ ๋ฒ์ง์ ๊ฐ์ ์ ์ฅํ๊ณ ์ฝ์ ์ ์๋ค. ๋ฉ๋ชจ๋ฆฌ๋ ๋ฌดํ์ ์ฌ์ฉํ ์ ์๋ ๊ณต๊ฐ์ด ์๋๊ธฐ ๋๋ฌธ์ ์๋ง์ ํ์ (์๋ฃํ)์ ์ฐ๋ ๊ฒ์ด ๋งค์ฐ ์ค์ํ๋ค.
*ํ๋์ ๋ณ์์๋ ์ค๋ก์ง ํ๋์ ๊ฐ๋ง ์ ์ฅํ ์ ์๊ณ , ์๋ฐ์์๋ ์ ์ธ๋ ๋ณ์์ ํ ๊ฐ์ง ์ข ๋ฅ์ ๊ฐ๋ง ์ ์ฅํ ์ ์๋ค.
๋ณ์๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ด๋์ ์ ์ฅํ๊ณ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ์ฅํ ์ง๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ด์์ฒด์ ๊ฐ ์ ํ๋ค. ์๋ฐ์ ๊ฒฝ์ฐ๋ JVM์ด ํ๋ค.
1. ๋ณ์ ๊ท์น
(1) ๋ณ์ ๋ช ๋ช ๊ท์น
๋ณ์ ์ด๋ฆ์ ํตํด ์๋ฏธ๋ฅผ ์ฝ๊ฒ ์ ์ถํ ์ ์๋๋ก '์๋ฏธ ์๋' ๋ณ์ ์ด๋ฆ์ ์ง์ด์ฃผ๋ ๊ฒ์ด ์ข๋ค. ๋ณ์ ์ด๋ฆ์ ๊ธธ์ด๋ ํ๋ก๊ทธ๋จ ์คํ๊ณผ๋ ๋ฌด๊ดํ๊ธฐ ๋๋ฌธ์ ์ถฉ๋ถํ ๊ธธ์ด๋ ์๊ด ์๋ค.
Camel case๋ฅผ ์ฌ์ฉํ๊ณ , ์ฒซ ๋ฒ์งธ ๊ธ์๋ ํน์๋ฌธ์ ํน์ ์ซ์๋ก ์์ํ ์ ์๋ค.
(2) ์์ฝ์ด ์ฌ์ฉ ๋ถ๊ฐ
๋ณ์ ๋ช ์ผ๋ก ์์ฝ์ด๋ฅผ ์ธ ์ ์๋ค. ์์ฝ์ด๋ ์ด๋ฏธ ํด๋น ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ํน์ ํ ์๋ฏธ๋ก ์ฐ์ด๊ณ ์๊ธฐ ๋๋ฌธ์, ์ฌ์ฉํ ์ ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
โป e.g) boolean, short, private, class, new, true, package ....
(3) ๋ก์ปฌ๋ณ์
๋ณ์๋ ์์ ์ด ์ ์ธ๋ ์์น์์ ์์ ์ด ์ํ ๋ธ๋ก ๋ด๋ถ๊น์ง๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๊ณ ๋ฐ์์๋ ์ฌ์ฉํ ์ ์๋ค. ๋ฉ์๋ ์คํ์ด ๋๋๋ฉด ๋ฉ๋ชจ๋ฆฌ์์ ์๋์ผ๋ก ์์ด์ง๋ค.
2. ๋ณ์์ ๊ด๋ จ๋ ์ฉ์ด
- ๋ณ์ ์ ์ธ: ๋ณ์์ ์ด๋ค ํ์ (์๋ฃํ)์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๊ฒ์ธ์ง, ๋ณ์ ์ด๋ฆ์ด ๋ฌด์์ธ์ง ๊ฒฐ์
๋ณ์ํ์ ๋ณ์์ด๋ฆ; // ๋ณ์์ ์ ์ธ ๋ฐฉ๋ฒ
int age; // ์ ์(int)๋ฅผ ์ ์ฅํ ์ ์๋ age ๋ณ์ ์ ์ธ
double value; // ์ค์(double)๋ฅผ ์ ์ฅํ ์ ์๋ value ๋ณ์ ์ ์ธ
- ํ ๋น: ๋ณ์์ ๊ฐ์ ๋ฃ๊ฑฐ๋ ์ ์ฅํ๋ ๊ฒ
- ์ฐธ์กฐ: ๋ณ์์ ์ ๊ทผํ๋ ๊ฒ
- ๊ฐ ์ ์ฅ: ๋ณ์์ ๊ฐ์ ์ ์ฅํ ๋๋ ๋์ ์ฐ์ฐ์(=)์ ์ฌ์ฉ, ์ค๋ฅธ์ชฝ ๊ฐ์ ์ผ์ชฝ์ ๋์
int score; // ๋ณ์ ์ ์ธ
score = 90; // ๊ฐ ์ ์ฅ
- ๋ณ์ ์ด๊ธฐํ: ๋ณ์์ ์ต์ด๋ก ๊ฐ์ด ์ ์ฅ๋ ๋ ๋ณ์๊ฐ ์์ฑ๋๋ ๊ฒ
- **์ด๊ธฐ๊ฐ: ๋ณ์ ์ด๊ธฐํ ๋ ์ฌ์ฉ๋ ๊ฐ
**๋ณ์๋ ์ด๊ธฐ๊ฐ์ด ์ ์ฅ๋์ง ์์ ์ํ์์ ์ฝ์ ์ ์๋ค.
Why?
์์ง ๋ฉ๋ชจ๋ฆฌ ๋ฒ์ง ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์์ง ์์ผ๋ฏ๋ก!!! ๋ณ์๋ฅผ ํตํด ๋ฉ๋ชจ๋ฆฌ ๊ฐ์ ์ฝ์ ์ ์๋ค.
3. ๋ณ์์ ํ์ - ๊ธฐ๋ณธํ์ (primitive type)๊ณผ ์ฐธ์กฐํ์ (reference type)
(1) ๊ธฐ๋ณธํ์ (primitive type)
๋ ผ๋ฆฌํ(boolean), ๋ฌธ์ํ(char), ์ ์ํ(byte, short, int, long), ์ค์ํ(float, double)
๊ณ์ฐ์ ์ํ ์ค์ ๊ฐ์ ์ ์ฅํ๋ค. ๋ชจ๋ 8๊ฐ.
↓๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ ์ธ์ฐ๋ ๋ฒ!
boolean์ true์ false ๋ ๊ฐ์ง ๊ฐ๋ง ํํํ ์ ์์ผ๋ฉด ๋๋ฏ๋ก ๊ฐ์ฅ ์์ ํฌ๊ธฐ์ธ 1 byte.
char์ ์๋ฐ์์ ์ ๋์ฝ๋(2 byte ๋ฌธ์์ฒด๊ณ)๋ฅผ ์ฌ์ฉํ๋ฏ๋ก 2 byte.
byte๋ ํฌ๊ธฐ๊ฐ 1byte๋ผ์ byte.
int(4 byte)๋ฅผ ๊ธฐ์ค์ผ๋ก ์งง์์ short(2 byte), ๊ธธ์ด์ long(8 byte).
float๋ ์ค์๊ฐ์ ๋ถ๋์์์ (floating-point) ๋ฐฉ์์ผ๋ก ์ ์ฅํ๊ธฐ ๋๋ฌธ์ float(4 byte).
double์ float๋ณด๋ค ๋ ๋ฐฐ์ ํฌ๊ธฐ(8 byte)๋ฅผ ๊ฐ๊ธฐ ๋๋ฌธ์ double.
ํ์ฉ ๋ฒ์๋ฅผ ์ด๊ณผํ ๊ฐ์ ๋์ ํ์ ๊ฒฝ์ฐ ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
(2) ์ฐธ์กฐํ์ (reference type)
๊ฐ์ฒด์ ์ฃผ์๋ฅผ ์ ์ฅํ๋ค. 8๊ฐ์ ๊ธฐ๋ณธํ์ ์ ์ธํ ๋๋จธ์ง ํ์ .
3. ๋ฌธ์ ๋ฆฌํฐ๋ด
๋ฆฌํฐ๋ด: ์์ค ์ฝ๋์์ ํ๋ก๊ทธ๋๋จธ์ ์ํด ์ง์ ์ ๋ ฅ๋ ๊ฐ
char ํ์ ์ 2 byte ํฌ๊ธฐ์ ์ ๋์ฝ๋๊ฐ ๋ค์ด๊ฐ๋๋ฐ, ์ ๋์ฝ๋๋ ์ ์์ด๋ฏ๋ก char๋ ์ ์ ํ์ ์ ์ํ๋ค.
'A'๋ int ํ์ ๋ณ์์๋ ์ ์ฅํ ์ ์๋ค.
char var1 = 'A';
int var2 = 'A';
System.out.println(var1); // A๋ฅผ ์ถ๋ ฅ
System.out.println(var1); // 65๋ฅผ ์ถ๋ ฅ
4. ํ๋ณํ
(1) ์๋ ํ์ ๋ณํ(Promotion)
←
ํฐ ํ์ฉ ๋ฒ์ ← = ← ์์ ํ์ฉ ๋ฒ์ ํ์
์๋ ํ์ ๋ณํ์ ๋ง ๊ทธ๋๋ก ์๋์ผ๋ก ํ์ ๋ณํ์ด ์ผ์ด๋๋ ๊ฒ์ด๋ค. ์ฝ๋๋ก ๋ณด๋ ๊ฒ์ด ์ดํด๊ฐ ๋ ๋น ๋ฅผ ๊ฒ์ด๋ค.
byte byteValue = 10; // ์์ ๊ฐ
int intValue = byteValue; // ํฐ ๊ทธ๋ฆ์ผ๋ก ์ฎ๊ฒจ์ง=์๋ ํ์
๋ณํ๋จ
๊ฐ์ด ์๋์ผ๋ก ํฐ ๊ทธ๋ฆ(ํฐ ์๋ฃํ์ ๋ณ์)์ผ๋ก ์ฎ๊ฒจ์ก๋ค๊ณ ๋ณด๋ฉด ๋๋ค.
โป ์์ธ: byte ํ์ ์ cahr ํ์ ์ผ๋ก ์๋ ํ์ ๋ณํ๋ ์ ์๋ค.
Why? char ํ์ ์ ํ์ฉ๋ฒ์๋ ์์๋ฅผ ํฌํจํ์ง ์๋๋ฐ, byte ํ์ ์ ์์๋ฅผ ํฌํจํ๊ธฐ ๋๋ฌธ์ด๋ค.
(2) ๊ฐ์ ํ๋ณํ(Casting)
ํฐ ํ์ฉ ๋ฒ์ ํ์ ์ ์์ ํ์ฉ ๋ฒ์ ํ์ ์ผ๋ก ๊ฐ์ ๋ก ๋๋ ์ ์ ์ฅํ๋ ๊ฒ์ด๋ค.
์บ์คํ ์ฐ์ฐ์ ๊ดํธ ( )๋ฅผ ์ฌ์ฉํ๋๋ฐ, ๊ดํธ ์์ ๋ค์ด๊ฐ๋ ํ์ ์ ๋๋๋ ๋จ์์ด๋ค.
←
์์ ํ์ฉ ๋ฒ์ ํ์ ← = ← (์์ ํ์ฉ ๋ฒ์ ํ์
) ํฐ ํ์ฉ ๋ฒ์ ํ์
๊ฐ์ ํ๋ณํ.
int intValue = 10;
byte byteValue = (byte) intValue; // ๊ฐ์ ํ์
๋ณํ
์ฐธ๊ณ ์์ | ํผ์ ๊ณต๋ถํ๋ ์๋ฐ | ์ด๊ฒ์ด ์๋ฐ๋ค | ์๋ฐ์ ์ ์ ๊ธฐ์ดํธ | THE ์น์ ํ ์๋ฐ ์ ๋ฌธ
'๐์น ๊ฐ๋ฐ(Web) > ์๋ฐ(JAVA)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฐ์ด(array)๊ณผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํตํด ์์๋ณด๋ ๋ฐฐ์ด์ ๋์์๋ฆฌ (0) | 2024.11.30 |
---|---|
JAVA ํท๊ฐ๋ฆฌ๋ JDK, JRE, JVM ์ดํด ๋ฐ JDK ์ค์น ๋ฐฉ๋ฒ (2) | 2024.11.18 |