๐ง๐ปโ๐ป
ํ์ ์ด ๋ฐ์ดํฐ์ ์ข ๋ฅ๋ผ๋ฉด, ๋ณ์๋ ๋ฐ์ดํฐ์ ์ ์ฅ ๊ณต๊ฐ์ ์๋ฏธ
๋ณ์๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋ฅผ ์ ๋ฆฌํ๋ฉด ํฌ๊ฒ ๋ค์๊ณผ ๊ฐ๋ค.
์๋ฐ ํ๋ก๊ทธ๋จ์ ์ฌ์ ์ ๋น์ ํ๋ฉด, ์ฌ์ ์ ๋ฑ๋ก๋ ๋จ์ด๋ง ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉ ํ ์ ์๋ค.
๋ง์ฝ ์ฌ์ ์ ๋ฑ๋ก๋์ง ์์ ๋จ์ด๋ฅผ ์ฌ์ฉํ๋ ค๊ณ ํ๋ค๋ฉด, ์ง์ ์ฌ์ ์ ๋ฑ๋ก์ ํด์ฃผ์ด์ผ ํ๋ค.
์ด๋ฅผ ๋ณ์๋ฅผ ์ ์ธ
ํ๊ณ ํ ๋น
ํ๋ค๊ณ ํ๋ค.
๋ณ์๋ฅผ ์ ์ธํ๋ ๊ฒ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๊ณต๊ฐ์ ๋ฉ๋ชจ๋ฆฌ์์ ํ๋ณดํ๋ ๊ฒ์ ์๋ฏธ,
๋ณ์์ ๊ฐ์ ํ ๋นํ๋ ๊ฒ์ ์ ์ธ์ ํตํด ํ๋ณดํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ์ ์ ์ฅํ๋ ๊ฒ์ ์๋ฏธ,
int number; // ๋ณ์๋ฅผ ์ ์ธํ๋ค
number = 6; // ์ ์ธํ ๋ณ์์ ๊ฐ์ ํ ๋นํ๋ค.
int number = 6; // ์ ์ธ๊ณผ ํ ๋น์ ๋์์ ํ ์ ์๋ค.
// ์ด์ฒ๋ผ ๋์์ ํ๋ ๊ฒ์ '์ด๊ธฐํ'๋ผ๊ณ ์นญํ๋ค
// ์ฆ, '์ ์ํ ๋ณ์ number๋ฅผ ์ ์ธํ๊ณ , 6์ผ๋ก ์ด๊ธฐํํ๋ค'๋ผ๊ณ ํ ์ ์๋ค.
์ฃผ์ํ ์ , ๋์
์ฐ์ฐ์์ธ '=' ์ด๋ค.
์ํ์์ ๋งํ๋ ๋๋ฑํ๋ค์ ์๋ฏธ๊ฐ ์๋, ์ค๋ฅธ์ชฝ ๊ฐ์ ์ผ์ชฝ์ ์ ์ฅํ๋ผ๋ ์๋ฏธ์ด๋ค.
๋ณ์๋ ๋ง ๊ทธ๋๋ก '๋ณํ๋ ์'์ด๊ธฐ ๋๋ฌธ์ ์ฌํ ๋น์ด ๊ฐ๋ฅํ๋ค.
int number = 6;
System.out.println(number); // 6์ด ์ถ๋ ฅ๋๋ค
number = 9; // number ๋ณ์์ 9๋ฅผ ์ ์ฅํ๋ค.(๊ธฐ์กด ๊ฐ 6์ ์ญ์ )
System.out.println(number); // 9๊ฐ ์ถ๋ ฅ๋๋ค.
๋ณ์๋ช
์ ์๋ฌธ์(๋,์๋ฌธ์)๋ ์ซ์,_๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
์๋ฐ์์ ๋ณ์๋ช
์ ์ผ๋ฐ์ ์ผ๋ก ์นด๋ฉ์ผ์ด์ค(camelCase)๋ฅผ ์ฌ์ฉํ๋ค.
๋ํ ๋ฑ ๋ชจ์์ ๋ฎ์๋ค๊ณ ํด์ ๋ถ์ฌ์ง ์ด๋ฆ์ผ๋ก, ๋ ๋ฒ์งธ ๋จ์ด๋ถํฐ ๋๋ฌธ์๋ก ์์ํด ๊ตฌ๋ถํ๋ค.
int camelCase;
int 10Age; // ์ฌ์ฉ ๋ถ๊ฐ
int byte;
int class;
๋ณ์๋ช
์ ์ฌ์ฉ ๋ชฉ์ ์ ๋ง๊ฒ ์๋ช
ํ๋ ๊ฒ์ด ๋งค์ฐ ์ค์ํ๋ค, ์ ๋์ํ๋ค๊ณ ํด์ ๋ฐ๋์ ์ ์ง ์ฝ๋๋ผ๊ณ ํ ์ ์๋ค.
์ข์ ์ฝ๋๋ ์ ๋์ํ ๋ฟ ์๋๋ผ, ์ฌ๋์๊ฒ๋ ์ ์ฝํ๋ ์ฝ๋๋ฅผ ์๋ฏธํ๋ค.
๐ง๐ปโ๐ซ ์ฝ๊ธฐ ์ข์ ์ฝ๋๋ ์ ์ง์ ๋ณ์๋ช ์์๋ถํฐ ์์๋๋ค.
์์(Constant)๋ ๋ณํ์ง ์๋ ์์ด๋ฉด์, ํ๋ก๊ทธ๋จ์์ ๋ณํ๋ฉด ์๋๋ ์, ์ฆ ๊ณ ์ ๊ฐ์ด๋ค.
์ผ๋ฐ์ ์ผ๋ก ๊ณ ์ ๋ ๊ฐ(ํน์ ์ธ๋ฌผ์ ์๋
์์ผ, ์ฑ๋ณ ๋ฑ)์ด ๋ ์๋ ์๊ณ , ํ๋ก๊ทธ๋๋จธ๊ฐ ์๊ฐํ๊ธฐ์ ๋ณํ์ง ์์์ผ ํ๋ ๊ฐ์ด ๋ ์๋ ์๋ค.
์๋ฅผ ๋ค์ด ๊ณ์ฐ๊ธฐ๋ฅผ ๋ง๋ ๋ค๊ณ ํ ๋ ์์ฃผ์จ์ ๊ฐ, ์ฆ pi(ฯ)๋ฅผ ๊ณฑํ๋ ์ฐ์ฐ์ ํ๋ค๋ฉด ๋งค๋ฒ pi๋ฅผ ์๋ก ์ฐ๊ธฐ๋ณด๋ค๋ ์์๋ก ์ ์ธํด์ ์ฌ์ฉํ๋ ๊ฒ์ด ํจ์จ์ ์ด๋ค.
์ซ์๋ฅผ ์๋ชป ์
๋ ฅํ๋ ์ค์๋ฅผ ๋ฐฉ์งํ๊ณ , ์ฝ๋ ๊ฐ๋
์ฑ์ ๋์ผ ์ ์๊ธฐ ๋๋ฌธ
final double CALCULATOR_PI = 3.14;
์๋ฐ์์ ์์๋ ์ต์ข
์ ์๋ฏธํ๋ final ์์ฝ์ด๋ฅผ ์ฌ์ฉํด ์ ์ธํ๋ค
์์๋ ์ผ๋ฐ์ ์ผ๋ก ๋๋ฌธ์์ ์ธ๋์ค์ฝ์ด(_)๋ฅผ ๋ฃ์ด ๊ตฌ๋ถํ๋ SCREAMING_SNAKE_CASE ๋ฅผ ์ฌ์ฉ
์ฌ์ ์ ์ผ๋ก ๋ฆฌํฐ๋ด(Literal)์ '๋ฌธ์ ๊ทธ๋๋ก์' ๋ผ๋ ๋ป์ ๊ฐ์ง๊ณ ์๋ค.
ํ๋ก๊ทธ๋๋ฐ์์ ๋ฆฌํฐ๋ด์ด๋ ๋ฌธ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ ๊ทธ ์์ฒด ๋ฅผ ์๋ฏธํ๋ค.
๋ฆฌํฐ๋ด์ ๊ฐ๊ณผ ๋์ผํ ๊ฐ๋
์ด ์๋๋ค, ๊ฐ์ ๋ฆฌํฐ๋ด์ด ํ๊ฐ๋์ด ๋ง๋ค์ด์ง ์ผ์ข
์ ๊ฒฐ๊ณผ
์๋ฅผ ๋ค์ด, 50 ์ด๋ผ๋ ์ ์ํ ๋ฆฌํฐ๋ด์ ์ปดํจํฐ ๋ด๋ถ์ 50์ด๋ผ๋ ๊ฐ์ ์์ฑํ๋ค,
// ์ ์ํ ๋ฆฌํฐ๋ด 20์ ์ ์ํ ๋ณ์ currentAge์ ํ ๋น
int currentAge = 20;
// ์ค์ํ ๋ฆฌํฐ๋ด 3.14159๋ฅผ ์ค์ํ ๋ณ์ pi์ ํ ๋น
double pi = 3.14159;
// ๋
ผ๋ฆฌํ ๋ฆฌํฐ๋ด true๋ฅผ ๋
ผ๋ฆฌํ ๋ณ์ boolean์ ํ ๋น
boolean isGenius = true;
// ๋ฌธ์ํ ๋ฆฌํฐ๋ด 'A'๋ฅผ ๋ฌธ์ํ ๋ณ์ firstAlphabet์ ํ ๋น
char firstAlphabet = 'A';
// ๋ฌธ์์ด ๋ฆฌํฐ๋ด "minThug"๋ฅผ ๋ฌธ์์ด ํ์
๋ณ์ learnedAt์ ํ ๋น
String learnedAt = "minThug";
f
๋ฅผ ๋ถ์ฌ์ฃผ์ด์ผ ํ๋ค.L
๋ฅผ ๋ถ์ฌ์ฃผ์ด์ผ ํ๋ค.float weight = 74.5f;
final long LIGHT_YEAR = 9472999314L;
์๋ฐ์์๋ ๋ณ์๋ฅผ ์ ์ธํ ๋ ํ์
์ ๋ช
์ ํด์ค์ผ ํ๋ค๊ณ ํ๋ค.
boolean์ ์ ์ธํ ๊ธฐ๋ณธ ํ์
7๊ฐ๋ ์๋ก ํ์
์ ๋ณํํ ์ ์๋ค.
๋ ๊ฐ์ง ๊ฒฝ์ฐ์๋ ํ์ ์ด ์๋์ผ๋ก ์ ํ๋๋ค.
byte(1) -> short(2)/char(2) -> int(4) -> long(8) -> float(4) -> double(8)
// ๊ดํธ ์์ ์ซ์๋ ๋ฐ์ดํธ์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ธ๋ค.
์์์ float์ 4 ๋ฐ์ดํธ์ธ๋ฐ int์ long๋ณด๋ค ๋ค์ชฝ์ ์์นํ์ต๋๋ค.
์ด์ ๋ float์ด ํํํ ์ ์๋ ๊ฐ์ด ๋ ์ ๋ฐํ๊ธฐ ๋๋ฌธ
long longValue = 12345L;
float floatValue = longValue;
// float์ด long๋ณด๋ค ์ ๋ฐํ๋ฏ๋ก, ์๋์ผ๋ก ํ์
์ด ๋ณํ๋ฉ๋๋ค.
System.out.println(floatValue);
// 12345.0์ด ์ถ๋ ฅ๋ฉ๋๋ค.
๋ฉ๋ชจ๋ฆฌ ์ฉ๋์ด ๋ ํฐ ํ์
์์ ์์ ํ์
์ผ๋ก๋ ์๋์ผ๋ก ํ์
์ด ๋ณํ๋์ง ์๋๋ค.
์ด๋ ๋ ํฐ ๋ฐ์ดํฐ ํ์
์ ์์ ๋ฐ์ดํฐ ํ์
์ ๋ณ์์ ์ ์ฅํ ์ ์๋ค, ์ด๋ฅผ ์บ์คํ
(casting)์ด๋ผ ํ๋ค.
์บ์คํ
์ฐ์ฐ์์ธ ()
๋ฅผ ์ฌ์ฉํ๊ณ , ์ฐ์ฐ์ ์์๋ ๋ณํํ๊ณ ์ ํ๋ ํ์
์ ์ ์ด์ฃผ๋ฉด ๋๋ค.
int intValue = 128;
byte byteValue = (byte)intValue;
//int ํ์
์ผ๋ก ์ ์ธ๋ ๋ณ์ intValue๋ฅผ ๋ ์์ ๋จ์์ธ byte๋ก ๋ณํํฉ๋๋ค.
System.out.println(byteValue);
//์ถ๋ ฅ๊ฐ์ byte์ ์ต๋ ํํ ๊ฐ์ธ 127์ด ์๋๋ผ -128์
๋๋ค.
//ํํ ๋ฒ์๋ฅผ ๋์ผ๋ฉด ํ ๋ฐํด๋ฅผ ๋์ ์์๋ก ์ถ๋ ฅํ๊ธฐ ๋๋ฌธ์
๋๋ค.