๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“– Java/๐Ÿ’Š Java ๊ฐ•์˜

Java ์ž…๋ฌธ ๊ฐ•์˜_์Šค์ฝ”ํ”„, ํ˜•๋ณ€ํ™˜

by carrot0911 2024. 11. 1.

์Šค์ฝ”ํ”„1 - ์ง€์—ญ ๋ณ€์ˆ˜์™€ ์Šค์ฝ”ํ”„

๋ณ€์ˆ˜๋Š” ์„ ์–ธํ•œ ์œ„์น˜์— ๋”ฐ๋ผ ์ง€์—ญ ๋ณ€์ˆ˜, ๋ฉค๋ฒ„ ๋ณ€์ˆ˜(ํด๋ž˜์Šค ๋ณ€์ˆ˜, ์ธ์Šคํ„ด์Šค ๋ณ€์ˆ˜)์™€ ๊ฐ™์ด ๋ถ„๋ฅ˜๋œ๋‹ค.
์ง€๊ธˆ๊นŒ์ง€ ํ•™์Šตํ•œ ๋ณ€์ˆ˜๋“ค์€ ๋ชจ๋‘ ์˜์–ด๋กœ ๋กœ์ปฌ ๋ณ€์ˆ˜(Local Variable) ํ•œ๊ธ€๋กœ ์ง€์—ญ ๋ณ€์ˆ˜๋ผ ํ•œ๋‹ค.

์ง€์—ญ ๋ณ€์ˆ˜๋Š” ์ด๋ฆ„ ๊ทธ๋Œ€๋กœ ํŠน์ • ์ง€์—ญ์—์„œ๋งŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋ณ€์ˆ˜๋ผ๋Š” ๋œป์ด๋‹ค. ํŠน์ • ์ง€์—ญ์„ ๋ฒ—์–ด๋‚˜๋ฉด ์‚ฌ์šฉํ•  ์ˆ˜ ์—†๋‹ค.
์—ฌ๊ธฐ์„œ ๋งํ•˜๋Š” ์ง€์—ญ์ด ๋ฐ”๋กœ ๋ณ€์ˆ˜๊ฐ€ ์„ ์–ธ๋œ ์ฝ”๋“œ ๋ธ”๋ก( { } )์ด๋‹ค. ์ง€์—ญ ๋ณ€์ˆ˜๋Š” ์ž์‹ ์ด ์„ ์–ธ๋œ ์ฝ”๋“œ ๋ธ”๋ก ( { } ) ์•ˆ์—์„œ๋งŒ ์ƒ์กดํ•˜๊ณ , ์ž์‹ ์ด ์„ ์–ธ๋œ ์ฝ”๋“œ ๋ธ”๋ก์„ ๋ฒ—์–ด๋‚˜๋ฉด ์ œ๊ฑฐ๋œ๋‹ค.
๋”ฐ๋ผ์„œ ์ดํ›„์—๋Š” ์ ‘๊ทผํ•  ์ˆ˜ ์—†๋‹ค ๐Ÿฅฒ๐Ÿฅฒ

Scope1

package scope;

public class Scope1 {

    public static void main(String[] args) {
        int m = 10;  //m ์ƒ์กด ์‹œ์ž‘

        if (true) {
            int x = 20;  //x ์ƒ์กด ์‹œ์ž‘
            System.out.println("m = " + m);  //m ์ƒ์กด ๊ฐ€๋Šฅ, ๋ธ”๋ก ๋‚ด๋ถ€์—์„œ ๋ธ”๋ก ์™ธ๋ถ€๋Š” ์ ‘๊ทผ ๊ฐ€๋Šฅ!!
            System.out.println("x = " + x);  //x ์ƒ์กด ๊ฐ€๋Šฅ
        }  //x ์ƒ์กด ์ข…๋ฃŒ

        //System.out.println("main x = " + x);  //x ์ƒ์กด ๋ถˆ๊ฐ€๋Šฅ, ์˜ค๋ฅ˜ ๋ฐœ์ƒ!! ๋ณ€์ˆ˜ x์— ์ ‘๊ทผ ๋ถˆ๊ฐ€...
        System.out.println("main m = " + m);  //m ์ƒ์กด ๊ฐ€๋Šฅ
    }  //m ์ƒ์กด ์ข…๋ฃŒ
}
  • int m
    • int m์€ main{ } ์˜ ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์—์„œ ์„ ์–ธ๋˜์—ˆ๋‹ค.
      ๋”ฐ๋ผ์„œ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•œ ์‹œ์ ๋ถ€ํ„ฐ main{ } ์˜ ์ฝ”๋“œ ๋ธ”๋ก์ด ์ข…๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ์ƒ์กด ๊ฐ€๋Šฅํ•˜๋‹ค.
    • if{ } ๋ธ”๋ก ๋‚ด๋ถ€์—์„œ๋„ ์™ธ๋ถ€ ๋ธ”๋ก์—์„œ ์„ ์–ธ๋œ m์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋‹ค.
      ์‰ฝ๊ฒŒ ์ด์•ผ๊ธฐํ•ด์„œ ์ƒ์กด ๋ฒ”์œ„๋งŒ ๋งž์œผ๋ฉด ๋‹ค ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋‹ค.
  • int x
    • int x๋Š” if{ } ๋ธ”๋ก ์•ˆ์—์„œ ์„ ์–ธ๋˜์—ˆ๋‹ค.
      ๋”ฐ๋ผ์„œ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•œ ์‹œ์ ๋ถ€ํ„ฐ if{ } ์˜ ์ฝ”๋“œ ๋ธ”๋ก์ด ์ข…๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ์ƒ์กด ๊ฐ€๋Šฅํ•˜๋‹ค.
    • if{ } ๋‚ด๋ถ€์—์„œ๋Š” ์ž์‹ ์˜ ๋ฒ”์œ„์—์„œ ์„ ์–ธํ•œ x์— ๋‹น์—ฐํžˆ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋‹ค.
    • if{ } ์ฝ”๋“œ ๋ธ”๋ก์ด ๋๋‚˜๋ฒ„๋ฆฌ๋ฉด x๋Š” ์ œ๊ฑฐ๋œ๋‹ค. ๋”ฐ๋ผ์„œ ๋”๋Š” x์— ์ ‘๊ทผํ•  ์ˆ˜ ์—†๋‹ค.
      ์ดํ›„์— ์ ‘๊ทผํ•˜๋ฉด cannot find symbol ์ด๋ผ๋Š” ๋ณ€์ˆ˜ ์ด๋ฆ„์„ ์ฐพ์„ ์ˆ˜ ์—†๋‹ค๋Š” ์ปดํŒŒ์ผ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.

์ •๋ฆฌํ•˜๋ฉด ์ง€์—ญ ๋ณ€์ˆ˜๋Š” ๋ณธ์ธ์˜ ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์—์„œ๋งŒ ์ƒ์กด ๊ฐ€๋Šฅํ•˜๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ž์‹ ์˜ ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์—์„œ๋Š” ์–ผ๋งˆ๋“ ์ง€ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋‹ค.
ํ•˜์ง€๋งŒ ์ž์‹ ์˜ ์ฝ”๋“œ ๋ธ”๋ก์„ ๋ฒ—์–ด๋‚˜๋ฉด ์ œ๊ฑฐ๋˜๊ธฐ ๋•Œ๋ฌธ์— ์ ‘๊ทผํ•  ์ˆ˜ ์—†๋‹ค... ๐Ÿฅฒ๐Ÿฅฒ

์ด๋ ‡๊ฒŒ ๋ณ€์ˆ˜์˜ ์ ‘๊ทผ ๊ฐ€๋Šฅํ•œ ๋ฒ”์œ„๋ฅผ ์Šค์ฝ”ํ”„(Scope)๋ผ๊ณ  ํ•œ๋‹ค. ์ฐธ๊ณ ๋กœ Scope๋ฅผ ๋ฒˆ์—ญํ•˜๋ฉด ๋ฒ”์œ„๋ผ๋Š” ๋œป์ด๋‹ค.

int m์€ main{ } ์ „์ฒด์—์„œ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์Šค์ฝ”ํ”„๊ฐ€ ๋„“๊ณ , int x๋Š” if{ } ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์—์„œ๋งŒ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์Šค์ฝ”ํ”„๊ฐ€ ์งง๋‹ค.

Scope2

package scope;

public class Scope2 {

    public static void main(String[] args) {
        int m = 10;  //m ์ƒ์กด ์‹œ์ž‘

        for (int i = 0; i < 2; i++) {  //i ์ƒ์กด ์‹œ์ž‘, ๋ธ”๋ก ๋‚ด๋ถ€, for๋ฌธ ๋‚ด์—์„œ๋งŒ...
            System.out.println("for m = " + m);  //๋ธ”๋ก ๋‚ด๋ถ€์—์„œ ์™ธ๋ถ€๋Š” ์ ‘๊ทผ ๊ฐ€๋Šฅ!!
            System.out.println("for i = " + i);  //i ์ƒ์กด ๊ฐ€๋Šฅ
        }  //i ์ƒ์กด ์ข…๋ฃŒ

        System.out.println("main m = " + m);  //m ์ƒ์กด ๊ฐ€๋Šฅ
        System.out.println("main i = " + i);  //i ์ƒ์กด ๋ถˆ๊ฐ€๋Šฅ, ์˜ค๋ฅ˜ ๋ฐœ์ƒ!! i ์ ‘๊ทผ ๋ถˆ๊ฐ€๋Šฅ...
    }  //m ์ƒ์กด ์ข…๋ฃŒ
}

for๋ฌธ์œผ๋กœ ๋ฐ”๋€ ๊ฒƒ์„ ์ œ์™ธํ•˜๋ฉด ์•ž์˜ ์˜ˆ์ œ์™€ ๋น„์Šทํ•œ ์˜ˆ์ œ์ด๋‹ค.
for๋ฌธ์˜ ๊ฒฝ์šฐ for(int i = 0; i < 2; i++) ๊ณผ ๊ฐ™์ด for๋ฌธ ์•ˆ์—์„œ ์ดˆ๊ธฐ์‹์— ์ง์ ‘ ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•  ์ˆ˜ ์žˆ๋‹ค.
๊ทธ๋ฆฌ๊ณ  ์ด๋ ‡๊ฒŒ ์„ ์–ธํ•œ ๋ณ€์ˆ˜๋Š” for๋ฌธ ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์—์„œ๋งŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

 

์Šค์ฝ”ํ”„2 - ์Šค์ฝ”ํ”„ ์กด์žฌ ์ด์œ 

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

Scope3_1

package scope;

public class Scope3_1 {

    public static void main(String[] args) {
        int m = 10;  //m ์ƒ์กด ์‹œ์ž‘
        int temp = 0;  //temp ์ƒ์กด ์‹œ์ž‘
        if (m > 0) {
            temp = m * 2;  // m, temp ์ƒ์กด ๊ฐ€๋Šฅ!
            System.out.println("temp = " + temp);  //temp ์ƒ์กด ๊ฐ€๋Šฅ!!
        }
        System.out.println("m = " + m);  //m ์ƒ์กด ๊ฐ€๋Šฅ!
    }  //m, temp ์ƒ์กด ์ข…๋ฃŒ
}

์กฐ๊ฑด์ด ๋งž์œผ๋ฉด ๋ณ€์ˆ˜ m์˜ ๊ฐ’์„ 2๋ฐฐ ์ฆ๊ฐ€ํ•ด์„œ ์ถœ๋ ฅํ•˜๋Š” ์ฝ”๋“œ์ด๋‹ค.
์—ฌ๊ธฐ์„œ 2๋ฐฐ ์ฆ๊ฐ€ํ•œ ๊ฐ’์„ ์ €์žฅํ•ด๋‘๊ธฐ ์œ„ํ•ด ์ž„์‹œ ๋ณ€์ˆ˜ temp๋ฅผ ์‚ฌ์šฉํ–ˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ ์ด ์ฝ”๋“œ๋Š” ์ข‹์€ ์ฝ”๋“œ๋ผ๊ณ  ๋ณด๊ธฐ๋Š” ์–ด๋ ต๋‹ค... ๐Ÿคจ
์™œ๋ƒํ•˜๋ฉด ์ž„์‹œ ๋ณ€์ˆ˜ temp๋Š” if ์กฐ๊ฑด์ด ๋งŒ์กฑํ•  ๋•Œ ์ž„์‹œ๋กœ ์ž ๊น ์‚ฌ์šฉํ•˜๋Š” ๋ณ€์ˆ˜์ด๋‹ค.
๊ทธ๋Ÿฐ๋ฐ ์ž„์‹œ ๋ณ€์ˆ˜ temp main( ) ์ฝ”๋“œ ๋ธ”๋ก์— ์„ ์–ธ๋˜์–ด ์žˆ๋‹ค. ์ด๋ ‡๊ฒŒ ๋˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.

  • ๋น„ํšจ์œจ์ ์ธ ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ :
    temp๋Š” if ์ฝ”๋“œ ๋ธ”๋ก์—์„œ๋งŒ ํ•„์š”ํ•˜์ง€๋งŒ, main( ) ์ฝ”๋“œ ๋ธ”๋ก์ด ์ข…๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ๋ฉ”๋ชจ๋ฆฌ์— ์œ ์ง€๋œ๋‹ค.
    ๋”ฐ๋ผ์„œ ๋ถˆํ•„์š”ํ•œ ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ ๋‚ญ๋น„๋œ๋‹ค.
    ๋งŒ์•ฝ if ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์— temp๋ฅผ ์„ ์–ธํ–ˆ๋‹ค๋ฉด ์ž๋ฐ”๋ฅผ ๊ตฌํ˜„ํ•˜๋Š” ๊ณณ์—์„œ if ์ฝ”๋“œ ๋ธ”๋ก์˜ ์ข…๋ฃŒ ์‹œ์ ์— ์ด ๋ณ€์ˆ˜๋ฅผ ๋ฉ”๋ชจ๋ฆฌ์—์„œ ์ œ๊ฑฐํ•ด์„œ ๋” ํšจ์œจ์ ์œผ๋กœ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
  • ์ฝ”๋“œ ๋ณต์žก์„ฑ ์ฆ๊ฐ€ :
    ์ข‹์€ ์ฝ”๋“œ๋Š” ๊ตฐ๋”๋”๊ธฐ ์—†๋Š” ๋‹จ์ˆœํ•œ ์ฝ”๋“œ์ด๋‹ค. ๐Ÿ˜Ž๐Ÿ˜Ž
    temp๋Š” if ์ฝ”๋“œ ๋ธ”๋ก์—์„œ๋งŒ ํ•„์š”ํ•˜๊ณ , ์—ฌ๊ธฐ์„œ๋งŒ ์‚ฌ์šฉํ•˜๋ฉด ๋œ๋‹ค.
    ๋งŒ์•ฝ if ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์— temp๋ฅผ ์„ ์–ธํ–ˆ๋‹ค๋ฉด if๊ฐ€ ๋๋‚˜๊ณ  ๋‚˜๋ฉด temp๋ฅผ ์ „ํ˜€ ์ƒ๊ฐํ•˜์ง€ ์•Š์•„๋„ ๋œ๋‹ค. ๋จธ๋ฆฌ ์†์—์„œ ์ƒ๊ฐํ•  ๋ณ€์ˆ˜๋ฅผ ํ•˜๋‚˜ ์ค„์ผ ์ˆ˜ ์žˆ๋‹ค.
    ๊ทธ๋Ÿฐ๋ฐ ์ง€๊ธˆ ์ž‘์„ฑํ•œ ์ฝ”๋“œ๋Š” if ์ฝ”๋“œ ๋ธ”๋ก์ด ๋๋‚˜๋„ main( ) ์–ด๋””์„œ๋‚˜ temp๋ฅผ ์—ฌ์ „ํžˆ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋‹ค. ๋ˆ„๊ตฐ๊ฐ€ ์ด ์ฝ”๋“œ๋ฅผ ์œ ์ง€๋ณด์ˆ˜ ํ•  ๋•Œ m์€ ๋ฌผ๋ก ์ด๊ณ  temp๊นŒ์ง€ ๊ณ„์† ์‹ ๊ฒฝ์จ์•ผ ํ•œ๋‹ค. ์Šค์ฝ”ํ”„๊ฐ€ ๋ถˆํ•„์š”ํ•˜๊ฒŒ ๋„“์€ ๊ฒƒ์ด๋‹ค.
    ์ง€๊ธˆ์€ ์ฝ”๋“œ๊ฐ€ ๋งค์šฐ ๋‹จ์ˆœํ•ด์„œ ์ดํ•ดํ•˜๋Š”๋ฐ ์–ด๋ ค์›€์ด ์—†๊ฒ ์ง€๋งŒ ์‹ค๋ฌด์—์„œ๋Š” ์ฝ”๋“œ๊ฐ€ ๋งค์šฐ ๋ณต์žกํ•œ ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๋‹ค.

Scope3_2

package scope;

public class Scope3_2 {

    public static void main(String[] args) {
        int m = 10;  //m ์ƒ์กด ์‹œ์ž‘!!

        if (m > 0) {
            int temp = m * 2;  //temp ์ƒ์กด ์‹œ์ž‘!! m ์ƒ์กด ๊ฐ€๋Šฅ!
            System.out.println("temp = " + temp);  //temp ์ƒ์กด ๊ฐ€๋Šฅ!
        }  //temp ์ƒ์กด ์ข…๋ฃŒ...
        
        //System.out.println(temp);  //temp ์ ‘๊ทผ ๋ถˆ๊ฐ€๋Šฅ... ์˜ค๋ฅ˜ ๋ฐœ์ƒ!
        System.out.println("m = " + m);  //m ์ƒ์กด ๊ฐ€๋Šฅ!
    }  //m ์ƒ์กด ์ข…๋ฃŒ...
}

temp๋ฅผ if ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์—์„œ ์„ ์–ธํ–ˆ๋‹ค. ์ด์ œ temp๋Š” if ์ฝ”๋“œ ๋ธ”๋ก ์•ˆ์œผ๋กœ ์Šค์ฝ”ํ”„๊ฐ€ ์ค„์–ด๋“ ๋‹ค.
๋•๋ถ„์— temp ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ๋นจ๋ฆฌ ์ œ๊ฑฐํ•ด์„œ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํšจ์œจ์ ์œผ๋กœ ์‚ฌ์šฉํ•˜๊ณ , temp ๋ณ€์ˆ˜๋ฅผ ์ƒ๊ฐํ•ด์•ผ ํ•˜๋Š” ๋ฒ”์œ„๋ฅผ ์ค„์—ฌ์„œ ๋” ์œ ์ง€๋ณด์ˆ˜ ํ•˜๊ธฐ ์ข‹์€ ์ฝ”๋“œ๋ฅผ ๋งŒ๋“ค์—ˆ๋‹ค. ๐Ÿ˜Ž๐Ÿ˜Ž

while๋ฌธ vs for๋ฌธ - ์Šค์ฝ”ํ”„ ๊ด€์ 

์ด์ œ ์Šค์ฝ”ํ”„ ๊ด€์ ์—์„œ while๋ฌธ๊ณผ for๋ฌธ์„ ๋น„๊ตํ•œ๋‹ค!!

While

package loop;

public class While2_3 {

    public static void main(String[] args) {
        int sum = 0;
        int i = 10;
        int endNum = 12;

        while (i <= endNum) {
            sum = sum + i;
            System.out.println("i = " + i + ", sum = " + sum);
            i++;
        }
        //... ์•„๋ž˜์— ๋” ๋งŽ์€ ์ฝ”๋“œ๋“ค์ด ์žˆ๋‹ค๊ณ  ๊ฐ€์ •
    }
}

For

package loop;

public class For2 {

    public static void main(String[] args) {
        int sum = 0;
        int endNum = 3;

        // 1 + 2 + 3 = 6
        for (int i = 1; i <= endNum; i++) {
            sum = sum + i;
            System.out.println("sum = " + sum);
        }
        //... ์•„๋ž˜์— ๋” ๋งŽ์€ ์ฝ”๋“œ๋“ค์ด ์žˆ๋‹ค๊ณ  ๊ฐ€์ •
    }
}

๋ณ€์ˆ˜์˜ ์Šค์ฝ”ํ”„ ๊ด€์ ์—์„œ ์นด์šดํ„ฐ ๋ณ€์ˆ˜ i๋ฅผ ๋น„๊ตํ•ด๋ณด์ž.

  • while๋ฌธ์˜ ๊ฒฝ์šฐ ๋ณ€์ˆ˜ i์˜ ์Šค์ฝ”ํ”„๊ฐ€ main( ) ๋ฉ”์„œ๋“œ ์ „์ฒด๊ฐ€ ๋œ๋‹ค. ๋ฐ˜๋ฉด์— for๋ฌธ์˜ ๊ฒฝ์šฐ ๋ณ€์ˆ˜ i์˜ ์Šค์ฝ”ํ”„๊ฐ€ for๋ฌธ ์•ˆ์œผ๋กœ ํ•œ์ •๋œ๋‹ค.
  • ๋”ฐ๋ผ์„œ ๋ณ€์ˆ˜ i์™€ ๊ฐ™์ด for๋ฌธ ์•ˆ์—์„œ๋งŒ ์‚ฌ์šฉ๋˜๋Š” ์นด์šดํ„ฐ ๋ณ€์ˆ˜๊ฐ€ ์žˆ๋‹ค๋ฉด while๋ฌธ๋ณด๋‹ค๋Š” for๋ฌธ์„ ์‚ฌ์šฉํ•ด์„œ ์Šค์ฝ”ํ”„์˜ ๋ฒ”์œ„๋ฅผ ์ œํ•œํ•˜๋Š” ๊ฒƒ์ด ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๊ณผ ์œ ์ง€๋ณด์ˆ˜ ๊ด€์ ์—์„œ ๋” ์ข‹๋‹ค. ๐Ÿ˜ƒ๐Ÿ˜ƒ
โœ”๏ธ์ฐธ๊ณ 

Ctrl + E ํ›„ Enter : ๋ฐ”๋กœ ์ „ ํŒŒ์ผ๋กœ ๋„˜์–ด๊ฐ„๋‹ค.
Ctrl + N : ํŒŒ์ผ ๊ฒ€์ƒ‰ํ•  ์ˆ˜ ์žˆ๋Š” ๋„ค๋น„๊ฒŒ์ด์…˜์ด ๋‚˜์˜จ๋‹ค.


โœ๏ธ ์ •๋ฆฌ

  • ๋ณ€์ˆ˜๋Š” ๊ผญ ํ•„์š”ํ•œ ๋ฒ”์œ„๋กœ ํ•œ์ •ํ•ด์„œ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹๋‹ค. ๋ณ€์ˆ˜์˜ ์Šค์ฝ”ํ”„๋Š” ๊ผญ ํ•„์š”ํ•œ ๊ณณ์œผ๋กœ ํ•œ์ •ํ•ด์„œ ์‚ฌ์šฉํ•˜์ž.
    ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํšจ์œจ์ ์œผ๋กœ ์‚ฌ์šฉํ•˜๊ณ  ๋” ์œ ์ง€๋ณด์ˆ˜ํ•˜๊ธฐ ์ข‹์€ ์ฝ”๋“œ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.
  • ์ข‹์€ ํ”„๋กœ๊ทธ๋žจ์€ ๋ฌดํ•œํ•œ ์ž์œ ๊ฐ€ ์žˆ๋Š” ํ”„๋กœ๊ทธ๋žจ์ด ์•„๋‹ˆ๋ผ ์ ์ ˆํ•œ ์ œ์•ฝ์ด ์žˆ๋Š” ํ”„๋กœ๊ทธ๋žจ์ด๋‹ค.

 

ํ˜•๋ณ€ํ™˜1 - ์ž๋™ ํ˜•๋ณ€ํ™˜

ํ˜•๋ณ€ํ™˜

  • ์ž‘์€ ๋ฒ”์œ„์—์„œ ํฐ ๋ฒ”์œ„๋กœ๋Š” ๋‹น์—ฐํžˆ ๊ฐ’์„ ๋„ฃ์„ ์ˆ˜ ์žˆ๋‹ค.
    • ์˜ˆ ) int โ†’ long โ†’ double
  • ํฐ ๋ฒ”์œ„์—์„œ ์ž‘์€ ๋ฒ”์œ„๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๋‹ค.... ๐Ÿฅฒ๐Ÿฅฒ
    • ์†Œ์ˆ˜์  ๋ฒ„๋ฆผ
    • ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ

์ž‘์€ ๋ฒ”์œ„์—์„œ ํฐ ๋ฒ”์œ„๋กœ ๋Œ€์ž…์€ ํ—ˆ์šฉํ•œ๋‹ค.

์ž๋ฐ”์—์„œ ์ˆซ์ž๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฒ”์œ„๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.
int  <  long  <  double
int๋ณด๋‹ค๋Š” long์ด, long๋ณด๋‹ค๋Š” double์ด ๋” ํฐ ๋ฒ”์œ„๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

์ž‘์€ ๋ฒ”์œ„์—์„œ ํฐ ๋ฒ”์œ„์— ๊ฐ’์„ ๋Œ€์ž…ํ•˜๋Š” ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•˜๋ฉด ํŠน๋ณ„ํ•œ ๋ฌธ์ œ์—†์ด ์ž˜ ์ˆ˜ํ–‰๋œ๋‹ค.

Casting1

package casting;

public class Casting1 {

    public static void main(String[] args) {
        int intValue = 10;
        long longValue ;
        double doubleValue;

        longValue = intValue;  //int -> long
        System.out.println("longValue = " + longValue);  //longValue = 10

        doubleValue = intValue;  //int -> double
        System.out.println("doubleValue = " + doubleValue);  //doubleValue = 10.0

        doubleValue = 20000000000L;  //long -> double
        System.out.println("doubleValue2 = " + doubleValue);  //doubleValue2 = 2.0E10
    }
}

์ž๋ฐ”๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ ๊ฐ™์€ ํƒ€์ž…์— ๊ฐ’์„ ๋Œ€์ž…ํ•  ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ ๋‹ค๋ฅธ ํƒ€์ž…์— ๊ฐ’์„ ๋Œ€์ž…ํ•˜๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ?

  • int  โ†’  long์„ ๋น„๊ตํ•ด๋ณด๋ฉด long์ด int๋ณด๋‹ค ๋” ํฐ ์ˆซ์ž ๋ฒ”์œ„๋ฅผ ํ‘œํ˜„ํ•œ๋‹ค.
    ์ž‘์€ ๋ฒ”์œ„ ์ˆซ์ž ํƒ€์ž…์—์„œ ํฐ ๋ฒ”์œ„ ์ˆซ์ž ํƒ€์ž…์ด ๋Œ€์ž…์„ ํ•˜๋ฉด ๋ฌธ์ œ๊ฐ€ ๋˜์ง€ ์•Š๋Š”๋‹ค.
    ๋งŒ์•ฝ ์ด๋Ÿฐ ๊ฒฝ์šฐ๊นŒ์ง€ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค๋ฉด ๊ฐœ๋ฐœ์ด ๋„ˆ๋ฌด ๋ถˆํŽธํ•  ๊ฒƒ์ด๋‹ค.
  • long  โ†’  double์˜ ๊ฒฝ์šฐ์—๋„ double์€ ๋ถ€๋™ ์†Œ์ˆ˜์ ์„ ์‚ฌ์šฉํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋” ํฐ ์ˆซ์ž ๋ฒ”์œ„๋ฅผ ํ‘œํ˜„ํ•œ๋‹ค.
    ๋”ฐ๋ผ์„œ ๋Œ€์ž…ํ•  ์ˆ˜ ์žˆ๋‹ค.
  • ์ •๋ฆฌํ•˜๋ฉด ์ž‘์€ ๋ฒ”์œ„์—์„œ ํฐ ๋ฒ”์œ„๋กœ์˜ ๋Œ€์ž…์€ ์ž๋ฐ” ์–ธ์–ด์—์„œ ํ—ˆ์šฉ๋œ๋‹ค. ์‰ฝ๊ฒŒ ์ด์•ผ๊ธฐํ•˜๋ฉด ํฐ ๊ทธ๋ฆ‡์€ ์ž‘์€ ๊ทธ๋ฆ‡์— ๋‹ด๊ธด ๋‚ด์šฉ๋ฌผ์„ ๋‹ด์„ ์ˆ˜ ์žˆ๋‹ค.

์ž๋™ ํ˜•๋ณ€ํ™˜

ํ•˜์ง€๋งŒ ๊ฒฐ๊ตญ ๋Œ€์ž…ํ•˜๋Š” ํ˜•(ํƒ€์ž…)์„ ๋งž์ถ”์–ด์•ผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๊ฐœ๋…์ ์œผ๋กœ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋™์ž‘ํ•œ๋‹ค.

//intValue = 10
doubleValue = intValue
doubleValue = (double) intValue  //ํ˜• ๋งž์ถ”๊ธฐ
doubleValue = (double) 10  //๋ณ€์ˆ˜ ๊ฐ’ ์ฝ๊ธฐ
doubleValue = 10.0  //ํ˜• ๋ณ€ํ™˜

์ด๋ ‡๊ฒŒ ์•ž์— (double)๊ณผ ๊ฐ™์ด ์ ์–ด์ฃผ๋ฉด intํ˜•์ด doubleํ˜•์œผ๋กœ ํ˜•์ด ๋ณ€ํ•œ๋‹ค. ์ด๋ ‡๊ฒŒ ํ˜•์ด ๋ณ€๊ฒฝ๋˜๋Š” ๊ฒƒ์„ ํ˜•๋ณ€ํ™˜์ด๋ผ๊ณ  ํ•œ๋‹ค.
์ž‘์€ ๋ฒ”์œ„ ์ˆซ์ž ํƒ€์ž…์—์„œ ํฐ ๋ฒ”์œ„ ์ˆซ์ž ํƒ€์ž…์œผ๋กœ์˜ ๋Œ€์ž…์€ ๊ฐœ๋ฐœ์ž๊ฐ€ ์ด๋ ‡๊ฒŒ ์ง์ ‘ ํ˜•๋ณ€ํ™˜์„ ํ•˜์ง€ ์•Š์•„๋„ ๋œ๋‹ค.
์ด๋Ÿฐ ๊ณผ์ •์ด ์ž๋™์œผ๋กœ ์ผ์–ด๋‚˜๊ธฐ ๋•Œ๋ฌธ์— ์ž๋™ ํ˜•๋ณ€ํ™˜, ๋˜๋Š” ๋ฌต์‹œ์  ํ˜•๋ณ€ํ™˜์ด๋ผ ํ•œ๋‹ค.

 

ํ˜•๋ณ€ํ™˜2 - ๋ช…์‹œ์  ํ˜•๋ณ€ํ™˜

ํฐ ๋ฒ”์œ„์—์„œ ์ž‘์€ ๋ฒ”์œ„ ๋Œ€์ž…์€ ๋ช…์‹œ์  ํ˜•๋ณ€ํ™˜์ด ํ•„์š”ํ•˜๋‹ค.

double์€ ์‹ค์ˆ˜๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค. ๋”ฐ๋ผ์„œ 1.5๊ฐ€ ๊ฐ€๋Šฅํ•˜๋‹ค.
๊ทธ๋Ÿฐ๋ฐ int๋Š” ์‹ค์ˆ˜๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์—†๋‹ค. ์ด ๊ฒฝ์šฐ double  โ†’  int๋กœ ๋Œ€์ž…ํ•˜๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ?

Casting2

package casting;

public class Casting2 {

    public static void main(String[] args) {
        double doubleValue = 1.5;
        int intValue = 0;

        //intValue = doubleValue;  //์ปดํŒŒ์ผ ์˜ค๋ฅ˜ ๋ฐœ์ƒ!!
        
        intValue = (int) doubleValue;  //ํ˜•๋ณ€ํ™˜
        System.out.println(intValue);
    }
}

๋‹ค์Œ ์ฝ”๋“œ์˜ ์•ž ๋ถ€๋ถ„์— ์žˆ๋Š” ์ฃผ์„์„ ํ’€๋ฉด(์ฃผ์„์„ ์ œ๊ฑฐํ•˜๋ฉด) ์ปดํŒŒ์ผ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.
intValue = doubleValue;  //์ปดํŒŒ์ผ ์˜ค๋ฅ˜ ๋ฐœ์ƒ

java: incompatible types: possible lossy conversion form double to int
// java: ํ˜ธํ™˜๋˜์ง€ ์•Š๋Š” ์œ ํ˜•: double์—์„œ int๋กœ์˜ ๊ฐ€๋Šฅํ•œ ์†์‹ค ๋ณ€ํ™˜

intํ˜•์€ doubleํ˜•๋ณด๋‹ค ์ˆซ์ž์˜ ํ‘œํ˜„ ๋ฒ”์œ„๊ฐ€ ์ž‘๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์‹ค์ˆ˜๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜๋„ ์—†๋‹ค.
๋”ฐ๋ผ์„œ ์ด ๊ฒฝ์šฐ ์ˆซ์ž๊ฐ€ ์†์‹ค๋˜๋Š” ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๋‹ค. ์‰ฝ๊ฒŒ ์ด์•ผ๊ธฐํ•ด์„œ ํฐ ์ปต์— ๋‹ด๊ธด ๋ฌผ์„ ์ž‘์€ ์ปต์— ์˜ฎ๊ฒจ ๋‹ด์œผ๋ ค๊ณ  ํ•˜๋‹ˆ, ์†์‹ค์ด ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค.
์ด๋Ÿฐ ๋ฌธ์ œ๋Š” ๋งค์šฐ ํฐ ๋ฒ„๊ทธ๋ฅผ ์œ ๋ฐœํ•  ์ˆ˜ ์žˆ๋‹ค. ๐Ÿ˜ฎ๐Ÿ˜ฎ
์˜ˆ๋ฅผ ๋“ค์–ด์„œ ์€ํ–‰ ํ”„๋กœ๊ทธ๋žจ์ด ๊ณ ๊ฐ์—๊ฒŒ ์€ํ–‰ ์ด์ž๋ฅผ ๊ณ„์‚ฐํ•ด์„œ ์ž…๊ธˆํ•ด์•ผ ํ•˜๋Š”๋ฐ ๋งŒ์•ฝ ์ด๋Ÿฐ ์ฝ”๋“œ๊ฐ€ ์•„๋ฌด๋Ÿฐ ์˜ค๋ฅ˜ ์—†์ด ์ˆ˜ํ–‰๋œ๋‹ค๋ฉด ๋”์ฐํ•œ ๋ฌธ์ œ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋ž˜์„œ ์ž๋ฐ”๋Š” ์ด๋Ÿฐ ๊ฒฝ์šฐ ์ปดํŒŒ์ผ ์˜ค๋ฅ˜๋ฅผ ๋ฐœ์ƒ์‹œํ‚จ๋‹ค.
ํ•ญ์ƒ ๊ฐ•์กฐํ•˜์ง€๋งŒ ์ปดํŒŒ์ผ ์˜ค๋ฅ˜๋Š” ๋ฌธ์ œ๋ฅผ ๊ฐ€์žฅ ๋นจ๋ฆฌ ๋ฐœ๊ฒฌํ•  ์ˆ˜ ์žˆ๋Š” ์ข‹์€ ์˜ค๋ฅ˜์ด๋‹ค.

ํ˜•๋ณ€ํ™˜

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

ํ˜•๋ณ€ํ™˜์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ณ€๊ฒฝํ•˜๊ณ  ์‹ถ์€ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ (int)์™€ ๊ฐ™์ด ๊ด„ํ˜ธ๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋ช…์‹œ์ ์œผ๋กœ ์ž…๋ ฅํ•˜๋ฉด ๋œ๋‹ค.
intValue = (int) doubleValue;  //ํ˜•๋ณ€ํ™˜
์ด๊ฒƒ์„ ํ˜•(ํƒ€์ž…)์„ ๋ฐ”๊พผ๋‹ค๊ณ  ํ•ด์„œ ํ˜•๋ณ€ํ™˜์ด๋ผ ํ•œ๋‹ค. ์˜์–ด๋กœ๋Š” ์บ์ŠคํŒ…์ด๋ผ ํ•œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ฐœ๋ฐœ์ž๊ฐ€ ์ง์ ‘ ํ˜•๋ณ€ํ™˜ ์ฝ”๋“œ๋ฅผ ์ž…๋ ฅํ•œ๋‹ค๊ณ  ํ•ด์„œ ๋ช…์‹œ์  ํ˜•๋ณ€ํ™˜์ด๋ผ ํ•œ๋‹ค.

์บ์ŠคํŒ… ์šฉ์–ด

"์บ์ŠคํŒ…"์€ ์˜์–ด ๋‹จ์–ด "cast"์—์„œ ์œ ๋ž˜๋˜์—ˆ๋‹ค. "cast"๋Š” ๊ธˆ์†์ด๋‚˜ ๋‹ค๋ฅธ ๋ฌผ์งˆ์„ ๋…น์—ฌ์„œ ํŠน์ •ํ•œ ํ˜•ํƒœ๋‚˜ ๋ชจ์–‘์œผ๋กœ ๋งŒ๋“œ๋Š” ๊ณผ์ •์„ ์˜๋ฏธํ•œ๋‹ค.

๋ช…์‹œ์  ํ˜•๋ณ€ํ™˜ ๊ณผ์ •

//doubleValue = 1.5
intValue = (int) doubleValue;
intValue = (int) 1.5;  //doubleValue์— ์žˆ๋Š” ๊ฐ’์„ ์ฝ๋Š”๋‹ค.
intValue = 1;  //(int)๋กœ ํ˜•๋ณ€ํ™˜ ํ•œ๋‹ค. intValue์— intํ˜•์ธ ์ˆซ์ž 1์„ ๋Œ€์ž…ํ•œ๋‹ค.

ํ˜•๋ณ€ํ™˜ ํ›„ ์ถœ๋ ฅํ•ด๋ณด๋ฉด ์ˆซ์ž 1์ด ์ถœ๋ ฅ๋˜๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์ด๋‹ค.
์ฐธ๊ณ ๋กœ ํ˜•๋ณ€ํ™˜์„ ํ•œ๋‹ค๊ณ  ํ•ด์„œ doubleValue ์ž์ฒด์˜ ํƒ€์ž…์ด ๋ณ€๊ฒฝ๋˜๊ฑฐ๋‚˜ ๊ทธ ์•ˆ์— ์žˆ๋Š” ๊ฐ’์ด ๋ณ€๊ฒฝ๋˜๋Š” ๊ฒƒ์€ ์•„๋‹ˆ๋‹ค.
doubleValue์—์„œ ์ฝ์€ ๊ฐ’์„ ํ˜•๋ณ€ํ™˜ํ•˜๋Š” ๊ฒƒ์ด๋‹ค. doubleValue ์•ˆ์— ๋“ค์–ด์žˆ๋Š” ๊ฐ’์€ 1.5๋กœ ๊ทธ๋Œ€๋กœ ์œ ์ง€๋œ๋‹ค.
์ฐธ๊ณ ๋กœ ๋ณ€์ˆ˜์˜ ๊ฐ’์€ ๋Œ€์ž…์—ฐ์‚ฐ์ž(=)๋ฅผ ์‚ฌ์šฉํ•ด์„œ ์ง์ ‘ ๋Œ€์ž…ํ•  ๋•Œ๋งŒ ๋ณ€๊ฒฝ๋œ๋‹ค.

ํ˜•๋ณ€ํ™˜๊ณผ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ

ํ˜•๋ณ€ํ™˜์„ ํ•  ๋•Œ ๋งŒ์•ฝ ์ž‘์€ ์ˆซ์ž๊ฐ€ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฒ”์œ„๋ฅผ ๋„˜์–ด์„œ๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ?

Casting3

package casting;

public class Casting3 {

    public static void main(String[] args) {
        long maxIntValue = 2147483647L;  //int ์ตœ๊ณ ๊ฐ’
        long maxIntOver = 2147483648L;  //int ์ตœ๊ณ ๊ฐ’ + 1(์ดˆ๊ณผ)
        int intValue = 0;

        intValue = (int) maxIntValue;  //ํ˜•๋ณ€ํ™˜
        System.out.println("maxIntValue casting = " + intValue);

        intValue = (int) maxIntOver;  //ํ˜•๋ณ€ํ™˜
        System.out.println("maxIntOver casting = " + intValue);  //๋ฒ”์œ„๋ฅผ ๋„˜์–ด๊ฐ€๋ฉด int์˜ ๊ฐ€์žฅ ์ž‘์€ ๋ฒ”์œ„๋ถ€ํ„ฐ ๋‹ค์‹œ ์‹œ์ž‘๋œ๋‹ค!!
    }
}

์ •์ƒ ๋ฒ”์œ„

long maxIntValue = 2147483647 ๋ฅผ ๋ณด๋ฉด int๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฐ€์žฅ ํฐ ์ˆซ์ž์ธ 2147483647๋ฅผ ์ž…๋ ฅํ–ˆ๋‹ค.
์ด ๊ฒฝ์šฐ int๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฒ”์œ„์— ํฌํ•จ๋˜๊ธฐ ๋•Œ๋ฌธ์— ๋‹ค์Œ๊ณผ ๊ฐ™์ด long  โ†’  int๋กœ ํ˜•๋ณ€ํ™˜์„ ํ•ด๋„ ์•„๋ฌด๋Ÿฐ ๋ฌธ์ œ๊ฐ€ ์—†๋‹ค.

intValue = (int) maxIntValue;  //ํ˜•๋ณ€ํ™˜

maxIntValue = 2147483647;  //int ์ตœ๊ณ ๊ฐ’
intValue = (int) maxIntValue;  //๋ณ€์ˆ˜ ๊ฐ’ ์ฝ๊ธฐ
intValue = (int) 2147483647;  //ํ˜•๋ณ€ํ™˜
intValue = 2147483647;

์ดˆ๊ณผ ๋ฒ”์œ„

๋‹ค์Œ์œผ๋กœ long maxIntOver = 2147483648L ๋ฅผ ๋ณด๋ฉด int๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฐ€์žฅ ํฐ ์ˆซ์ž์ธ 2147483647๋ณด๋‹ค 1 ํฐ ์ˆซ์ž๋ฅผ ์ž…๋ ฅํ–ˆ๋‹ค. ์ด ์ˆซ์ž๋Š” ๋ฆฌํ„ฐ๋Ÿด์€ int ๋ฒ”์œ„๋ฅผ ๋„˜์–ด๊ฐ€๊ธฐ ๋•Œ๋ฌธ์— ๋งˆ์ง€๋ง‰์— L์„ ๋ถ™์—ฌ์„œ longํ˜•์„ ์‚ฌ์šฉํ•ด์•ผ ํ•œ๋‹ค.
์ด ๊ฒฝ์šฐ int๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฒ”์œ„๋ฅผ ๋„˜๊ธฐ ๋•Œ๋ฌธ์— ๋‹ค์Œ๊ณผ ๊ฐ™์ด long  โ†’  int๋กœ ํ˜•๋ณ€ํ™˜ํ•˜๋ฉด ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.

intValue = (int) maxIntOver;  //ํ˜•๋ณ€ํ™˜

maxIntOver = 2147483638L;  //int ์ตœ๊ณ ๊ฐ’ + 1
inValue = (int) maxIntOver;  //๋ณ€์ˆ˜ ๊ฐ’ ์ฝ๊ธฐ
intValue = (int) 2147483648L;  //ํ˜•๋ณ€ํ™˜ ์‹œ๋„
intValue = -2147483648;
  • ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด -2147483648์ด๋ผ๋Š” ์ „ํ˜€ ๋‹ค๋ฅธ ์ˆซ์ž๊ฐ€ ๋ณด์ธ๋‹ค.
    intํ˜•์€ 2147483648L๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์ด ์—†๋‹ค. ์ด๋ ‡๊ฒŒ ๊ธฐ์กด ๋ฒ”์œ„๋ฅผ ์ดˆ๊ณผํ•ด์„œ ํ‘œํ˜„ํ•˜๊ฒŒ ๋˜๋ฉด ์ „ํ˜€ ๋‹ค๋ฅธ ์ˆซ์ž๊ฐ€ ํ‘œํ˜„๋˜๋Š”๋ฐ, ์ด๋Ÿฐ ํ˜„์ƒ์„ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ๋ผ ํ•œ๋‹ค.
  • ๋ณดํ†ต ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ๊ฐ€ ๋ฐœ์ƒํ•˜๋ฉด ๋งˆ์น˜ ์‹œ๊ณ„๊ฐ€ ํ•œ๋ฐ”ํ€ด ๋ˆ ๊ฒƒ์ฒ˜๋Ÿผ ๋‹ค์‹œ ์ฒ˜์Œ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•œ๋‹ค. ์ฐธ๊ณ ๋กœ -2147483648 ์ˆซ์ž๋Š” int์˜ ๊ฐ€์žฅ ์ž‘์€ ์ˆซ์ž์ด๋‹ค.
  • ์ค‘์š”ํ•œ ๊ฒƒ์€ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ๊ฐ€ ๋ฐœ์ƒํ•˜๋Š” ๊ฒƒ ์ž์ฒด๊ฐ€ ๋ฌธ์ œ๋ผ๋Š” ์ ์ด๋‹ค!
    ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ๊ฐ€ ๋ฐœ์ƒํ–ˆ์„ ๋•Œ ๊ฒฐ๊ณผ๊ฐ€ ์–ด๋–ป๊ฒŒ ๋˜๋Š”์ง€ ๊ณ„์‚ฐํ•˜๋Š”๋ฐ ์‹œ๊ฐ„์„ ๋‚ญ๋น„ํ•˜๋ฉด ์•ˆ๋œ๋‹ค!
    ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ์ž์ฒด๊ฐ€ ๋ฐœ์ƒํ•˜์ง€ ์•Š๋„๋ก ๋ง‰์•„์•ผ ํ•œ๋‹ค.
    ์ด ๊ฒฝ์šฐ ๋‹จ์ˆœํžˆ ๋Œ€์ž…ํ•˜๋Š” ๋ณ€์ˆ˜(intValue)์˜ ํƒ€์ž…์„ int  โ†’  long์œผ๋กœ ๋ณ€๊ฒฝํ•ด์„œ ์‚ฌ์ด์ฆˆ๋ฅผ ๋Š˜๋ฆฌ๋ฉด ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ๋ฌธ์ œ๊ฐ€ ํ•ด๊ฒฐ๋œ๋‹ค.

 

๊ณ„์‚ฐ๊ณผ ํ˜•๋ณ€ํ™˜

ํ˜•๋ณ€ํ™˜์€ ๋Œ€์ž…๋ฟ๋งŒ ์•„๋‹ˆ๋ผ, ๊ณ„์‚ฐ์„ ํ•  ๋•Œ๋„ ๋ฐœ์ƒํ•œ๋‹ค.

Casting4

package casting;

public class Casting4 {

    public static void main(String[] args) {
        int div1 = 3 / 2;
        System.out.println("div1 = " + div1);  //1

        double div2 = 3 / 2;
        System.out.println("div2 = " + div2);  //1.0

        double div3 = 3.0 / 2;
        System.out.println("div3 = " + div3);  //1.5

        double div4 = (double) 3 / 2;
        System.out.println("div4 = " + div4);  //1.5

        int a = 3;
        int b = 2;
        double result = (double) a / b;
        System.out.println("result = " + result);  //1.5
    }
}

์ž๋ฐ”์—์„œ ๊ณ„์‚ฐ์€ ๋‹ค์Œ 2๊ฐ€์ง€๋ฅผ ๊ธฐ์–ตํ•˜์ž.

  • ๊ฐ™์€ ํƒ€์ž…๋ผ๋ฆฌ์˜ ๊ณ„์‚ฐ์€ ๊ฐ™์€ ํƒ€์ž…์˜ ๊ฒฐ๊ณผ๋ฅผ ๋‚ธ๋‹ค!!!
    • int + int๋Š” int๋ฅผ, double + double์€ double์˜ ๊ฒฐ๊ณผ๊ฐ€ ๋‚˜์˜จ๋‹ค.
  • ์„œ๋กœ ๋‹ค๋ฅธ ํƒ€์ž…์˜ ๊ณ„์‚ฐ์€ ํฐ ๋ฒ”์œ„๋กœ ์ž๋™ ํ˜•๋ณ€ํ™˜์ด ์ผ์–ด๋‚œ๋‹ค!!!
    • int + long์€ long + long์œผ๋กœ ์ž๋™ ํ˜•๋ณ€ํ™˜์ด ์ผ์–ด๋‚œ๋‹ค.
    • int + double์€ double + double๋กœ ์ž๋™ ํ˜•๋ณ€ํ™˜์ด ์ผ์–ด๋‚œ๋‹ค.

๋‹ค์–‘ํ•œ ํƒ€์ž…๋ณ„๋กœ ๋” ์ž์„ธํžˆ ๋“ค์–ด๊ฐ€๋ฉด ์•ฝ๊ฐ„ ์ฐจ์ด๊ฐ€ ์žˆ์ง€๋งŒ ์ด ๊ธฐ์ค€์œผ๋กœ ์ดํ•ดํ•˜๋ฉด ์ถฉ๋ถ„ํ•˜๋‹ค ๐Ÿ˜Ž

int div1 = 3 / 2;  //int / int
int div1 = 1;  //int / int์ด๋ฏ€๋กœ int ํƒ€์ž…์œผ๋กœ ๊ฒฐ๊ณผ๊ฐ€ ๋‚˜์˜จ๋‹ค.
double div2 = 3 / 2;  //int / int
double div2 = 1;  //int / int์ด๋ฏ€๋กœ int ํƒ€์ž…์œผ๋กœ ๊ฒฐ๊ณผ๊ฐ€ ๋‚˜์˜จ๋‹ค.
double div2 = (double) 1;  //int -> double์— ๋Œ€์ž…ํ•ด์•ผ ํ•œ๋‹ค. ์ž๋™ ํ˜•๋ณ€ํ™˜ ๋ฐœ์ƒ!
double div2 = 1.0;  //1(int) -> 1.0(double)๋กœ ํ˜•๋ณ€ํ™˜๋˜์—ˆ๋‹ค.
double div3 = 3.0 / 2;  //double / int
double div3 = 3.0 / (double) 2;  //double / int์ด๋ฏ€๋กœ, double / double๋กœ ํ˜•๋ณ€ํ™˜์ด ๋ฐœ์ƒํ•œ๋‹ค!
double div3 = 3.0 / 2.0;  //double / double -> double์ด ๋œ๋‹ค!
double div3 = 1.5;
double div4 = (double) 3 / 2;  //๋ช…์‹œ์  ํ˜•๋ณ€ํ™˜์„ ์‚ฌ์šฉํ–ˆ๋‹ค. (double) int / int
double div4 = (double) 3 / (double) 2;  //double + int์ด๋ฏ€๋กœ, double + double๋กœ ํ˜•๋ณ€ํ™˜์ด ๋ฐœ์ƒํ•œ๋‹ค.
double div4 = 3.0 / 2.0;  //double / double -> double์ด ๋œ๋‹ค.
double div4 = 1.5;

3 / 2์™€ ๊ฐ™์ด intํ˜•๋ผ๋ฆฌ ๋‚˜๋ˆ—์…ˆ์„ ํ•ด์„œ ์†Œ์ˆ˜๊นŒ์ง€ ๊ตฌํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด div4์˜ ์˜ˆ์ œ์ฒ˜๋Ÿผ ๋ช…์‹œ์  ํ˜•๋ณ€ํ™˜์„ ์‚ฌ์šฉํ•˜๋ฉด ๋œ๋‹ค.

๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒฝ์šฐ์—๋„ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํ˜•๋ณ€ํ™˜์„ ํ•  ์ˆ˜ ์žˆ๋‹ค.

int a = 3;
int b = 2;
double result = (double) a / b;

์ฒ˜๋ฆฌ ๊ณผ์ •

double result = (double) a / b;  //(double) int / int
double result = (double) 3 / 2;  //๋ณ€์ˆ˜ ๊ฐ’ ์ฝ๊ธฐ
double result = (double) 3 / (double) 2;  double + int ์ด๋ฏ€๋กœ ๋” ํฐ ๋ฒ”์œ„๋กœ ํ˜•๋ณ€ํ™˜
douvle result = 3.0 / 2.0;  //(double / double) -> double์ด ๋œ๋‹ค.
double result = 1.5;

 

์ •๋ฆฌ

ํ˜•๋ณ€ํ™˜

int  โ†’  long  โ†’  double

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