Java๋ ๋ํ์ ์ธ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ค.
์๋ฐ์ ํน์ง์ผ๋ก๋
โ ๊ตฌ๋ฌธ์ด ๊ฐ๊ฒฐํ๋ค. ํฌ์ธํฐ ๋ฐ์ดํฐ ํ์์ ์์ฐ์ผ๋ก์จ C++์์ ์ฃผ๋ก ๋ฌธ์ ๋ฅผ ์ผ์ผํค๋ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ฌธ์ ๊ฐ ๋ํญ ํด๊ฒฐ๋์๋ค.
โก๋ช ๋ฃํ ๊ฐ์ฒด์งํฅ ์ธ์ด์ด๋ค.
โข์ด์์ฑ์ด ๋์ผ๋ฉฐ ๊ธฐ๊ณ์ ์ค๋ฆฝ์ ์ด๋ค. ํ๋ฒ ์์ฑํ Java๋ ๋ค์ํ ์ด์์ฒด์ ์์ ๋์ํ๋ค. ์ด๊ฒ์ JVM(Java Virutal Machine)์ด๋ผ๋ ์ํํธ์จ์ด์ ์ํด ๊ฐ๋ฅํ๋ค.
โฃ๋ถ์ฐ ์ฒ๋ฆฌ๋ฅผ ์ง์ํ๋ค.
โค๋ฉํฐ์ค๋ ๋(multi - thread) ์ธ์ด์ด๋ค.
๋ณ์์ ๋ฐ์ดํฐ ํ์
Java์์ ์ฐ์ด๋ ๋ฐ์ดํฐ ํ์ ์ ํฌ๊ฒ ๊ธฐ๋ณธ ํ์ (์์ ํ์ : primitive type)๊ณผ ์ฐธ์กฐ ํ์ (referene type)์ผ๋ก ๋ถ๋ฅ๋๋ค. ๊ธฐ๋ณธํ์ ์ด๋ ์ ์, ์ค์, ๋ฌธ์, ๋ ผ๋ฆฌ ๋ฆฌํฐ๋ด์ ์ ์ฅํ๋ ํ์ ์ ๋งํ๋ค. ์ฐธ์กฐ ํ์ ์ด๋ ๊ฐ์ฒด(Object)์ ๋ฒ์ง๋ฅผ ์ฐธ์กฐํ๋ ํ์ ์ผ๋ก ๋ฐฐ์ด, ์ด๊ฑฐ, ํด๋์ค, ์ธํฐํ์ด์ค ๋ฑ์ ๋งํ๋ค.
java์์ ์ฃผ๋ก ์ฌ์ฉ๋๋ ๋ฐ์ดํฐ ํ์ (๊ธฐ๋ณธ ํ์ + String Class)
๋ฐ์ดํฐ ํ์ | ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ํฌ๊ธฐ | ์ค๋ช | ||
๋ฌธ์ํ | String | ์ฐธ์กฐํ | ๊ธฐ๋ณธ ๋ฐ์ดํฐํ์ด ์๋ ์๋ฐ์์ ์ ๊ณต๋๋ Class์ด๋ค. “ ”๋ฅผ ์ฌ์ฉํ๋ค. | |
char | 2byte | 16bit | ๋ฌธ์ํ์ด ์๋ ์ ์ํ์ด์ง๋ง ๋ฌธ์ 1๊ฐ์ง๋ฅผ ๋ํ๋ผ ๋ ์ฐ์ธ๋ค. ‘ ’๋ฅผ ์ฌ์ฉํ๋ค. | |
์ ์ํ | byte | 1byte | 8bit | -128 ~ 127๊น์ง๋ฅผ ์ ๋ ฅ |
short | 2byte | 16bit | -32768 ~ 32767๊น์ง ์ ๋ ฅ | |
int | 4byte | 32bit | ๊ฐ์ฅ ๋๋ฆฌ ์ฐ์ด๋ ๋ฐ์ดํฐ ํ์ ์ฝ-21์ต ~์ฝ21์ต๊น์ง ์ ๋ ฅ | |
long | 8byte | 64bit | ๋งค์ฐ ํฐ ์ ์๊น์ง ์ ๋ ฅ | |
์ค์ํ | float | 4byte | 32bit | ์์์ ์ด ์๋ ์ค์๋ฅผ ์ ๋ ฅ |
double | 8byte | 64bit | ์ค์๋ฅผ ์ ๋ ฅ float๋ณด๋ค ์ ๋ฐ๋๊ฐ ๋๋ค | |
๋ ผ๋ฆฌํ | boolean | 1byte | 8bit | true ๋๋ false๋ฅผ ์ ๋ ฅ |

byte์ short
- byte : 1๋ฐ์ดํธ ๋จ์์ ์๋ฃํ ๋์์, ์์ ํ์ผ, ์คํ ํ์ผ์ ์๋ฃ๋ฅผ ์ฒ๋ฆฌํ ๋ ์ฌ์ฉ
- short: 2๋ฐ์ดํธ ๋จ์์ ์๋ฃํ C/C++ ์ธ์ด์ ํธํ ์ ์ฌ์ฉ
int
- ์๋ฐ์์ ์ฌ์ฉํ๋ ์ ์์ ๋ํ ๊ธฐ๋ณธ ์๋ฃ ํ
- 4๋ฐ์ดํธ ๋จ์์ ์๋ฃํ
- ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉํ๋ ๋ชจ๋ ์ซ์(๋ฆฌํฐ๋ด)์ int ๋ก ์ ์ฅ๋จ
- 32 ๋นํธ๋ฅผ ์ด๊ณผํ๋ ์ซ์๋ long ์๋ฃํ์ผ๋ก ์ฒ๋ฆฌ
long
- 8๋ฐ์ดํธ ์๋ฃํ
- ์ซ์์ ๋ค์ ์ํ๋ฒณ L ๋๋ l ์ ์จ์ long ํ์์ ํ์ ํจ
- ์) int num = 12345678900; // ์ค๋ฅ
long lnum = 12345678900; //์ค๋ฅ
long lnumber = 12345678900L; // ok
์ค์ ํํ ๋ฐฉ์
- ๋ถ๋ ์์์ ๋ฐฉ์
- ์ค์๋ ์ ์ ๋ณด๋ค ์ ๋ฐํ๊ธฐ ๋๋ฌธ์ ์ ์์๋ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ํํํด์ผ ํจ
- ๋ถ๋ ์์์ ๋ฐฉ์์ผ๋ก ์ค์ ๊ฐ 0.1 ํํ

- ์ง์๋ถ์ ๊ฐ์๋ถ๋ก ํํ ํจ
- ์ปดํจํฐ์์๋ ๋ฐ์๋ฅผ 2๋ก ์ฌ์ฉ
- ์ ๊ทํ : ๊ฐ์๊ฐ ๋ฐ์๋ณด๋ค ์์ ํ ์๋ฆฌ๊น์ง ๊ฐ์๋ก ํํ ๋๋ ๊ฒ
- ์ปดํจํฐ์์๋ ๋ฐ์๊ฐ 2 ์ด๋ฏ๋ก ์ ๊ทํ๋ฅผ ํ๊ฒ ๋๋ฉด ๊ฐ์๋ถ๋ถ์ ์ฒซ ๋ฒ์งธ ์๋ฆฌ ์ซ์๋ ํญ์ 1์
์) 0.2 ํํ 0.4 X 2^-1 ์ ๊ทํ ํ๋ฉด 1.6 X 2^-3 ์ปดํจํฐ์์ ๋ชจ๋ ์ค์๋ 1.mX 2^-n ์ผ๋ก ํํํ๋ค.
- floatํ๊ณผ doubleํ
์๋ฐ์์ ๋ชจ๋ ์ค์ ๋ฆฌํฐ๋ด ๋ค์ dobule๋ก ์ ์ฅ๋์ด ์๋ค.
์๋ฐ์์๋ ์ค์์ ๊ธฐ๋ณธ ํ์ ์ dobule์ ์ฌ์ฉ ํจ

- ๋ถ๋ ์์์ ๋ฐฉ์์ ์ค๋ฅ
์ง์์ ๊ฐ์๋ก ๋ํ๋ด๋ ๋ถ๋ ์์์ ๋ฐฉ์์์๋ ์ง์๋ถ๊ฐ 0์ ํํํ ์ ์๊ธฐ ๋๋ฌธ์ ์ฝ๊ฐ์ ์ค์ฐจ๊ฐ ๋ฐ์ํ ์ ์๋ค
public class DoubleTest2 {
public static void main(String[] args) {
double dnum = 1;
for(int i = 0; i<10000; i++) {
dnum = dnum + 0.1;
}
System.out.println(dnum);
}
}

์๋ฃํ(data type) - ๋ฌธ์๋ ํ๋ก๊ทธ๋จ์์ ์ด๋ป๊ฒ ํํํ์ฌ ์ฌ์ฉํ๋์?
- ๋ฌธ์๋ ์ ์๋ก ํํํฉ๋๋ค.
- ์ด๋ค ๋ฌธ์๋ฅผ ์ปดํจํฐ ๋ด๋ถ์์ ํํํ๊ธฐ ์ํด ํน์ ์ ์ ๊ฐ์ ์ ์
- A ๋ 65

- ๋ฌธ์์ธํธ : ๊ฐ ๋ฌธ์๋ฅผ ์ผ๋ง๋ก ํํํ ๊ฒ์ธ์ง ์ฝ๋ ๊ฐ์ ๋ชจ์๋ ๊ฒ์ ๋ฌธ์์ธํธ(charater set)๋ผ ํจ
(ex. ASKII, euc-kr, utf-8, utf-16)
- ์๋ฐ์์๋ ๋ฌธ์๊ฐ ์ด๋ป๊ฒ ํํ๋๋์?
- ์๋ฐ๋ ๋ฌธ์๋ฅผ ๋ํ๋ด๊ธฐ ์ํด ์ ์ธ๊ณ ํ์ค์ธ UNICODE๋ฅผ ์ฌ์ฉ
- utf-16 ์ธ์ฝ๋ฉ์ ์ฌ์ฉ (๋ชจ๋ ๋ฌธ์๋ฅผ 2๋ฐ์ดํธ๋ก ํ์)
- ๋ฌธ์ํ ๋ณ์ ์ ์ธ๊ณผ ์ฌ์ฉํ๊ธฐ
- ๋ฌธ์๋ฅผ ์ํ ๋ฐ์ดํฐ ํ์ char ch = 'A';
- ๋ฌธ์๋ ' ' ๋ก ํํํ๊ณ " " ๋ก ํํํ๊ฒ ๋๋ฉด ๋ฌธ์์ด์ด ๋๋ค. ์ด๊ฒ์ ์์ฐํ ๋ค๋ฅธ ์๋ฃํ์ด๋ค.
- ๋ด๋ถ์ ์ผ๋ก ์ซ์๋ฃ ํํ๋๋ฏ๋ก ์ซ์๋ฅผ ๋ฃ์ด๋ ๋ฌธ์๊ฐ ์ถ๋ ฅ๋ ์ ์์
- char ch2 = 66;
- ํ์ง๋ง ์์๋ ํํํ ์ ์๋ค.
public class CharacterTest {
public static void main(String[] args) {
char ch1 = 'A';
System.out.println(ch1);
System.out.println((int)ch1);
char ch2 = 66;
System.out.println(ch2);
int ch3 = 67;
System.out.println(ch3);
System.out.println((char)ch3);
//char ch4 = -66; ์์๋ ๋์
ํ ์ ์์
char ch5 = 'ํ';
char ch6 = '\uD55C';
System.out.println(ch5);
System.out.println(ch6);
}
}
์ฐธ๊ณ
character set: ๋ฌธ์๋ฅผ ์ซ์๋ก ๋ณํํ ๊ฐ์ ์ธํธ
encoding: ๋ฌธ์๊ฐ ์ซ์๋ก ๋ณํ๋๋ ๊ฒ
decoding: ์ซ์์์ ๋ค์ ๋ฌธ์๋ก ๋ณํ๋๋ ๊ฒ
ASKII code: ์ํ๋ฒณ๊ณผ ์ซ์ ํน์ ๋ฌธ์๋ฑ์ 1๋ฐ์ดํธ์ ํํํ๋๋ฐ ์ฌ์ฉํ๋ ๋ฌธ์์ธํธ
UNICODE: ์ ์ธ๊ณ ํ์ค์ผ๋ก ๋ง๋ ๋ฌธ์ ์ธํธ
UTF-8: 1๋ฐ์ดํธ์์ 4๋ฐ์ดํธ๊น์ง ๋ค์ํ๊ฒ ๋ฌธ์๋ฅผ ํํํ ์ ์์
UTF-16: 2๋ฐ์ดํธ๋ก ๋ฌธ์๋ฅผ ํํ
int num = 123;
int → ๋ฐ์ดํฐ ํ์ (์ ์ํ์ด๊ณ , 4byte ๊ณต๊ฐ์ ์ ์ฅํ ๊ฑฐ๋ ์๋ฏธ)
num → ์์๋ก ์ง์ ๋ณ์ ์ด๋ฆ ์ผ๋ฐ์ ์ผ๋ก ๋ณด๋ ์ฌ๋์ด ์๊ธฐ ์ฝ๊ฒ ์๋ช ํ๋ ๊ฒ์ด ์ข๋ค.
= → ํ ๋น ์ฐ์ฐ์(๋์ ์ฐ์ฐ์)
123; → ๋ฆฌํฐ๋ด, ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น ํ๊ณ ์ถ์ ์์์ ๊ฐ, ๋๋ ๋ ํญ์ ์ธ๋ฏธ์ฝ๋ก ; ์ ๋ถ์ด์ค์ผ ํ๋ค.
์ฐ์ฐ์
ํ๋ก๊ทธ๋จ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ์ฐ์ถํ๋ ๊ฒ์ ์ฐ์ฐ(operations)์ด๋ผ๊ณ ํ๋ค.์ฐ์ฐ์์ ์ฌ์ฉ๋๋ ํ์๋ ๊ธฐํธ๋ฅผ ์ฐ์ฐ์(operator)๋ผ๊ณ ํ๊ณ , ์ฐ์ฐ๋๋ ๋ฐ์ดํฐ๋ ํผ์ฐ์ฐ์๋ผ๊ณ ํ๋ค. ์ฐ์ฐ์์ ํผ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ์ฐ์ฐ์ ๊ณผ์ ์ ๊ธฐ์ ํ ๊ฒ์ ์ฐ์ฐ์(expressions)์ด๋ผ๊ณ ํ๋ค.
์ฐ์ฐ์ | ์ค๋ช |
+, -, *, /, % | ์ฌ์น์ฐ์ฐ์๋ก /์ % ๋ชจ๋ ๋๋๊ธฐ ์ฐ์ฐ์์ง๋ง /๋ ๋ชซ์ %์ ๋๋จธ์ง ๊ฐ์ ๊ณ์ฐํ๋ค. |
+, - | ๋ถํธ ์ฐ์ฐ์๋ก ๋ณ์, ์,์ ์์ ๋ถ์ผ ์ ์๋ค. |
= | ๋์ (ํ ๋น)์ฐ์ฐ์๋ก ์ค๋ฅธ์ชฝ์ ์ผ์ชฝ์ ๋์ ํ๋ค. |
++, -- | ์ฆ๊ฐ์ฐ์ฐ์๋ก 1์ฉ ์ฆ๊ฐ ๋๋ ๊ฐ์์ํจ๋ค. |
==, !=, <, >, >=, <= | ๋น๊ต ์ฐ์ฐ์๋ก ๊ฒฐ๊ณผ๋ true ๋๋ false์ด๋ฉฐ, if๋ฌธ์ด๋ ๋ฐ๋ณต๋ฌธ์ ์ฃผ๋ก ์ฐ์ธ๋ค. |
&&, || | ๋ ผ๋ฆฌ ์ฐ์ฐ์๋ก and ์ or๋ฅผ ์๋ฏธํ๋ค. |
&, |,^, ~ | ๋นํธ ์ฐ์ฐ์๋ก ๋นํธ ๋จ์๋ก and, or, exclusive or, not ์ฐ์ฐ์ ํ๋ค. |
<<, >> | ์ํํธ ์ฐ์ฐ์๋ก, ๋นํธ ๋จ์๋ก ์ผ์ชฝ ๋๋ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํ๋ค. |
+=,-=,*=, /= | ๋ณตํฉ ๋์ ์ฐ์ฐ์๋ก, 'a+=b' ๋ 'a=a+b'์ ๋์ผํ๋ค. |
(๋ฐ์ดํฐ ํ์) | ์บ์คํธ(cast) ์ฐ์ฐ์๋ก, ๋ฐ์ดํฐ ํ์์ ๊ฐ์ ๋ก ๋ณํํ๋ค. ์๋ฅผ ๋ค์ด int a = (int)3.5๋ doubleํ์ธ 3.5 ๊ฐ์ intํ์ผ๋ก ๊ฐ์ ๋ก ๋ณํํ์ฌ a์ ๋์ ํ๋ค. ๊ฒฐ๊ตญ a์ 3์ด ๋์ ๋๋ค. |
Java์ ์ ์ด๋ฌธ
์ ์ด๋ฌธ | ์ค๋ช | |
์กฐ๊ฑด๋ฌธ | if ๋ฌธ | if-else๋ฌธ , ์ค์ฒฉ if ๋ฌธ ์ผ๋ก ์ธ์ ์๊ณ true๋ฉด ๋ธ๋ก์ ์คํํ๊ณ false๋ฉด else๋ธ๋ก์ด ์คํ๋๋ค. |
switch ๋ฌธ | case๋ฅผ ๋๋์ด ๋ณ์๊ฐ ์ด๋ค ๊ฐ์ ๊ฐ๋๋์ ๋ฐ๋ผ ์คํ๋ฌธ์ด ์ ํ๋๋ค. | |
๋ฐ๋ณต๋ฌธ | for๋ฌธ | ( ; ; );๋ก ์นํฐ๋ฅผ ๋๋๊ณ ๊ฐ ์นํฐ์ boolean ํํ์์ด ๋ค์ด์์ผํ๋ค.(๋น์นธ ์ ์ธ) ์ฒซ๋ฒ์งธ ์นํฐ๋ ์ด๊ธฐํ์, ๋๋ฒ์งธ ์นํฐ๋ ์กฐ๊ฑด์, ์ธ๋ฒ์งธ ์นํฐ๋ ๋๋ถ๋ถ ์ฆ๊ฐ์์ด ์จ๋ค. |
while ๋ฌธ | for๋ฌธ์ด ์ ํ์ง ํ์๋งํผ ๋ฐ๋ณต์ด๋ผ๋ฉด, while๋ฌธ์ ์กฐ๊ฑด์์ด true์ผ ๊ฒฝ์ฐ์ ๊ณ์ ๋ฐ๋ณตํ๋ค. do-while๋ฌธ์ ์กฐ๊ฑด์์ ๋จผ์ ๊ฒ์ฌํ๊ณ ๋ธ๋ก ๋ด๋ถ๋ฅผ ์คํํ ์ง ๊ฒฐ์ ํ๋๊ฒ ์๋, ์คํ๋ฌธ์ ์ฐ์ ์คํ ์ํค๊ณ ์คํ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ์ ๋ฐ๋ณต ์คํ์ ๊ณ์ํ ์ง ๊ฒฐ์ ํ๋ค. |
|
๊ทธ ์ธ | break ๋ฌธ์ ๋ฐ๋ณต๋ฌธ์ ์คํ ์ค์งํ ๋ ์ด์ฉํ๋ค. ๋ํ ์ด์ ์ ํ์ตํ switch ๋ฌธ์์๋ ์คํ๋ฌธ์ ์ข
๋ฃ์ํฌ์ ์๋ค. continue ๋ฌธ์ ๋ฐ๋ณต๋ฌธ์๋ง ์ฌ์ฉ๋๋ฉฐ, continue ๋ฌธ์ด ์คํ๋๋ฉด for๋ฌธ์ ์ฆ๊ฐ์ ๋๋ while, do-while๋ฌธ์ ์กฐ๊ฑด์์ผ๋ก ์ด๋ํ๋ค. |
java์ ์ ์ด๋ฌธ ์ข ๋ฅ๋ ํฌ๊ฒ ์กฐ๊ฑด๋ฌธ(๋ถ๊ธฐ๋ฌธ)๊ณผ ๋ฐ๋ณต๋ฌธ์ด ์๋ค. ์กฐ๊ฑด๋ฌธ์๋ if๋ฌธ, switch๋ฌธ์ด ์๊ณ ,์กฐ๊ฑด์์๋ true ๋๋ false ๊ฐ์ ์ฐ์ถํ ์ ์๋ ์ฐ์ฐ์์ด๋, boolean ๋ณ์๊ฐ ์ฌ ์ ์๋ค. ์กฐ๊ฑด์์ด true๋ฉด ๋ธ๋ก(์คํ๋ฌธ)์ ์คํํ๊ณ , false๋ฉด ๋ธ๋ก์ ์คํ ํ์ง ์๋๋ค. ๋ฐ๋ณต๋ฌธ์ for๋ฌธ, while๋ฌธ, do-while๋ฌธ์ด ์๋ค. ์ ์ด๋ฌธ ๋ธ๋ก์ด ์คํ ์๋ฃ๋์์ ๊ฒฝ์ฐ ๋ค์ ์ ์ด๋ฌธ ์ฒ์์ผ๋ก ๋์๊ฐ์ง, ์๋๋ฉด ์ ์ด๋ฌธ ๋ธ๋ก์ ๋น ์ ธ๋์ ์ ์ํ๋ฆ์ผ๋ก ๋ค์ ๋์์ฌ์ง๋ ์ด๋ค ์ ์ด๋ฌธ์ ์ฌ์ฉํ๋์ ๋ฐ๋ผ ๋ฌ๋ ค์๋ค.
์กฐ๊ฑด๋ฌธ์ผ ๊ฒฝ์ฐ๋ ์ ์ํ๋ฆ์ผ๋ก ๋์์ค์ง๋ง, ๋ฐ๋ณต๋ฌธ์ผ ๊ฒฝ์ฐ๋ ์ ์ด๋ฌธ ์ฒ์์ผ๋ก ๋ค์ ๋๋์๊ฐ ๋ฐ๋ณต ์คํํ๋ค. ์ด๋ฅผ ๋ฃจํ(looping)์ด๋ผ๊ณ ํ๋ค.
์ฐธ์กฐ ํ์
๊ธฐ๋ณธ ํ์ ์ผ๋ก ์ ์ธ๋ ๋ณ์์ ์ฐธ์กฐ ํ์ ์ผ๋ก ์ ์ธ๋ ๋ณ์์ ์ฐจ์ด์ ์ ์ ์ฅ๋๋ ๊ฐ์ด ๋ฌด์์ด๋์ด๋ค. ๊ธฐ๋ณธ ํ์ ์ ์ด์ฉํด์ ์ ์ธ๋ ๋ณ์๋ ์ค์ ๊ฐ์ ๋ณ์์์ ์ ์ฅํ์ง๋ง, ์ฐธ์กฐ ํ์ ์ธ ๋ฐฐ์ด, ์ด๊ฑฐ, ํด๋์ค, ์ธํฐํ์ด์ค๋ฅผ ์ด์ฉํด์ ์ ์ธ๋ ๋ณ์๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ฒ์ง(์ฃผ์)๋ฅผ ๊ฐ์ผ๋ก ๊ฐ๋๋ค. ๋ฒ์ง๋ฅผ ํตํด ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ค๋ ๋ป์์ ์ฐธ์กฐํ์ ์ด๋ผ ๋ถ๋ฅธ๋ค. ๋ณ์๋ ์คํ์์ญ์ ์์ฑ๋๊ณ ๊ฐ์ฒด๋ ํ์์ญ์ ์์ฑ๋๋ค.
String ํ์
์๋ฐ์์ ๋ฌธ์์ด์ String ๊ฐ์ฒด๋ก ์์ฑ๋๊ณ ๋ณ์๋ String ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ค. ํ์ง๋ง ์ผ๋ฐ์ ์ผ๋ก ํํํ ๋ String ๋ณ์์ ์ ์ฅํ๋ค๋ ๋ง์ ์ฌ์ฉํ๋ค. ๋ง์ฝ ๋๊ฐ์ง ๋ค๋ฅธ ๋ณ์๊ฐ ๋์ผํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ฐธ์กฐํ ๊ฒฝ์ฐ๋ ๊ฐ์ String ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๋ค.
String name1 = "ํ๊ธธ๋";
String name2 = "ํ๊ธธ๋";
String name3 = new String("ํ๊ธธ๋");
name1๊ณผ name2๋ ๋์ผํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด๋ก ์์ฑ๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ธฐ ๋๋ฌธ์ name1==name2์ ๊ฒฐ๊ณผ๋ true๊ฐ์ด ๋์จ๋ค. ๊ทธ๋ฌ๋ name3๋ new ์ฐ์ฐ์๋ก String ๊ฐ์ฒด๋ฅผ ๋ณ๋๋ก ์์ฑํ๊ธฐ ๋๋ฌธ์ name1==name3์ ๊ฒฐ๊ณผ๋ false๊ฐ ๋์จ๋ค. ๋์ผํ String ๊ฐ์ฒด์ด๋ ๋ค๋ฅธ String๊ฐ์ฒด์ด๋ ์๊ด์์ด ๋ฌธ์์ด๋ง์ ๋น๊ตํ ๋์๋ String ๊ฐ์ฒด์ .equals()๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผํ๋ค. .equals()๋ฉ์๋๋ ์ฐ๋๋ณธ ๋ฌธ์์ด๊ณผ ๋งค๊ฐ๊ฐ์ผ๋ก ์ฃผ์ด์ง ๋น๊ต ๋ฌธ์์ด์ด ๋์ผํ์ง ๋น๊ตํ ํ true ๋๋ false๋ฅผ ๋ฆฌํดํ๋ค.
๋๊ธ