1. ํƒ€์ž…์บ์ŠคํŒ…

์ž๋ฐ”์˜ ํƒ€์ž…์บ์ŠคํŒ…

๊ธฐ๋ณธ ์œ ํ˜•์˜ ๋ณ€์ˆ˜(์œ ํ˜• ์ œ์™ธ boolean)๋Š” ๋‹ค์–‘ํ•œ ์œ ํ˜•์˜ ์ˆซ์ž๋ฅผ ์ €์žฅํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๋ณ€์ˆ˜์˜ ์œ ํ˜•์€ ์ ˆ๋Œ€ ๋ณ€๊ฒฝ๋˜์ง€ ์•Š์ง€๋งŒ ํ•œ ์œ ํ˜•์—์„œ ๋‹ค๋ฅธ ์œ ํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ๋Š” ๊ณณ์ด ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ทธ ์žฅ์†Œ๋Š” ํ• ๋‹น ์ž…๋‹ˆ๋‹ค .

์„œ๋กœ ๋‹ค๋ฅธ ์œ ํ˜•์˜ ๋ณ€์ˆ˜๋ฅผ ์„œ๋กœ ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ํ•œ ์œ ํ˜•์˜ ๋ณ€์ˆ˜ ๊ฐ’์ด ๋‹ค๋ฅธ ์œ ํ˜•์˜ ๊ฐ’์œผ๋กœ ๋ณ€ํ™˜๋˜์–ด ๋‘ ๋ฒˆ์งธ ๋ณ€์ˆ˜์— ํ• ๋‹น๋ฉ๋‹ˆ๋‹ค. ์ด์™€ ๊ด€๋ จํ•˜์—ฌ ๋‘ ์ข…๋ฅ˜์˜ ์œ ํ˜• ๋ณ€ํ™˜์„ ์‹๋ณ„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ™•๋Œ€ ๋ฐ ์ถ•์†Œ์ž…๋‹ˆ๋‹ค.

ํ™•๋Œ€๋Š” ์ž‘์€ ๋ฐ”๊ตฌ๋‹ˆ์—์„œ ํฐ ๋ฐ”๊ตฌ๋‹ˆ๋กœ ๊ฐ’์„ ์ด๋™ํ•˜๋Š” ๊ฒƒ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์ด ์ž‘์—…์€ ๋งค๋„๋Ÿฝ๊ณ  ๊ณ ํ†ต์ด ์—†์Šต๋‹ˆ๋‹ค. ์ถ•์†Œ๋Š” ํฐ ๋ฐ”๊ตฌ๋‹ˆ์—์„œ ์ž‘์€ ๋ฐ”๊ตฌ๋‹ˆ๋กœ ๊ฐ’์„ ์ด๋™ํ•  ๋•Œ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค. ๊ณต๊ฐ„์ด ์ถฉ๋ถ„ํ•˜์ง€ ์•Š์„ ์ˆ˜ ์žˆ์œผ๋ฉฐ ๋ฌด์–ธ๊ฐ€๋ฅผ ๋ฒ„๋ ค์•ผ ํ•ฉ๋‹ˆ๋‹ค.

๋‹ค์Œ์€ ๋ฐ”๊ตฌ๋‹ˆ ํฌ๊ธฐ๋ณ„๋กœ ์ •๋ ฌ๋œ ์œ ํ˜•์ž…๋‹ˆ๋‹ค.

์ž๋ฐ” 2์˜ ํƒ€์ž…์บ์ŠคํŒ…


2. ์œ ํ˜• ๋ณ€ํ™˜ ํ™•๋Œ€

ํ•œ ์ˆซ์ž ์œ ํ˜•์˜ ๋ณ€์ˆ˜๋ฅผ ๋‹ค๋ฅธ ์ˆซ์ž ์œ ํ˜•์˜ ๋ณ€์ˆ˜์— ํ• ๋‹นํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์ข…์ข… ์žˆ์Šต๋‹ˆ๋‹ค. ์–ด๋–ป๊ฒŒ ํ•ฉ๋‹ˆ๊นŒ?

Java์—๋Š” 4๊ฐ€์ง€ ์ •์ˆ˜ ์œ ํ˜•์ด ์žˆ์Šต๋‹ˆ๋‹ค.

์œ ํ˜• ํฌ๊ธฐ
byte 1 byte
short 2 bytes
int 4 bytes
long 8 bytes

๋” ์ž‘์€ ๋ฐ”์Šค์ผ“์— ์ €์žฅ๋œ ๋ณ€์ˆ˜๋Š” ํ•ญ์ƒ ๋” ํฐ ๋ฐ”์Šค์ผ“์— ์ €์žฅ๋œ ๋ณ€์ˆ˜์— ํ• ๋‹น๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

int, short๋ณ€์ˆ˜ ๋ฅผ ๋ณ€์ˆ˜ byte์— ์‰ฝ๊ฒŒ ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค long. short๊ทธ๋ฆฌ๊ณ  byte๋ณ€์ˆ˜๋Š” ๋ณ€์ˆ˜์— ํ• ๋‹น๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค int. ๊ทธ๋ฆฌ๊ณ  byte๋ณ€์ˆ˜๋Š” ๋ณ€์ˆ˜์— ํ• ๋‹น๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค short.

์˜ˆ:

์•”ํ˜ธ ์„ค๋ช…
byte a = 5;
short b = a;
int c = a + b;
long d = c * c;
์ด ์ฝ”๋“œ๋Š” ์ž˜ ์ปดํŒŒ์ผ๋ฉ๋‹ˆ๋‹ค.

๋” ์ž‘์€ ์œ ํ˜•์—์„œ ๋” ํฐ ์œ ํ˜•์œผ๋กœ์˜ ์ด๋Ÿฌํ•œ ๋ณ€ํ™˜์„ ํ™•์žฅ ์œ ํ˜• ๋ณ€ํ™˜์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

์‹ค์ˆ˜๋Š” ์–ด๋–ป์Šต๋‹ˆ๊นŒ?

๋ชจ๋“  ๊ฒƒ์ด ๋™์ผํ•ฉ๋‹ˆ๋‹ค. ํฌ๊ธฐ๊ฐ€ ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค.

์œ ํ˜• ํฌ๊ธฐ
float 4 bytes
double 8 bytes

floatdouble์•„๋ฌด๋Ÿฐ ๋ฌธ์ œ ์—†์ด ๋ณ€์ˆ˜ ์— ๋ณ€์ˆ˜๋ฅผ ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . ๊ทธ๋Ÿฌ๋‚˜ ์ •์ˆ˜ ์œ ํ˜•์ด ๋” ํฅ๋ฏธ๋กญ์Šต๋‹ˆ๋‹ค.

๋ชจ๋“  ์ •์ˆ˜ ๋ณ€์ˆ˜๋ฅผ float๋ณ€์ˆ˜์— ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. long๊ธธ์ด๊ฐ€ 8๋ฐ”์ดํŠธ์ธ ์œ ํ˜• ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค . ๊ทธ๋ฆฌ๊ณ  ๋ณ€์ˆ˜์— ์›ํ•˜๋Š” ๋ชจ๋“  ๋ณ€์ˆ˜(์ •์ˆ˜ ๋ณ€์ˆ˜ ๋˜๋Š” float๋ณ€์ˆ˜) ๋ฅผ ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค double.

์•”ํ˜ธ ๋ฉ”๋ชจ
long a = 1234567890;
float b = a;
double c = a;

b == 1.23456794E9
c == 1.23456789E9

์‹ค์ œ ์œ ํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋ฉด ์œ ํšจ ์ž๋ฆฟ์ˆ˜๊ฐ€ ์ถฉ๋ถ„ํ•˜์ง€ ์•Š์•„ ์ •๋ฐ€๋„๊ฐ€ ์†์‹ค๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ •์ˆ˜์—์„œ ๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆซ์ž๋กœ ๋ณ€ํ™˜ํ•  ๋•Œ ์ˆซ์ž์˜ ํ•˜์œ„ ๋ถ€๋ถ„์€ ๋ฒ„๋ ค์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋ถ„์ˆ˜๋Š” ๋Œ€๋žต์ ์ธ ๊ฐ’์„ ์ €์žฅํ•˜๋Š” ๊ฒƒ์œผ๋กœ ์ดํ•ด๋˜๋ฏ€๋กœ ์ด๋Ÿฌํ•œ ํ• ๋‹น ์—ฐ์‚ฐ์ด ํ—ˆ์šฉ๋ฉ๋‹ˆ๋‹ค.


3. ์œ ํ˜• ๋ณ€ํ™˜ ์ถ•์†Œ

๋‹ค๋ฅธ ๊ฐ€๋Šฅ์„ฑ์€ ์–ด๋–ป์Šต๋‹ˆ๊นŒ? long๋ณ€์ˆ˜ ์— ๊ฐ’์„ ํ• ๋‹นํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ํ•ฉ๋‹ˆ๊นŒ int?

๋ณ€์ˆ˜๋ฅผ ๋ฐ”๊ตฌ๋‹ˆ๋กœ ์ƒ์ƒํ•ด ๋ณด์‹ญ์‹œ์˜ค. 1, 2, 4, 8๋ฐ”์ดํŠธ ๋“ฑ ๋‹ค์–‘ํ•œ ํฌ๊ธฐ์˜ ๋ฐ”์Šค์ผ“์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์ž‘์€ ๋ฐ”๊ตฌ๋‹ˆ์—์„œ ํฐ ๋ฐ”๊ตฌ๋‹ˆ๋กœ ์‚ฌ๊ณผ๋ฅผ ์˜ฎ๊ธฐ๋Š” ๊ฒƒ์€ ๋ฌธ์ œ๊ฐ€ ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ํฐ ๋ฐ”๊ตฌ๋‹ˆ์—์„œ ์ž‘์€ ๋ฐ”๊ตฌ๋‹ˆ๋กœ ์ด๋™ํ•  ๋•Œ ์ผ๋ถ€ ์‚ฌ๊ณผ๊ฐ€ ์†์‹ค๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋” ํฐ ์œ ํ˜•์—์„œ ๋” ์ž‘์€ ์œ ํ˜•์œผ๋กœ์˜ ์ด๋Ÿฌํ•œ ๋ณ€ํ™˜์„ ์ถ•์†Œ ์œ ํ˜• ๋ณ€ํ™˜ ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค . ์ด์™€ ๊ฐ™์€ ํ• ๋‹น ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ๋•Œ ์ˆซ์ž์˜ ์ผ๋ถ€๊ฐ€ ์ƒˆ ๋ณ€์ˆ˜์— ๋งž์ง€ ์•Š์„ ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ํ๊ธฐ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์œ ํ˜•์„ ์ขํž ๋•Œ ์šฐ๋ฆฌ๋Š” ์ปดํŒŒ์ผ๋Ÿฌ์—๊ฒŒ ์šฐ๋ฆฌ๊ฐ€ ์‹ค์ˆ˜๋ฅผ ํ•˜๊ณ  ์žˆ๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ฉฐ ์˜๋„์ ์œผ๋กœ ์ˆซ์ž์˜ ์ผ๋ถ€๋ฅผ ๋ฒ„๋ฆฌ๊ณ  ์žˆ์Œ์„ ๋ช…์‹œ์ ์œผ๋กœ ์•Œ๋ ค์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ฅผ ์œ„ํ•ด typecast ์—ฐ์‚ฐ์ž๊ฐ€ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๊ด„ํ˜ธ ์•ˆ์˜ ์œ ํ˜• ์ด๋ฆ„ ์ž…๋‹ˆ๋‹ค .

์ด๋Ÿฌํ•œ ์ƒํ™ฉ์—์„œ Java ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ typecast ์—ฐ์‚ฐ์ž๋ฅผ ์ง€์ •ํ•˜๋„๋ก ์š”๊ตฌํ•ฉ๋‹ˆ๋‹ค. ์ผ๋ฐ˜์ ์œผ๋กœ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

(type) expression

์˜ˆ:

์•”ํ˜ธ ์„ค๋ช…
long a = 1;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;
typecast ์—ฐ์‚ฐ์ž๋ฅผ ๋ช…์‹œ์ ์œผ๋กœ ์ง€์ •ํ•ด์•ผ ํ•  ๋•Œ๋งˆ๋‹ค

์—ฌ๊ธฐ์„œ๋Š” a์™€ ๊ฐ™์œผ๋ฉฐ 1์•„๋งˆ๋„ typecast ์—ฐ์‚ฐ์ž๋Š” ๊ณผ์ž‰์ฒ˜๋Ÿผ ๋ณด์ผ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ a๋” ํฌ๋ฉด ์–ด๋–จ๊นŒ์š”?

์•”ํ˜ธ ์„ค๋ช…
long a = 1000000;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;
a == 1000000
b == 1000000
c == 16960
d == 64

๋ฐฑ๋งŒ์€ long์™€ ์— ์™„๋ฒฝํ•˜๊ฒŒ ๋งž์Šต๋‹ˆ๋‹ค int. ๊ทธ๋Ÿฌ๋‚˜ ๋ณ€์ˆ˜์— 100๋งŒ ๊ฐœ๋ฅผ ํ• ๋‹นํ•  ๋•Œ short์ฒ˜์Œ 2๋ฐ”์ดํŠธ๋Š” ๋ฒ„๋ฆฌ๊ณ  ๋งˆ์ง€๋ง‰ 2๋ฐ”์ดํŠธ๋งŒ ์œ ์ง€๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์— ํ• ๋‹นํ•  ๋•Œ byte๋งˆ์ง€๋ง‰ ๋ฐ”์ดํŠธ๋งŒ ๋‚จ์Šต๋‹ˆ๋‹ค.

์ˆซ์ž๊ฐ€ ๋ฉ”๋ชจ๋ฆฌ์— ๋ฐฐ์—ด๋˜๋Š” ๋ฐฉ์‹:

์œ ํ˜• ์ด์ง„ ํ‘œ๊ธฐ๋ฒ• ์‹ญ์ง„๋ฒ•
int 0b 00000000 00001111 01000010 01000000 1000000
short 0b 01000010 01000000 16.960
byte 0b 01000000 64

char์œ ํ˜•

A ๋Š” chara ์ฒ˜๋Ÿผ short2๋ฐ”์ดํŠธ๋ฅผ ์ฐจ์ง€ํ•˜์ง€๋งŒ ํ•˜๋‚˜๋ฅผ ๋‹ค๋ฅธ ๊ฒƒ์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด ํ•ญ์ƒ typecast ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ ๋ฌธ์ œ๋Š” short์œ ํ˜•์ด ๋ถ€ํ˜ธ ์žˆ๊ณ  ์—์„œ -32,768๊นŒ์ง€ ์˜ ๊ฐ’์„ ํฌํ•จํ•  ์ˆ˜ +32,767์žˆ์ง€๋งŒ ์œ ํ˜•์ด ๋ถ€ํ˜ธ๊ฐ€ ์—†๊ณ  ์—์„œ ๊นŒ์ง€์˜ char๊ฐ’์„ ํฌํ•จํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค .065,535

์Œ์ˆ˜๋Š” ์— ์ €์žฅํ•  ์ˆ˜ ์—†์ง€๋งŒ char์—๋Š” ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค short. ๊ทธ๋ฆฌ๊ณ  a๋Š” short๋ณด๋‹ค ํฐ ์ˆซ์ž๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์—†์ง€๋งŒ 32,767์ด๋Ÿฌํ•œ ์ˆซ์ž๋Š” a์— ์ €์žฅํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค char.


4. ํ‘œํ˜„์˜ ์ข…๋ฅ˜

๋‹ค๋ฅธ ์œ ํ˜•์˜ ๋ณ€์ˆ˜๊ฐ€ ๋™์ผํ•œ ํ‘œํ˜„์‹์— ์‚ฌ์šฉ๋˜๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ์š”? ๋…ผ๋ฆฌ์ ์œผ๋กœ ๋จผ์ € ๊ณตํ†ต ์œ ํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•ด์•ผ ํ•œ๋‹ค๋Š” ๊ฒƒ์„ ์ดํ•ดํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์–ด๋Š ๊ฒƒ?

๋ฌผ๋ก  ๋” ํฐ ์‚ฌ๋žŒ์—๊ฒŒ.

Java๋Š” ํ•ญ์ƒ ๋” ํฐ ์œ ํ˜•์œผ๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค. ๋Œ€๋žต์ ์œผ๋กœ ๋งํ•˜๋ฉด ๋จผ์ € ์œ ํ˜• ์ค‘ ํ•˜๋‚˜๋ฅผ ํ™•์žฅํ•œ ๋‹ค์Œ ๋™์ผํ•œ ์œ ํ˜•์˜ ๊ฐ’์„ ์‚ฌ์šฉํ•˜์—ฌ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.

an int๊ณผ a๊ฐ€ long์‹์— ํฌํ•จ๋œ ๊ฒฝ์šฐ the์˜ ๊ฐ’์ด inta๋กœ ๋ณ€ํ™˜๋œ long๋‹ค์Œ์—๋งŒ ์ž‘์—…์ด ์ง„ํ–‰๋ฉ๋‹ˆ๋‹ค.

์•”ํ˜ธ ์„ค๋ช…
int a = 1;
long b = 2;
long c = a + b;
a๊ฐ€ a๋กœ ํ™•์žฅ๋˜๊ณ  long์ถ”๊ฐ€๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆซ์ž

์ •์ˆ˜์™€ ๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆซ์ž( float๋˜๋Š” double)๊ฐ€ ํ‘œํ˜„์‹์— ํฌํ•จ๋œ ๊ฒฝ์šฐ ์ •์ˆ˜๋Š” ๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆซ์ž( float๋˜๋Š” double)๋กœ ๋ณ€ํ™˜๋œ ๋‹ค์Œ์—๋งŒ ์—ฐ์‚ฐ์ด ์ˆ˜ํ–‰๋ฉ๋‹ˆ๋‹ค.

์ž‘์—…์— a float๋ฐ a ๊ฐ€ ํฌํ•จ๋œ double๊ฒฝ์šฐ float๊ฐ€ ๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค double. ์‹ค์ œ๋กœ ์˜ˆ์ƒ๋ฉ๋‹ˆ๋‹ค.

๋†€๋ผ๋‹ค

, ๋ฐ ์œ ํ˜•์€ ์„œ๋กœ ์ƒํ˜ธ ์ž‘์šฉํ•  ๋•Œ byteํ•ญ์ƒ ๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค . ์œ ํ˜•์ด ํ‘œ์ค€ ์ •์ˆ˜ ์œ ํ˜•์œผ๋กœ ๊ฐ„์ฃผ๋˜๋Š” ๋ฐ์—๋Š” ํƒ€๋‹นํ•œ ์ด์œ ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค .shortcharintint

bytea์— a๋ฅผ ๊ณฑํ•˜๋ฉด short๊ฐ€ ๋ฉ๋‹ˆ๋‹ค int. bytea์— a๋ฅผ ๊ณฑํ•˜๋ฉด byte๊ฐ€ ๋ฉ๋‹ˆ๋‹ค int. bytea ์™€ a๋ฅผ ๋”ํ•ด๋„ ๊ฐ€ byte๋ฉ๋‹ˆ๋‹ค int.

์ด์— ๋Œ€ํ•œ ๋ช‡ ๊ฐ€์ง€ ์ด์œ ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ:

์•”ํ˜ธ ์„ค๋ช…
byte a = 110;
byte b = 120;
byte c = a * b;  // Error
110 * 120is 13,200์ด๋ฉฐ ๋‹ค์Œ ์œ ํ˜•์˜ ์ตœ๋Œ€๊ฐ’๋ณด๋‹ค ์•ฝ๊ฐ„ ํฝ๋‹ˆ๋‹ค byte.127
byte a = 110;
byte b = 120;
byte c = a + b; // Error
110 + 120is 230์ด๋ฉฐ ๋‹ค์Œ ์œ ํ˜•์˜ ์ตœ๋Œ€๊ฐ’๋ณด๋‹ค ์•ฝ๊ฐ„ ํฝ๋‹ˆ๋‹ค byte.127

์ผ๋ฐ˜์ ์œผ๋กœ 8๋น„ํŠธ(1๋ฐ”์ดํŠธ) ์ˆซ์ž์™€ 8๋น„ํŠธ(1๋ฐ”์ดํŠธ) ์ˆซ์ž๋ฅผ ๊ณฑํ•˜๋ฉด 16๋น„ํŠธ(2๋ฐ”์ดํŠธ)๋ฅผ ์ฐจ์ง€ํ•˜๋Š” ์ˆซ์ž๊ฐ€ ๋‚˜์˜ต๋‹ˆ๋‹ค.

๊ฒฐ๊ณผ์ ์œผ๋กœ ๋ณด๋‹ค ์ž‘์€ ์ •์ˆ˜ ์œ ํ˜•์˜ ๋ชจ๋“  ์—ฐ์‚ฐ์€ intํ•ญ์ƒ ์ฆ‰์‹œ ints๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค. ์ฆ‰, ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋‹ค ์ž‘์€ ์œ ํ˜•์˜ ๋ณ€์ˆ˜์— ์ €์žฅํ•˜๋ ค๋ฉด intํ•ญ์ƒ ์œ ํ˜• ๋ณ€ํ™˜ ์—ฐ์‚ฐ์ž๋ฅผ ๋ช…์‹œ์ ์œผ๋กœ ์ง€์ •ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

์˜ˆ:

์•”ํ˜ธ ์„ค๋ช…
byte a = 110;
byte b = 120;
byte c = (byte) (a * b);
ํ‘œํ˜„ byte * byte์€int
byte a = 110;
byte b = 120;
byte c = (byte) (a + b);
ํ‘œํ˜„ byte + byte์€int
byte a = 1;
byte b = (byte) (a + 1);
ํ‘œํ˜„์‹ byte + int์€ ์ž…๋‹ˆ๋‹ค. int
๋ฆฌํ„ฐ๋Ÿด์€ ์ž…๋‹ˆ๋‹ค int.

5. ์ค‘์š”ํ•œ ๋‰˜์•™์Šค

typecast ์—ฐ์‚ฐ์ž๋Š” ์ƒ๋‹นํžˆ ๋†’์€ ์šฐ์„  ์ˆœ์œ„๋ฅผ ๊ฐ–์Šต๋‹ˆ๋‹ค.

์ฆ‰, ์˜ˆ๋ฅผ ๋“ค์–ด ์‹์— ์ถ”๊ฐ€ ๋ฐ typecast ์—ฐ์‚ฐ์ž๊ฐ€ ํฌํ•จ๋œ ๊ฒฝ์šฐ typecast๋Š” ์ถ”๊ฐ€ ์ „์— ์ˆ˜ํ–‰๋ฉ๋‹ˆ๋‹ค.

์˜ˆ:

์•”ํ˜ธ ์„ค๋ช…
byte a = 1;
byte b = 2;
byte c = (byte) a * b;
typecast ์—ฐ์‚ฐ์ž๋Š” a์ด๋ฏธ byte. ์ด ์ฝ”๋“œ๋Š” ์ปดํŒŒ์ผ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
byte a = 1;
byte b = 2;
byte c = (byte) (a * b);
์ด๊ฒƒ์ด ์˜ฌ๋ฐ”๋ฅธ ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

ํ‘œํ˜„์‹์˜ ํ•œ ๊ตฌ์„ฑ ์š”์†Œ๊ฐ€ ์•„๋‹ˆ๋ผ ์ „์ฒด ํ‘œํ˜„์‹์„ ํŠน์ • ์œ ํ˜•์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด ์ „์ฒด ํ‘œํ˜„์‹์„ ๊ด„ํ˜ธ๋กœ ๋ฌถ๊ณ  typecast ์—ฐ์‚ฐ์ž๋ฅผ ์•ž์— ๋‘์‹ญ์‹œ์˜ค.