Java์์ ๋ฐ์ดํฐ ํ์ ์ ๋ณ์๊ฐ ์ ์ฅํ ์ ์๋ ๊ฐ์ ์ข ๋ฅ๋ฅผ ๊ฒฐ์ ํฉ๋๋ค. ๋ฐ์ดํฐ ํ์ ์ ์ฌ๋ฐ๋ฅด๊ฒ ์ดํดํ๊ณ ์ฌ์ฉํ๋ ๊ฒ์ ํ๋ก๊ทธ๋๋ฐ์ ๊ธฐ๋ณธ์ด๋ฉฐ, ์ฝ๋์ ์์ ์ฑ๊ณผ ์ฑ๋ฅ์ ๋์ด๋ ๋ฐ ์ค์ํ ์ญํ ์ ํฉ๋๋ค. ์ด๋ฒ ๊ธ์์๋ Java์ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ๊ณผ ๊ฐ ํ์ ์ ํน์ฑ, ๊ทธ๋ฆฌ๊ณ ๋ณ์ ์ ์ธ ์ ๋ฐ์ดํฐ ํ์ ์ ํ์ฉ๋ฒ์ ์ค๋ช ํ๊ฒ ์ต๋๋ค.
Java ๋ฐ์ดํฐ ํ์ ์ ์ข ๋ฅ
Java์ ๋ฐ์ดํฐ ํ์ ์ ํฌ๊ฒ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ (Primitive Data Types)๊ณผ ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์ (Reference Data Types)์ผ๋ก ๋๋ฉ๋๋ค.
1. ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ (Primitive Data Types)
Java์๋ 8๊ฐ์ง์ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ์ด ์์ต๋๋ค. ์ด๋ฌํ ํ์ ์ ๋ฉ๋ชจ๋ฆฌ์ ๊ณ ์ ๋ ํฌ๊ธฐ๋ฅผ ์ฐจ์งํ๋ฉฐ, ํ๋ก๊ทธ๋จ์ ์ฑ๋ฅ์ ์ต์ ํํ๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค.
- ์ ์ํ:
byte
,short
,int
,long
- ์ค์ํ:
float
,double
- ๋ฌธ์ํ:
char
- ๋
ผ๋ฆฌํ:
boolean
2. ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์ (Reference Data Types)
์ฐธ์กฐ ๋ฐ์ดํฐ ํ์ ์ ๊ฐ์ฒด์ ์ฐธ์กฐ๋ฅผ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๋ฐฐ์ด, ํด๋์ค, ์ธํฐํ์ด์ค ๋ฑ์ด ์ฐธ์กฐ ํ์ ์ ํฌํจ๋ฉ๋๋ค. ์ด ๊ธ์์๋ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ์ ์ค์ ์ ๋์ด ์ค๋ช ํ๊ฒ ์ต๋๋ค.
๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ์ ํน์ง
1. ์ ์ํ ๋ฐ์ดํฐ ํ์
์ ์ํ ๋ฐ์ดํฐ ํ์ ์ ์ ์๋ฅผ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋๋ฉฐ, ํ์ ์ ๋ฐ๋ผ ์ ์ฅ ๊ฐ๋ฅํ ๊ฐ์ ๋ฒ์๊ฐ ๋ค๋ฆ ๋๋ค.
ํ์ | ํฌ๊ธฐ | ๊ฐ์ ๋ฒ์ |
---|---|---|
byte |
1๋ฐ์ดํธ | -128 ~ 127 |
short |
2๋ฐ์ดํธ | -32,768 ~ 32,767 |
int |
4๋ฐ์ดํธ | -2,147,483,648 ~ 2,147,483,647 |
long |
8๋ฐ์ดํธ | -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 |
์์ ์ฝ๋
public class IntegerExample {
public static void main(String[] args) {
byte smallNumber = 100;
int mediumNumber = 50000;
long largeNumber = 10000000000L; // L ์ ๋ฏธ์ฌ ํ์
System.out.println("byte: " + smallNumber);
System.out.println("int: " + mediumNumber);
System.out.println("long: " + largeNumber);
}
}
2. ์ค์ํ ๋ฐ์ดํฐ ํ์
์ค์ํ ๋ฐ์ดํฐ ํ์
์ ์์์ ์ ํฌํจํ๋ ์ซ์๋ฅผ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. float
์ double
ํ์
์ด ์์ผ๋ฉฐ, ์ ํ๋์ ์ ์ฅ ๋ฒ์๊ฐ ๋ค๋ฆ
๋๋ค.
ํ์ | ํฌ๊ธฐ | ์ค๋ช |
---|---|---|
float |
4๋ฐ์ดํธ | ์์์ ์ดํ ์ฝ 7์๋ฆฌ์ ์ ํ๋ |
double |
8๋ฐ์ดํธ | ์์์ ์ดํ ์ฝ 15์๋ฆฌ์ ์ ํ๋ |
์์ ์ฝ๋
public class FloatDoubleExample {
public static void main(String[] args) {
float pi = 3.14F; // F ์ ๋ฏธ์ฌ ํ์
double e = 2.718281828459045;
System.out.println("float: " + pi);
System.out.println("double: " + e);
}
}
3. ๋ฌธ์ํ ๋ฐ์ดํฐ ํ์
char
ํ์
์ ๋จ์ผ ๋ฌธ์๋ฅผ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋๋ฉฐ, ์ ๋์ฝ๋ ๋ฌธ์๋ฅผ ์ง์ํฉ๋๋ค.
public class CharExample {
public static void main(String[] args) {
char letter = 'A';
char unicodeChar = '\u0041'; // 'A'์ ์ ๋์ฝ๋
System.out.println("char: " + letter);
System.out.println("์ ๋์ฝ๋ char: " + unicodeChar);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
char: A
์ ๋์ฝ๋ char: A
4. ๋ ผ๋ฆฌํ ๋ฐ์ดํฐ ํ์
boolean
ํ์
์ true
๋๋ false
๋ ๊ฐ์ง ๊ฐ๋ง ๊ฐ์ง ์ ์์ผ๋ฉฐ, ์กฐ๊ฑด๋ฌธ๊ณผ ๋
ผ๋ฆฌ ์ฐ์ฐ์ ์ฌ์ฉ๋ฉ๋๋ค.
public class BooleanExample {
public static void main(String[] args) {
boolean isJavaFun = true;
boolean isFishTasty = false;
System.out.println("Java๋ ์ฌ๋ฏธ์๋ค: " + isJavaFun);
System.out.println("๋ฌผ๊ณ ๊ธฐ๋ ๋ง์๋ค: " + isFishTasty);
}
}
๋ฐ์ดํฐ ํ์ ๋ณํ
Java์์๋ ๋ฐ์ดํฐ ํ์ ๋ณํ์ด ํ์ํ ๋๊ฐ ์์ต๋๋ค. ํ์ ๋ณํ์ ๋ฌต์์ (์๋) ๋ณํ๊ณผ ๋ช ์์ (๊ฐ์ ) ๋ณํ์ผ๋ก ๋๋ฉ๋๋ค.
๋ฌต์์ ๋ณํ (์๋ ๋ณํ)
Java๋ ์์ ๋ฐ์ดํฐ ํ์ ์ ํฐ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ์๋ ๋ณํํฉ๋๋ค.
int num = 10;
double result = num; // ์๋ ๋ณํ (int → double)
System.out.println("์๋ ๋ณํ๋ ๊ฐ: " + result);
๋ช ์์ ๋ณํ (๊ฐ์ ๋ณํ)
ํฐ ๋ฐ์ดํฐ ํ์ ์ ์์ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ๋ณํํ ๋๋ ๋ฐ์ดํฐ ์์ค์ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ช ์์ ์ผ๋ก ๋ณํํด์ผ ํฉ๋๋ค.
double largeNumber = 9.78;
int integerPart = (int) largeNumber; // ๊ฐ์ ๋ณํ (double → int)
System.out.println("๊ฐ์ ๋ณํ๋ ๊ฐ: " + integerPart);
๋ณ์ ์ ์ธ๊ณผ ์ด๊ธฐํ
Java์์ ๋ณ์๋ฅผ ์ ์ธํ ๋๋ ๋ฐ์ดํฐ ํ์ ๊ณผ ๋ณ์๋ช ์ ์ง์ ํด์ผ ํฉ๋๋ค. ๋ณ์๋ ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํํ ์๋ ์๊ณ , ๋์ค์ ์ด๊ธฐํํ ์๋ ์์ต๋๋ค.
int a; // ์ ์ธ
a = 5; // ์ด๊ธฐํ
double b = 3.14; // ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ
๊ฒฐ๋ก
Java์ ๋ฐ์ดํฐ ํ์ ์ ํ๋ก๊ทธ๋จ์ด ์ฒ๋ฆฌํ ๋ฐ์ดํฐ๋ฅผ ์ ์ํ๊ณ ๋ค๋ฃจ๋ ๋ฐ ์ค์ํ ์ญํ ์ ํฉ๋๋ค. ๊ฐ ๋ฐ์ดํฐ ํ์ ์ ํน์ฑ๊ณผ ์ ์ฅ ๊ฐ๋ฅํ ๊ฐ์ ๋ฒ์๋ฅผ ์ ์ดํดํ๊ณ ์ฌ์ฉํ๋ฉด ํจ์จ์ ์ด๊ณ ์์ ํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ์ด๋ฒ ๊ธ์์ ์ค๋ช ํ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ๊ณผ ์์ ๋ฅผ ํตํด Java ํ๋ก๊ทธ๋๋ฐ์ ๊ธฐ์ด๋ฅผ ํํํ ๋ค์ ธ ๋ณด์ธ์!
๋๊ธ ์ฐ๊ธฐ