๋ชฉํ
์๋ฐ์ ํ๋ฆฌ๋ฏธํฐ๋ธ ํ์ , ๋ณ์ ๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ตํ๋๋ค.
ํ์ตํ ๊ฒ
- ํ๋ฆฌ๋ฏธํฐ๋ธ ํ์ ์ข ๋ฅ์ ๊ฐ์ ๋ฒ์ ๊ทธ๋ฆฌ๊ณ ๊ธฐ๋ณธ ๊ฐ
- ํ๋ฆฌ๋ฏธํฐ๋ธ ํ์ ๊ณผ ๋ ํผ๋ฐ์ค ํ์
- ๋ฆฌํฐ๋ด
- ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํํ๋ ๋ฐฉ๋ฒ
- ๋ณ์์ ์ค์ฝํ์ ๋ผ์ดํํ์
- ํ์ ๋ณํ, ์บ์คํ ๊ทธ๋ฆฌ๊ณ ํ์ ํ๋ก๋ชจ์
- 1์ฐจ ๋ฐ 2์ฐจ ๋ฐฐ์ด ์ ์ธํ๊ธฐ
- ํ์ ์ถ๋ก , var
Primitive Type
Type | Contains | Default | Size | Range |
---|---|---|---|---|
boolean | true or false | false | 1bit | |
char | unicode | \u0000 | 16bits | \u0000 ~ \uffff |
byte | signed integer | 0 | 8bits | -128 ~ 127 |
short | signed integer | 0 | 16bits | โ32768 ~ 32767 |
int | signed integer | 0 | 32bits | โ2147483648 ~ 2147483647 |
long | signed integer | 0 | 64bits | 9223372036854775808 ~ 9223372036854775807 |
float | IEEE 754 floating point | 0.0 | 32bits | 1.4Eโ45 ~ 3.4028235E+38 |
double | IEEE 754 floating point | 0.0 | 64bits | 4.9Eโ324 ~ 1.7976931348623157E+308 |
+) Java์๋ unsigned
primitive type์ด ์๋ค.
Primitive vs Reference
- Primitve๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ ์ํ ์ ์์.
- Primitive๋ ๊ฐ ์์ฒด๋ฅผ ํํํ์ง๋ง, Reference ํ์ ์ ๋ฉ๋ชจ๋ฆฌ ์ฐธ์กฐ ๊ฐ์.
- Primitive๋ ๊ฐ์ ํญ์ ์ ์ฒด ๋ณต์ฌํด์ ์ ๋ฌํ์ง๋ง, Reference๋ ํด๋น ๋ฉ๋ชจ๋ฆฌ ๊ฐ๋ง์ ์ ๋ฌํ๋ฉฐ, ๋ฉ๋ชจ๋ฆฌ๋ ํ์ ์ ์ฅ๋์ด GC์ ๋์์ด ๋๋ค.
Boxing, Unboxing
Java์์๋ Primitive type์ Wrapperํด๋์ค(Boolean
, Byte
, Short
, Character
, Integer
, Long
, Float
, Double
)๋ฅผ ์ ๊ณตํ๊ณ , ์ฃผ๋ก Collection์ ๊ฐ์ ์ ์ฅํ ๋ ์ฌ์ฉํ๋ค(Generic์ ์ฐธ์กฐ ๊ฐ๋ง ์ง์ํ๊ธฐ ๋๋ฌธ). ex List<Integer>
- Boxing : Primitive โ Reference
- Unboxing: Reference โ Primitive
Java์์ boxing,unboxing์ ํ์ ์บ์คํ ํ์์์ด ์๋์ผ๋ก ์ผ์ด๋๋ค. ๋ถํ์ํ boxing, unboxing์ ์ฑ๋ฅ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ๋ฏ๋ก Collections๋ก ์ฐ๋๊ฒ ์๋๋ผ๋ฉด Primitive๋ฅผ ์ฐ์.
Literal
์์๊ฐ์ ๋ํ๋ด๋ ๋ฌธ์.
1 1.0 '1' 1L "one" true false null
- integer literal โ int๋ก ์ทจ๊ธ.
- long โ
L
, octa โ0
, hex โ0x
, binary โ0b
๋ฅผ ๋ถ์ฌ์ผ ํจ
- long โ
- floating point๋ overflow๋๋ฉด Infinity. underflow๋๋ฉด 0.
double inf = 1.0/0.0; // Infinity
double neginf = -1.0/0.0; // Negative infinity
double negzero = -1.0/inf; // Negative zero
double NaN = 0.0/0.0; // Not a Number
๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ
int <๋ณ์ ์ด๋ฆ> = 0; // primitive type
Player <๋ณ์ ์ด๋ฆ> = new Player(); // reference type์ new์ ์์ฑ์ ํจ์๋ก ์ด๊ธฐํ
๋ณ์์ ์ค์ฝํ์ ๋ผ์ดํํ์
- ํด๋์ค ๋ณ์ - ํด๋์ค๋ก๋๊ฐ ํด๋์ค๋ฅผ ๋ก๋ฉํ ๋ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น (static). ๋ชจ๋ ํด๋์ค ์ธ์คํด์ค๊ฐ ํด๋น ๋ณ์๋ฅผ ๊ณต์ .
- ์ธ์คํด์ค ๋ณ์ - ์ธ์คํด์ค๊ฐ ์์ฑ๋ ๋ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๊ณ ์ธ์คํด์ค๊ฐ ํด์ ๋ ๋ ๊ฐ์ด ํด์ ๋จ.
- ์ง์ญ ๋ณ์ - ๋ฉ์๋ ๋ด์์ ์ ์ธ. ๋ฉ์๋ ๋ด์์๋ง ์ฌ์ฉ ๊ฐ๋ฅ
ํ์ ๋ณํ, ์บ์คํ ๊ทธ๋ฆฌ๊ณ ํ์ ํ๋ก๋ชจ์
- ํ์
๋ณํ
- ๋ณ์์ ํ์ ์ ๋ค๋ฅธ ํ์ ์ผ๋ก ๋ณ๊ฒฝํ๋ ๊ฒ
- ํ์
์บ์คํ
(๊ฐ์ ๋ณํ)
()
์ฐ์ฐ์๋ฅผ ์ด์ฉํด ๊ฐ์ ๋ก ํ๋ณํํ๋ค.- ๊ฐ์ ๋ก ํ๋ณํํ๊ธฐ ๋๋ฌธ์ ๊ฐ ์์ค์ด ์์ ์ ์๋ค. ex
(int)3.14f -> 3
- ํ์
ํ๋ก๋ชจ์
(์๋ ๋ณํ)
- ํ์ ํ์ ์ด ์์ ํ์ ์ผ๋ก ๋ณ๊ฒฝ๋๋ ๊ฒฝ์ฐ.
byte โ short โ int โ long โ float โ double
1์ฐจ ๋ฐ 2์ฐจ ๋ฐฐ์ด ์ ์ธํ๊ธฐ
int[] arr1 = new int[2]; // 1์ฐจ์ ๋ฐฐ์ด
int[][] arr = new int[2][3]; // 2x3 ๋ฐฐ์ด
int[][] arr = new int[][] {{1,0}, {2}}; // ์ ์ธ๊ณผ ๋์ ์ด๊ธฐํ, ์๋ก ๋ค๋ฅธ ๊ธธ์ด๋ก ์ ์ธ ๊ฐ๋ฅ.
ํ์
์ถ๋ก , var
var list = new ArrayList<String>();
Java10๋ถํฐ ์ถ๊ฐ๋, ๋ณ์ ์ ์ธ ์ ์ด๊ธฐํ ๊ฐ์ ๋ฐํ์ผ๋ก ํ์
์ ์ถ๋ก ํด์ฃผ๋ ํค์๋(.NET์๋ ์๋ค).
์ ์ธ ์ ํ์
์ ์ฌ๋ฌ๋ฒ ์ฐ์ง ์์๋ ๋๋ฏ๋ก ์ฝ๋๋ฅผ ๊น๋ํ๊ฒ ์ ์งํ ์ ์์ผ๋ฉฐ, ํํํ๊ธฐ ๊ณค๋ํ ํ์
์ ๋ํ๋ด๋๋ฐ๋ ์ข๋ค.
๋ค๋ง ์๋์ ๊ฐ์ ๊ฒฝ์ฐ๋ค์ var
ํค์๋๋ฅผ ์ด์ฉํ ํ์
์ถ๋ก ์ด ๋ถ๊ฐ๋ฅํ๋ค.
var x; // ์ด๊ธฐํ ํ์
var x = null // null๋ก๋ ์ด๊ธฐํ ๋ถ๊ฐ
var arr = {1,2,3} // ๋ฐฐ์ด ์ด๊ธฐํ๋ ๋ถ๊ฐ
var f = () -> {} // lambda ๋ถ๊ฐ