Java์ ๋ฐ์ดํฐ ํ์ ์ ํ๋ก๊ทธ๋จ์์ ๋ค์ํ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ์ฒ๋ฆฌํ๋ ๋ฐ ํ์์ ์ธ ์์์ ๋๋ค. ๋ฐ์ดํฐ ํ์ ์ ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ฉด ํ๋ก๊ทธ๋จ์ ์์ ์ฑ๊ณผ ์ฑ๋ฅ์ ๋์ผ ์ ์์ต๋๋ค. Java์ ๋ฐ์ดํฐ ํ์ ์ ํฌ๊ฒ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ (Primitive Data Types)๊ณผ ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์ (Reference Data Types)์ผ๋ก ๋๋ฉ๋๋ค. ์ด๋ฒ ๊ธ์์๋ Java์ ์ฃผ์ ๋ฐ์ดํฐ ํ์ ๊ณผ ๊ฐ ํ์ ์ ์์ ๋ฅผ ํตํด ๋ฐ์ดํฐ ํ์ ์ ํ์ฉ๋ฒ์ ์์๋ณด๊ฒ ์ต๋๋ค.
๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ (Primitive Data Types)
Java์ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ์ ์ด 8๊ฐ์ง๋ก, ๋ฉ๋ชจ๋ฆฌ์ ๊ณ ์ ๋ ํฌ๊ธฐ๋ก ์ ์ฅ๋๋ฉฐ ํจ์จ์ ์ธ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ์๋ ์ ์ํ, ์ค์ํ, ๋ฌธ์ํ, ๋ ผ๋ฆฌํ์ด ์์ต๋๋ค.
1. ์ ์ํ ๋ฐ์ดํฐ ํ์
Java์ ์ ์ํ ๋ฐ์ดํฐ ํ์
์ byte
, short
, int
, long
์ด ์์ผ๋ฉฐ, ๊ฐ ํ์
์ ์ ์ฅ ๊ฐ๋ฅํ ๊ฐ์ ๋ฒ์์ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ๊ฐ ๋ค๋ฆ
๋๋ค.
์ ์ํ ์์ ์ฝ๋
public class IntegerExample {
public static void main(String[] args) {
byte smallNumber = 100;
short mediumNumber = 32000;
int standardNumber = 100000;
long largeNumber = 10000000000L; // L ์ ๋ฏธ์ฌ ํ์
System.out.println("byte: " + smallNumber);
System.out.println("short: " + mediumNumber);
System.out.println("int: " + standardNumber);
System.out.println("long: " + largeNumber);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
byte: 100
short: 32000
int: 100000
long: 10000000000
์ ์ฝ๋์์๋ ๊ฐ๊ธฐ ๋ค๋ฅธ ํฌ๊ธฐ์ ์ ์ํ ๋ณ์๋ฅผ ์ ์ธํ๊ณ ์ถ๋ ฅํ๊ณ ์์ต๋๋ค. long
ํ์
์ ๊ฒฝ์ฐ, ํฐ ์ ์๋ฅผ ํํํ๊ธฐ ์ํด ์ ๋ฏธ์ฌ L
์ ๋ถ์ฌ์ผ ํฉ๋๋ค.
2. ์ค์ํ ๋ฐ์ดํฐ ํ์
Java์ ์ค์ํ ๋ฐ์ดํฐ ํ์
์ float
๊ณผ double
์ด ์์ผ๋ฉฐ, ์์์ ์ดํ์ ๊ฐ์ ํฌํจํ ์ซ์๋ฅผ ์ ์ฅํ ์ ์์ต๋๋ค.
์ค์ํ ์์ ์ฝ๋
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);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
float: 3.14
double: 2.718281828459045
์ ์ฝ๋์์๋ float
๊ณผ double
์ ์ฌ์ฉํ์ฌ ์ค์ ๊ฐ์ ์ ์ฅํ๊ณ ์์ต๋๋ค. float
ํ์
์ F
์ ๋ฏธ์ฌ๋ฅผ ํ์๋ก ํ๋ฉฐ, double
์ ๋ ๋์ ์ ๋ฐ๋๋ฅผ ๊ฐ์ง๋๋ค.
3. ๋ฌธ์ํ ๋ฐ์ดํฐ ํ์
char
๋ฐ์ดํฐ ํ์
์ ๋จ์ผ ๋ฌธ์๋ฅผ ์ ์ฅํ๋ฉฐ, ์ ๋์ฝ๋ ๋ฌธ์ ํํ์ด ๊ฐ๋ฅํฉ๋๋ค.
๋ฌธ์ํ ์์ ์ฝ๋
public class CharExample {
public static void main(String[] args) {
char letter = 'A';
char digit = '1';
char symbol = '#';
System.out.println("๋ฌธ์: " + letter);
System.out.println("์ซ์ ๋ฌธ์: " + digit);
System.out.println("๊ธฐํธ: " + symbol);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
๋ฌธ์: A
์ซ์ ๋ฌธ์: 1
๊ธฐํธ: #
์ ์ฝ๋์์๋ ๋ฌธ์, ์ซ์ ๋ฌธ์, ๊ธฐํธ๋ฅผ char
ํ์
์ผ๋ก ์ ์ธํ๊ณ ์ถ๋ ฅํฉ๋๋ค. char
๋ ์์ ๋ฐ์ดํ(' '
)๋ก ๊ฐ์ธ์ ํํํฉ๋๋ค.
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๋ ์ฌ๋ฏธ์๋ค: true
๋ฌผ๊ณ ๊ธฐ๋ ๋ง์๋ค: false
์ ์ฝ๋์์๋ boolean
๋ณ์๋ฅผ ์ ์ธํ๊ณ , true
์ false
๊ฐ์ ํ ๋นํ์ฌ ์ถ๋ ฅํฉ๋๋ค.
์ฐธ์กฐ ๋ฐ์ดํฐ ํ์ (Reference Data Types)
Java์์ ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์
์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๋ํ์ ์ธ ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์
์ผ๋ก๋ ๋ฌธ์์ด์ ๋ค๋ฃจ๋ String
์ด ์์ต๋๋ค. String
์ ""
๋ก ๊ฐ์ธ์ ํํํฉ๋๋ค.
String ์์ ์ฝ๋
public class StringExample {
public static void main(String[] args) {
String greeting = "Hello, World!";
String name = "Alice";
System.out.println("์ธ์ฌ: " + greeting);
System.out.println("์ด๋ฆ: " + name);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
์ธ์ฌ: Hello, World!
์ด๋ฆ: Alice
์ ์ฝ๋์์๋ String
ํ์
๋ณ์๋ฅผ ์ ์ธํ๊ณ , ๋ฌธ์์ด์ ์ ์ฅํ ํ ์ถ๋ ฅํฉ๋๋ค. String
์ Java์์ ๊ฐ์ฅ ์์ฃผ ์ฌ์ฉ๋๋ ์ฐธ์กฐ ํ์
์ค ํ๋์
๋๋ค.
๋ฐ์ดํฐ ํ์ ๋ณํ ์์
Java์์๋ ์๋ก ๋ค๋ฅธ ๋ฐ์ดํฐ ํ์ ๊ฐ์ ๋ณํ์ด ํ์ํ ๋๊ฐ ์์ต๋๋ค. ํ์ ๋ณํ์ ๋ฌต์์ ๋ณํ๊ณผ ๋ช ์์ ๋ณํ์ผ๋ก ๋๋ฉ๋๋ค.
1. ๋ฌต์์ ํ์ ๋ณํ
์์ ๋ฐ์ดํฐ ํ์ ์ ํฐ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ๋ณํํ ๋ ์๋์ผ๋ก ๋ณํ์ด ์ด๋ฃจ์ด์ง๋๋ค.
public class ImplicitConversionExample {
public static void main(String[] args) {
int num = 100;
double doubleNum = num; // ์๋ ๋ณํ (int → double)
System.out.println("์๋ ๋ณํ๋ ๊ฐ: " + doubleNum);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
์๋ ๋ณํ๋ ๊ฐ: 100.0
์ ์ฝ๋์์๋ int
ํ์
์ double
ํ์
์ผ๋ก ์๋ ๋ณํํ์ฌ ์ถ๋ ฅํ๊ณ ์์ต๋๋ค.
2. ๋ช ์์ ํ์ ๋ณํ
ํฐ ๋ฐ์ดํฐ ํ์ ์ ์์ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ๋ณํํ ๋๋ ๋ฐ์ดํฐ ์์ค์ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ช ์์ ์ผ๋ก ๋ณํํด์ผ ํฉ๋๋ค.
public class ExplicitConversionExample {
public static void main(String[] args) {
double doubleValue = 9.78;
int intValue = (int) doubleValue; // ๊ฐ์ ํ๋ณํ (double → int)
System.out.println("๊ฐ์ ๋ณํ๋ ๊ฐ: " + intValue);
}
}
์ถ๋ ฅ ๊ฒฐ๊ณผ:
๊ฐ์ ๋ณํ๋ ๊ฐ: 9
์ ์ฝ๋์์๋ double
ํ์
์ int
ํ์
์ผ๋ก ๊ฐ์ ํ๋ณํํ๋ฉฐ, ์์์ ์ดํ ๋ถ๋ถ์ด ๋ฒ๋ ค์ง๋๋ค.
๊ฒฐ๋ก
Java์ ๋ฐ์ดํฐ ํ์ ์ ํ๋ก๊ทธ๋จ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ๋ค๋ฃจ๋ ๋ฐ ๋งค์ฐ ์ค์ํ ์ญํ ์ ํฉ๋๋ค. ์ด๋ฒ ๊ธ์์๋ ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์ ๊ณผ ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์ ์ ์ฃผ์ ์์ ๋ฅผ ํตํด Java ๋ฐ์ดํฐ ํ์ ์ ํ์ฉ๋ฒ์ ์ดํด๋ณด์์ต๋๋ค. ์ฌ๋ฐ๋ฅธ ๋ฐ์ดํฐ ํ์ ์ ์ ํํ๊ณ ์ฌ์ฉํ๋ฉด, ๋ณด๋ค ์์ ์ ์ด๊ณ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ๋ค์ํ ๋ฐ์ดํฐ ํ์ ์์ ๋ฅผ ํตํด Java์์ ๋ฐ์ดํฐ ํ์ ์ ๋ ๊น์ด ์ดํดํ๊ณ ํ์ฉํด ๋ณด์ธ์!
๋๊ธ ์ฐ๊ธฐ