[Java] ๊ธฐ๋ณธ์ ์ธ ๋ฌธ๋ฒ๋ค - ์๋ฃํ, ์์, ๋ฆฌํฐ๋ด์ ๋ํด
by rlaehddnd0422๊ธฐ๋ณธ์ ์ธ ๋ฌธ๋ฒ๋ค ์ค ์ฌ์ํ๊ฑฐ๋ ์๋ฆฌ ์์ด ๋น์ฐํ๋ค๊ณ ์๊ฐํ๋ ๊ฒ๋ค ์์ฃผ๋ก ์ ๋ฆฌํ์ต๋๋ค.
1. ๋ณ์์ ํ์(์๋ฃํ)
๊ธฐ๋ณธํ
๊ธฐ๋ณธํ์๋ ๋ ผ๋ฆฌํ, ๋ฌธ์ํ, ์ ์ํ, ์ค์ํ์ด ์์ต๋๋ค.
- ๋ ผ๋ฆฌํ - boolean (C์์๋ bool๋ก ์ฌ์ฉํ์ง๋ง, Java์์๋ boolean์ผ๋ก ์ฌ์ฉํฉ๋๋ค.)
- ๋ฌธ์ํ - char
- ์ ์ํ - byte, short, int, long
- ์ค์ํ - double, float
- Spring ์ ๋ค๋ฃฐ ๋์๋ int, double, long ๋์ Integer, Double, Long์ ์ฌ์ฉํ๋๋ฐ int์ Integer๋ ์ด๋ป๊ฒ ๋ค๋ฅผ๊น?
int๋ ์๋ฃํ(primitive type, ๋ณ์์ ํ์ ์ผ๋ก '๋ณ์'๋ '๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ ์์ ๊ณต๊ฐ'์ ์๋ฏธ)์ผ๋ก ์ฐ์์ฐ์ฐ์ด ๊ฐ๋ฅํ๊ณ null๋ก ์ด๊ธฐํ๊ฐ ๋ถ๊ฐ๋ฅํ์ง๋ง, Integer์ wrapper class๋ก Integer์ ํ ๋นํ ๊ฐ์ Unboxingํ์ง ์์ ์์๋ ์ฐ์ฐ์ด ๋ถ๊ฐ๋ฅํ๊ณ , null๊ฐ์ผ๋ก ์ด๊ธฐํํ ์ ์์ต๋๋ค.
boxing : primitive type โก๏ธ wrapper class ๋ณํ ( int to Integer )
unboxing : wrapper class โก๏ธ primitive type ๋ณํ ( Integer to int )
public class WrapperTest {
public static void main(String[] args) {
Long value1 = Long.valueOf(1); // long to Long (Boxing)
Long value2 = Long.valueOf(2); // long to Long (Boxing)
long value3 = null; // null ์ด๊ธฐํ ๋ถ๊ฐ๋ฅ
Long value4 = null; // null ์ด๊ธฐํ ๊ฐ๋ฅ
System.out.println("value1 = " + value1 + value2);
}
}
์ฐธ์กฐํ
๊ธฐ๋ณธํ์ ์ ์ธํ ๋๋จธ์ง ํ์ ์ ์ฐธ์กฐํ ๋ณ์๋ก ํด๋์ค์ ์ด๋ฆ์ ์ฌ์ฉํ๋ฏ๋ก ํด๋์ค์ ์ด๋ฆ์ด ์ฐธ์กฐ๋ณ์์ ํ์ ์ด ๋ฉ๋๋ค. (๋ฐ๋ผ์ String๋ ์ฐธ์กฐํํ์ )
๋ฐ๋ผ์ ์๋ก์ด ํด๋์ค๋ฅผ ์์ฑํ๋ค๋ ๊ฒ์ ์ด๋ค ์๋ฏธ์์ ์ฐธ์กฐ๋ณ์ํ์ ์ถ๊ฐํ๋ ์ ์ ๋๋ค.
ํด๋์ค์ด๋ฆ ๋ณ์์ด๋ฆ;
๋ณ์ Naming ๊ท์น
- ๋์๋ฌธ์๊ฐ ๊ตฌ๋ถ๋๋ฉฐ ๊ธธ์ด์ ์ ํ์ด ์์ต๋๋ค.
- ์ฆ, int a์ int A๋ ์๋ก ๋ค๋ฅธ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
- Java์ ์์ฝ์ด๋ก ๋ฑ๋ก๋ ๊ฒ๋ค์ ๋ณ์ ์ด๋ฆ์ผ๋ก ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ์์ฝ์ด์๋ if, do, double, try, void, abstract, extends ๋ฑ์ด ์์.
- ์์ฝ์ด์ ๋ํ ์ถ๊ฐ์ ๋ณด๋ ์ฐธ๊ณ ์๋ฃ๋ฅผ ์ฐธ๊ณ
- ์ซ์๋ก ์์ํ ์ ์์ต๋๋ค.
- ex) int 1abc, int 9sp (X)
- ํน์๋ฌธ์๋ '_'์ '$'๋ง์ ํ์ฉํฉ๋๋ค.
- ex) int $uper (O), int _$3 (O), int #a (X), int ^3^(X)
- ํ๊ธ๋ ๋ณ์์ด๋ฆ์ผ๋ก ์ง์ ํ ์ ์์ต๋๋ค.
- ex) int ์๋ (O)
2. ์์(Constant)
์์๋ ๋ณ์์ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ฐ์ ์ ์ฅํ ์ ์๋ ๊ณต๊ฐ์ด์ง๋ง ํ ๋ฒ ๊ฐ์ ์ ์ฅํ๋ฉด ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํฉ๋๋ค. ์์๋ฅผ ์ ์ธํ๋ ๋ฐฉ๋ฒ์ ๋ณ์์ ๋์ผํ๋, ํ์ ์์ final ํค์๋๋ง ์ถ๊ฐํ๋ฉด ๋ฉ๋๋ค. ์ ์ธ๊ณผ ๋์์ ๊ฐ์ ์ ์ฅํ์ง ์์ผ๋ฉด ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค.
public class ConstantTest {
public static void main(String[] args) {
final Long a = 1L;
final Long b;
System.out.println("b = " + b);
}
}
- final ํค์๋๋ ๋ณ์(variable), ๋ฉ์๋(method), ๋๋ ํด๋์ค(class)์ ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ์ด๋ค ๊ณณ์ ์ฌ์ฉํ๋๋์ ๋ฐ๋ผ ๋ค๋ฅธ ์๋ฏธ๋ฅผ ๊ฐ์ง์ง๋ง ๊ณตํต์ ์ผ๋ก ๋ฌด์ธ๊ฐ๋ฅผ ์ ํํ๋ค๋ ์ ์ ๊ณตํต์ ์ ๋๋ค.
๋ฉ์๋์ final ํค์๋๋ฅผ ๋ถ์ด๋ฉด override๋ฅผ ์ ํ.
๋ณ์์ final ํค์๋๋ฅผ ๋ถ์ด๋ฉด ๋ณ๊ฒฝ ์ ํ.
ํด๋์ค์ final ํค์๋๋ฅผ ๋ถ์ด๋ฉด ์์ ์ ํ.
์์ Naming ๊ท์น
์์์๋ ์๋ฌธ์๋ก ์ฌ์ฉํ์ง๋ง ์ผ๋ฐ์ ์ผ๋ก ์์ ์ด๋ฆ์ ๋ชจ๋ ๋๋ฌธ์๋ก ํ๊ณ , ์ฌ๋ฌ ๋จ์ด๋ก ์ด๋ฃจ์ด์ง ๊ฒฝ์ฐ _๋ก ๊ตฌ๋ถํ๋๊ฒ ๊ฐ๋ฐ์๋ค ์ฌ์ด์ ์๋ฌต์ ์ฝ์์ ๋๋ค.
3. ๋ฆฌํฐ๋ด(Literal)
๊ฐ ์์ฒด๋ฅผ ์๋ฏธํ๋ ๊ฒ. ์ฝ๊ฒ ๋งํด final Long A_VALUE = 1L;์์ 1L์ด ๋ฆฌํฐ๋ด.
์์์ ๋ฆฌํฐ๋ด์ ๋ฐ์ ํ ๊ด๊ณ๋ฅผ ๊ฐ์ง๋๋ค.
๊ฐ๋ฐ ๋จ๊ณ์์ ๋ฆฌํฐ๋ด ๊ฐ์ ์ฌ๋ฌ๊ตฐ๋ฐ์์ ์ฌ์ฉํ๋ค๊ณ ์๊ฐํด๋ด ์๋ค. ๊ทธ๋ฐ๋ฐ ์ด ๋ฆฌํฐ๋ด ๊ฐ์ ๋ณ๊ฒฝํด์ผ ํ๋ ๊ฒฝ์ฐ, ๋ฆฌํฐ๋ด์ ์ฌ์ฉํ ๋ชจ๋ ๊ณณ์ ์ฐพ์ ์ผ์ผ์ด ๋ชจ๋ ๋ณ๊ฒฝํด์ฃผ์ด์ผ ํฉ๋๋ค. ํ์ง๋ง ์์๋ฅผ ์ฌ์ฉํ๋ค๋ฉด ์์์ ๊ฐ์ ์ ์ฅํ ๋ถ๋ถ๋ง ๋ฐ๊ฟ์ฃผ๋ฉด ๋ชจ๋ ๊ฒ์ด ํด๊ฒฐ๋ฉ๋๋ค.
- ์์๊ฐ ์๋์ฌ๋ ์๊ด์์ง ์๋?
- final ํค์๋๋ฅผ ๋นผ๊ณ ์์๋ก ์ง์ ํ์ง ์๊ณ ์ฌ์ฉํด๋ ๋์ง ์๋๋ผ๊ณ ํ ์ ์๋๋ฐ ์ฌ์ฉ ๋์ค ์์ฑํ ์ฝ๋์ ์ํด ์๋์น ์๊ฒ ๊ฐ์ด ๋ฐ๋์ด๋ฒ๋ฆฌ๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. ๋ง์ฝ ์ฌ์ฉ๋์ค ๊ฐ์ด ๋ฐ๋๋ค๋ฉด ์ปดํ์ผ ์์ ์ ์ด๊ฑธ ๋์น์ฑ๊ณ ์๋ ค์ฃผ๊ธฐ ๋๋ฌธ์ ๋ฆฌํฐ๋ด์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์์ํํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ ๋๋ค.
๋ฆฌํฐ๋ด ์ ๋ฏธ์ฌ
- int์ long์ ๋ฆฌํฐ๋ด์ ๊ตฌ๋ถํ๊ธฐ ์ํด ์ ์ํ์ longํ์ ์ ๋ฆฌํฐ๋ด์๋ ์ ๋ฏธ์ฌ 'l(์๋ฌธ์ L)'๋๋ 'L'์ ๋ถ์ ๋๋ค.
- double๊ณผ float์ ๋ฆฌํฐ๋ด์ ๊ตฌ๋ถํ๊ธฐ ์ํด doubleํ์๋ ๋์ d๋ฅผ ๋ถ์ด๊ณ , floatํ์๋ ๋์ f๋ฅผ ๋ถํ ๊ตฌ๋ถํฉ๋๋ค.
- ๋ถ์ด์ง ์์ ๊ฒฝ์ฐ๋ doubleํ์ผ๋ก ๊ฐ์ฃผํ๊ธฐ ๋๋ฌธ์, float ์๋ฃํ์ ์ ๋ฏธ์ฌ๋ฅผ ๋ถ์ด์ง ์์ผ๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค.
- ex) float pi = 3.14; // error
- ๋ถ์ด์ง ์์ ๊ฒฝ์ฐ๋ doubleํ์ผ๋ก ๊ฐ์ฃผํ๊ธฐ ๋๋ฌธ์, float ์๋ฃํ์ ์ ๋ฏธ์ฌ๋ฅผ ๋ถ์ด์ง ์์ผ๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํฉ๋๋ค.
public class LiteralTest0 {
public static void main(String[] args) {
long a = 1L;
double d = 0.1d;
float f = 0.11f;
System.out.println("a = " + a);
System.out.println("d = " + d);
System.out.println("f = " + f);
}
}
- + 10์ง์ ์ธ์๋ 2,8,16์ง์๋ก ํํ๋ ๋ฆฌํฐ๋ด์ ๋ณ์์ ์ ์ฅํ ์ ์์ต๋๋ค.
public class LiteralTest {
public static void main(String[] args) {
long big = 010; // 8์ง์ 10 -> 10์ง์ 8
long hexNum = 0x10; // 16์ง์ 10 -> 10์ง์ 16
long binNum = 0b11; // 2์ง์ 11 - > 10์ง์ 3
System.out.println("big = " + big);
System.out.println("hexNum = " + hexNum);
System.out.println("binNum = " + binNum);
}
}
- 16์ง์๋ผ๋ ๊ฒ์ ํ์ํ๊ธฐ ์ํด ๋ฆฌํฐ๋ด ์์ '0x'๋ '0X'๋ฅผ ๋ถ์ด๊ณ
- 8์ง์๋ผ๋ ๊ฒ์ ํ์ํ๊ธฐ ์ํด ๋ฆฌํฐ๋ด ์์ '0'์ ๋ถ์ด๊ณ ,
- 2์ง์๋ผ๋ ๊ฒ์ ํ์ํ๊ธฐ ์ํด ๋ฆฌํฐ๋ด ์์ '0b'๋ฅผ ๋ถ์ ๋๋ค.
public class LiteralDelimiterTest {
public static void main(String[] args) {
long big = 100_000_000_000L;
long hex = 0xFFFF_FFFF_FFFFL;
System.out.println("big = " + big);
System.out.println("hex = " + hex);
}
}
Tip : JDK 1.7๋ถํฐ๋ ์ ์ํ ๋ฆฌํฐ๋ด ์ค๊ฐ์ ๊ตฌ๋ถ์ _๋ฅผ ๋ฃ์ด ํฐ ์ซ์๋ฅผ ํธํ๊ฒ ์ฝ์ ์ ์๊ฒ ๋์์ต๋๋ค.
์ ๊ณฑ ๋ฆฌํฐ๋ด ์ ๋ฏธ์ฌ
์ ์ฐ์ด์ง๋ ์์ง๋ง ๊ธฐํธ p๋ฅผ ์ด์ฉํด ์ค์ ๋ฆฌํฐ๋ด์ ์ง์ํํ๋ก ํํํ ์ ์์ต๋๋ค. p๋ 2์ ์ ๊ณฑ์ ์๋ฏธํฉ๋๋ค.
๊ธฐํธ E๋ฅผ ์ด์ฉํด ์ค์ ๋ฆฌํฐ๋ด์ ์ง์ํํ๋ก ํํํ ์ ์์ต๋๋ค. E๋ 10์ ์ ๊ณฑ์ ์๋ฏธํฉ๋๋ค.
public class LiteralDelimiterTest0 {
public static void main(String[] args) {
// 16์ง์ 12 * 2^3 = (16 + 2) * 8 = 144.0
double d = 0x12p3;
// 3 * 10^3 = 3000
double a = 3e3;
System.out.println("d = " + d);
System.out.println("a = " + a);
}
}
ํ์ ํ์ฅ
float์ ์์์ ์ ๋ฐ๋๋ 7์๋ฆฌ, double์ ์์์ ์ ๋ฐ๋๋ 15์๋ฆฌ
์๋์ ์ผ๋ก ํฐ ์๋ฃํ์๋ ์๋์ ์ผ๋ก ์์ ํ์ ์ ๋ด์ ์ ์์ต๋๋ค.
ex) int i = 'A' // OK('A'์ ์ ๋์ฝ๋์ธ 65๊ฐ ์ ์ฅ). int ํ์ ์ ๋ฒ์๊ฐ char ํ์ ์ ๋ฒ์๋ณด๋ค ํฌ๊ธฐ ๋๋ฌธ์
ex) long l = 123; // OK. long ํ์ ์ ๋ฒ์๊ฐ int ํ์ ์ ๋ฒ์๋ณด๋ค ํฌ๊ธฐ ๋๋ฌธ์
ex) double d = d = 3.14f // OK. double ํ์ ์ ๋ฒ์๊ฐ float ํ์ ์ ๋ฒ์๋ณด๋ค ํฌ๊ธฐ ๋๋ฌธ์
ex) float f = 3.14 // ์๋ฌ. float ํ์ ์ ๋ฒ์๋ณด๋ค double ํ์ ์ด ํฌ๋ฏ๋ก ์ ์ฅ ๋ถ๊ฐ
ex) int i = 0x123456789; int ํ์ ์ ๋ฒ์๋ฅผ ๋์ด์ฌ 0001 2345 6789(16์ง์)
๋ฌธ์์ ๋ฌธ์์ด ๋ฆฌํฐ๋ด
๋ฌธ์์ ๊ฒฝ์ฐ ์์ ๋ฐ์ดํ๋ก ๊ฐ์ธ ๋ฌธ์ ๋ฆฌํฐ๋ด๋ก ์ฌ์ฉํฉ๋๋ค -> ๋ฌธ์ A์ ๊ฒฝ์ฐ 'A'
๋ฌธ์์ด์ ๊ฒฝ์ฐ ํฐ ๋ฐ์ดํ๋ก ๊ฐ์ธ ๋ฌธ์์ด ๋ฆฌํฐ๋ด๋ก ์ฌ์ฉํฉ๋๋ค -> ๋ฌธ์์ด ABC์ ๊ฒฝ์ฐ "ABC"
๋ฌธ์์ ๊ฒฝ์ฐ ๋ฆฌํฐ๋ด ์์ ๊ณต๋ฐฑ๋ฌธ์๋ฅผ ํฌํจํ์ฌ ๋ฐ๋์ ๋ฌธ์๊ฐ ์์ด์ผ ํ๊ณ ,
๋ฌธ์์ด์ ๊ฒฝ์ฐ์๋ ๋ฆฌํฐ๋ด ์์ ๋ด์ฉ์ด ์๋ ๋น ๋ฌธ์์ด์ ์ฌ์ฉ ํ ์ ์์ต๋๋ค.
char c0 = 'A';
String s0 = "ABC";
char c = '' // error
char c = ' '; // OK
String s = ""; // OK
Tip : ๋ฌธ์์ด์ ๊ฒฝ์ฐ ๋ง์ ์ฐ์ฐ์๋ก ๋ฌธ์์ด์ ๊ฒฐํฉํ ์ ์๋ค.
๋ฌธ์์ด + any Type = ๋ฌธ์์ด + ๋ฌธ์์ด = ๋ฌธ์์ด
any Type + ๋ฌธ์์ด = ๋ฌธ์์ด + ๋ฌธ์์ด = ๋ฌธ์์ด
์ฆ, ๋ฌธ์์ด๊ณผ ๊ฒฐํฉ๋๋ ๊ฒฝ์ฐ ์ด๋ ํ ํ์ ์ด๋ ๋ฌธ์์ด๋ก ์นํ๋จ
<์ฐธ๊ณ ์๋ฃ>
'๐ Backend > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] JVM(Java Virtual Machine)์ ๊ตฌ์กฐ์ ๋์๋ฐฉ์์ ๋ํด (0) | 2023.09.21 |
---|---|
[Java] String ๊ฐ์ฒด์ ๋ถ๋ณ์ฑ(Immutablity)์ ๋ํด (0) | 2023.09.20 |
[Java] Java ์ธ์ด์ ํน์ง, ์ฅ์ ์ ๋ํด (0) | 2023.09.20 |
[Java] ๋๋ค์ - 2. ํจ์ํ ์ธํฐํ์ด์ค์ ๋ํด (0) | 2023.08.13 |
[Java] ๋๋ค์ - 1. ๋๋ค์ ์์ฑ๋ฒ์ ๋ํด (0) | 2023.08.13 |
๋ธ๋ก๊ทธ์ ์ ๋ณด
Study Repository
rlaehddnd0422