์ค์ฝํ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 m์ main{ } ์ ์ฝ๋ ๋ธ๋ก ์์์ ์ ์ธ๋์๋ค.
- int x
- int x๋ if{ } ๋ธ๋ก ์์์ ์ ์ธ๋์๋ค.
๋ฐ๋ผ์ ๋ณ์๋ฅผ ์ ์ธํ ์์ ๋ถํฐ if{ } ์ ์ฝ๋ ๋ธ๋ก์ด ์ข ๋ฃ๋ ๋๊น์ง ์์กด ๊ฐ๋ฅํ๋ค. - if{ } ๋ด๋ถ์์๋ ์์ ์ ๋ฒ์์์ ์ ์ธํ x์ ๋น์ฐํ ์ ๊ทผํ ์ ์๋ค.
- if{ } ์ฝ๋ ๋ธ๋ก์ด ๋๋๋ฒ๋ฆฌ๋ฉด x๋ ์ ๊ฑฐ๋๋ค. ๋ฐ๋ผ์ ๋๋ x์ ์ ๊ทผํ ์ ์๋ค.
์ดํ์ ์ ๊ทผํ๋ฉด cannot find symbol ์ด๋ผ๋ ๋ณ์ ์ด๋ฆ์ ์ฐพ์ ์ ์๋ค๋ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
- int x๋ if{ } ๋ธ๋ก ์์์ ์ ์ธ๋์๋ค.
์ ๋ฆฌํ๋ฉด ์ง์ญ ๋ณ์๋ ๋ณธ์ธ์ ์ฝ๋ ๋ธ๋ก ์์์๋ง ์์กด ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ์์ ์ ์ฝ๋ ๋ธ๋ก ์์์๋ ์ผ๋ง๋ ์ง ์ ๊ทผํ ์ ์๋ค.
ํ์ง๋ง ์์ ์ ์ฝ๋ ๋ธ๋ก์ ๋ฒ์ด๋๋ฉด ์ ๊ฑฐ๋๊ธฐ ๋๋ฌธ์ ์ ๊ทผํ ์ ์๋ค... ๐ฅฒ๐ฅฒ
์ด๋ ๊ฒ ๋ณ์์ ์ ๊ทผ ๊ฐ๋ฅํ ๋ฒ์๋ฅผ ์ค์ฝํ(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
- ์์ ๋ฒ์์์ ํฐ ๋ฒ์๋ก๋ ๋์
ํ ์ ์๋ค.
- ์ด๊ฒ์ ๋ฌต์์ ํ๋ณํ ๋๋ ์๋ ํ๋ณํ์ด๋ผ ํ๋ค.
- ํฐ ๋ฒ์์์ ์์ ๋ฒ์์ ๋์
์ ๋ค์๊ณผ ๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. ์ด๋๋ ๋ช
์์ ํ๋ณํ์ ์ฌ์ฉํด์ผ ํ๋ค.
- ์์์ ๋ฒ๋ฆผ
- ์ค๋ฒํ๋ก์ฐ
- ์ฐ์ฐ๊ณผ ํ๋ณํ
- ๊ฐ์ ํ์ ์ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๋ธ๋ค.
- ์๋ก ๋ค๋ฅธ ํ์ ์ ๊ณ์ฐ์ ํฐ ๋ฒ์๋ก ์๋ ํ๋ณํ์ด ์ผ์ด๋๋ค.
'๐ Java > ๐ Java ๊ฐ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Java ์ ๋ฌธ ๊ฐ์_๋ฐฐ์ด (0) | 2024.11.07 |
---|---|
Java ์ ๋ฌธ ๊ฐ์_ํ๋ จ (4) | 2024.11.06 |
Java ์ ๋ฌธ ๊ฐ์_๋ฐ๋ณต๋ฌธ (1) | 2024.10.29 |
Java ์ ๋ฌธ ๊ฐ์_์กฐ๊ฑด๋ฌธ (8) | 2024.10.25 |
Java ์ ๋ฌธ ๊ฐ์_์ฐ์ฐ์ (9) | 2024.10.24 |