[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 3์ฅ ์์ฝ & ์ ๋ฆฌ
3์ฅ ๋ฐ๋ณต๋ฌธ๊ณผ ๋ฐฐ์ด ๊ทธ๋ฆฌ๊ณ ์์ธ์ฒ๋ฆฌ
1. ๋ฐ๋ณต๋ฌธ
for(์ด๊ธฐ๋ฌธ; ์กฐ๊ฑด์; ๋ฐ๋ณต ํ ์์
๋ฌธ) {
์คํ๋ฌธ์ฅ;
}
์ด๊ธฐ๋ฌธ์ ๋ฐ๋ณต ์ ์ด ๋ณ์ ์ ์ธ ๊ฐ๋ฅ
์ด๊ธฐ๋ฌธ๊ณผ ๋ฐ๋ณต ํ ์์
๋ฌธ์ ,๋ก ๊ตฌ๋ถํ์ฌ ์ฌ๋ฌ ๋ฌธ์ฅ ๋์ด ๊ฐ๋ฅ
๋น์ํ๋ก ๋์ด๋ ๋์ง๋ง ๋์ ์ธ๋ฏธ์ฝ๋ก ์ ์์ด์ผ ํจ
๋ณ์๋ฅผ ์ด๊ธฐ๋ฌธ์ ์ ์ธํ๋ฉด for๋ฌธ ๋ธ๋ญ ๋ด์์๋ง ์ฌ์ฉ๋๋ ์ง์ญ ๋ณ์๋ก ์ ์ธํ์ฌ ์ฌ์ฉํ ์ ์์
๋ฌดํ๋ฐ๋ณต
1. ์กฐ๊ฑด์์ ๋
ผ๋ฆฌ ๋ฆฌํฐ๋ด true;
2. ์กฐ๊ฑด์์ ๋น์๋ ; ;
while(์กฐ๊ฑด์){
์คํ๋ฌธ์ฅ;
}
do
{
์คํ๋ฌธ์ฅ;
} while(์กฐ๊ฑด์);
while๋ฌธ ๋์๋ ์ธ๋ฏธ์ฝ๋ก ์ด ์์ง๋ง, do while๋ฌธ ๋์๋ ์ธ๋ฏธ์ฝ๋ก ์ด ์์ด์ผ ํจ
while, do-while๋ฌธ ์กฐ๊ฑด์์ ์ฌ์ฉ๋ ๋ฐ๋ณต ์ ์ด ๋ณ์๋ ๊ทธ ์ ์ ์ ์ธ๋์ด ์์ด์ผ ํจ
while, do-while๋ฌธ ๋ฌดํ๋ฐ๋ณต์ ํํํ๊ธฐ ์ํด ์กฐ๊ฑด์์ ๋น์๋๋ฉด ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์
do-while๋ฌธ์ ๋ค๋ฅธ ๋ฐ๋ณต๋ฌธ๊ณผ ๋ฌ๋ฆฌ, ์์ ๋ฌธ์ด ์ต์ด ํ๋ฒ์ ๋ฐ๋์ ์คํ๋จ
์ฒ์๋ถํฐ ๋ฐ๋ณต ํ์๋ ๋ฒ์๊ฐ ๋ช ํํ ๊ฒฝ์ฐ์๋ for๋ฌธ, ๋ฐ๋ณต ํ์๋ฅผ ์ฒ์๋ถํฐ ์ ์ ์๊ณ , ๋ฐ๋ณต์ด ์งํ๋๋ฉด์ ํ๊ฐ๋์ด์ผ ํ๋ ๊ฒฝ์ฐ while, do-while๋ฌธ ์ฌ์ฉ
์ค์ฒฉ๋ฐ๋ณต๋ฌธ
์ค์ฒฉ ๋ฐ๋ณต๋ฌธ // ๋ฐ๋ณต๋ฌธ ์์ ๋ค๋ฅธ ๋ฐ๋ณต๋ฌธ์ด ์๋ ๊ตฌ์กฐ
์ด๋ก ์ ์ผ๋ก๋ ํ์์ ํ ์์ง๋ง, ๋๋ฌด ๋ง์ ์ค์ฒฉ์ ํ๋ก๊ทธ๋จ์ ๋ณต์กํ๊ฒ ๋ง๋๋ฏ๋ก 2, 3์ค ๋ฐ๋ณต๋ฌธ์ด ์ ๋น
๊ตฌ๊ตฌ๋จ ์์ ์ ๋ช
2. break;, continue;, ๋ผ๋ฒจ:
break; // ํ๋ก๊ทธ๋จ์์ break;๋ฌธ์ ๋ง๋๋ฉด ์๊ธฐ์์ ์ ๋๋ฌ์ธ๊ณ ์๋ ๋ธ๋ก {} ์ผ๋ก๋ถํฐ ๋ฒ์ด๋๋ค.
continue; // ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ๋๊ฐ์ง ์์ผ๋ฉด์ ๋ค์ ๋ฐ๋ณต์ผ๋ก ์งํ
for๋ฌธ์ ๋ฐ๋ณต ํ ์์
๋ฌธ, whilen๋ฌธ์ ์กฐ๊ฑด์, do-while๋ฌธ๋ ์กฐ๊ฑด์์ผ๋ก ๋ถ๊ธฐ
๋ฐ๋ณต๋ฌธ์ label๋ฅผ ๋ถ์ผ ์ ์๋ค. // ๋ผ๋ฒจ์ด๋ฆ:, break ๋ผ๋ฒจ์ด๋ฆ;, continue ๋ผ๋ฒจ์ด๋ฆ;
while๋ฌธ์์ ๋ฒ์ด๋๊ธฐ ๋
ธํ์ฐ
while๋ฌธ์ ์กฐ๊ฑด์์ true๋ฅผ ์์ฑํ์ฌ ์ผ๋จ ๋ฌดํ ๋ฐ๋ณตํ๋ ๋ฐ๋ณต๋ฌธ์ ์์ฑํ๋ค. ๊ทธ๋ฆฌ๊ณ while๋ฌธ์ ๋ฒ์ด๋๋ ์กฐ๊ฑด์ if๋ฌธ์ผ๋ก ์์ฑํ ๋ค, break;๋ฌธ์ผ๋ก ๋น ์ ธ๋๊ฐ๋ค.
ex) while(!(n % 5 == 0 || n < 0)) ์์
while(true) {
if(n%5 ==0) break;
if(n<0) break;
}
3. ๋ฐฐ์ด
๋ฐฐ์ด // C/C++๊ณผ ๋ฌธ๋ฒ์ด ๋ค๋ฆ
์ธ๋ฑ์ค์ ์ธ๋ฑ์ค์ ๋์ํ๋ ๋ฐ์ดํฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์๋ฃ๊ตฌ์กฐ
๊ฐ์ ํ์
์ ๋ฐ์ดํฐ๋ค์ด ์์ฐจ์ ์ผ๋ก ์ ์ฅ
์ธ๋ฑ์ค๋ 0๋ถํฐ ์์
๋ฐฐ์ด์ ์ ์ธ ๋ฐ ์์ฑ
int[] i = new int[10]; // intํ ๊ฐ์ ์ ์ฅํ๋ ํฌ๊ธฐ๊ฐ 10์ธ ๋ฐฐ์ด i ์ ์ธ ๋ฐ ์์ฑ
์๋ฐ์์๋ ๋ฐฐ์ด์ ๊ฐ์ฒด๋ก ๋ค๋ฃธ // new ํค์๋๋ก ์์ฑ, new๋ ๊ฐ์ฒด๋ฅผ ๋ง๋๋ ์ฐ์ฐ์int i[10]; // C์ธ์ด์ ๋ฌ๋ฆฌ, ๋ฐฐ์ด(์ ๋ํ ๋ ํผ๋ฐ์ค ๋ณ์)์ ์ธ ์ ํฌ๊ธฐ ์ง์ ํ ์ ์๋ค.
int[] i = new int[] {1, 2, 3, 4, 5, 6}; == int[] i = {1, 2, 3, 4, 5, 6};
// ๋ฐฐ์ด์ ์ ์ธํ๊ณ ๋์์ ์ด๊ธฐํ ๋ธ๋ก์ผ๋ก ์ด๊ธฐํํ๋ฉด, new๋ก ๋ฐ๋ก ๋ฐฐ์ด ๊ฐ์ฒด์ ์์ฑ์ ํ ํ์ ์๋ค.
int[] i;
i = new int[] {1, 2, 3, 4, 5, 6}; // ์ด๋ฏธ ์ ์ธ๋ ๋ฐฐ์ด์ ์ด ๋ฐฉ๋ฒ์ผ๋ก๋ง ์ด๊ธฐํ ๋ธ๋ญ์ ์ฌ์ฉํ ์ ์๋ค.
ํ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๋ณ์ ์ ์ธํ ๋ ์ ์ฒด๋ ์ด๋ฆ์ ์ผ์ชฝ์ ๋ค ๋ชฐ์์ ์ด๋ค.
์ด๋ฆ์ ์ผ์ชฝ์ ์ ์ฒด๋ฅผ ํํํ int[] intArray;๊ฐ int intArray[]; ๋ณด๋ค ๋ ์ข์ ํํ๋ฒ์ด๋ค.
int[] intArray; // intArray๋ ๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค ๊ฐ์ ๊ฐ์ง๋ฉฐ, ๊ทธ ์์ฒด๊ฐ ๋ฐฐ์ด์ ์๋๋ค. ์์ง ์ ์๋ฅผ ์ ์ฅํ ๋ฐฐ์ด ๊ณต๊ฐ์ด ์์ฑ๋์ง ์์์ผ๋ฏ๋ก intArray ๊ฐ์ null์ด๋ค.
4. ๋ฐฐ์ด ์์ ์ ๊ทผ
๋ฐฐ์ด ์์ ์ ๊ทผ // [] ์์ ์ธ๋ฑ์ค ๋ฃ์ด ์ง์ ์ ๊ทผ
๋ฐฐ์ด ์์ฑํ ํ์ ์์์ ์ ๊ทผ์ด ๊ฐ๋ฅ
์ธ๋ฑ์ค ๋ฒ์ ์ฃผ์ // 0๋ถํฐ ์์, ํฌ๊ธฐ -1๊น์ง, ์์ ๋ถ๊ฐ
๋ฐฐ์ด ๊ฐ์ฒด ๋ด length ํ๋ // ๋ฐฐ์ด์ ํฌ๊ธฐ
int[] intArray = new int[5];
int[] myArray = intArray;
// ํ ๊ฐ์ ๋ฐฐ์ด์ ์ฌ๋ฌ ๊ฐ์ ๋ฐฐ์ด ๋ ํผ๋ฐ์ค๊ฐ ์ฐธ์กฐ ๊ฐ๋ฅ
// ์ด ์นํ์ผ๋ก ๋ฐฐ์ด์ด ๋ณต์ฌ๋๋ ๊ฒ์ด ์๋๋ผ, ๋ ํผ๋ฐ์ค๋ง ๋ณต์ฌ๋จ
for-each๋ฌธ // ๋ฐฐ์ด์ด๋ ๋์ด์ ๊ฐ ์์๋ฅผ ์์ฐจ์ ์ผ๋ก ์ ๊ทผ ํ๋๋ฐ ์ ์ฉํ for๋ฌธ
int[] num = {1, 2, 3, 4, 5};
for(int k : num) // ๋ฐ๋ณต๋ ๋๋ง๋ค k๋ num[0], num[1], ..., num[4] ๊ฐ์ผ๋ก ์ค์ ๋จ
sum += k; // k๋ num์ด๋ผ๋ ๋ฐฐ์ด์ ์์์ ์์ํํ
System.out.println(”ํฉ์ “ + sum);
enum ํค์๋ ์ฌ์ฉํ์ฌ enum ์์ฑ
enum์ .values() ๋ฉ์๋ ์ฌ์ฉ // ๋ฐฐ์ด์ด ์๋๋ฏ๋ก []๋ก ์์์ ์ง์ ์ ๊ทผํ ์ ์์
enum Week {์, ํ, ์, ๋ชฉ, ๊ธ, ํ , ์ผ}
for(Week day : Week.values()) // ๋ฐ๋ณต๋ ๋๋ง๋ค day๋ ์, ํ, ์ ... ์ผ
System.out.print(day + “์์ผ ”);
5. ๋ค์ฐจ์ ๋ฐฐ์ด
๋ค์ฐจ์ ๋ฐฐ์ด // ์ฃผ๋ก 2์ฐจ์ ๋ฐฐ์ด ์ฌ์ฉ
int[][] i = new int[2][5]; // intํ ๊ฐ์ ์ ์ฅํ๋ ํฌ๊ธฐ๊ฐ 2ํ 5์ด์ธ ๋ฐฐ์ด i ์ ์ธ ๋์์ ์์ฑ
int[][] intArray = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}; // ๋ฐฐ์ด์ ์ ์ธํ๊ณ ๋์์ ์ด๊ธฐํ ๋ธ๋ญ์ผ๋ก ๊ฐ์ ์ด๊ธฐํํ๋ฉด new ์ฐ์ฐ์๋ก ๋ฐ๋ก ๋ฐฐ์ด ๊ฐ์ฒด์ ์์ฑ์ ํ ํ์ ์๋ค.
๋ฐฐ์ด ๊ฐ์ฒด๊ฐ ์ด 3๊ฐ๊ฐ ๋ง๋ค์ด์ง๋ค.
// ํ ๋ฐฐ์ด 1๊ฐ, ๊ฐ ํ์ ๋ํ ์ด ๋ฐฐ์ด 2๊ฐ
// ํ์ ๊ฐ ์์๋ ์ด ๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค๊ฐ ๋๋ค.
2์ฐจ์ ๋ฐฐ์ด์ length ํ๋ // ์๋ฐ์์๋ ๋น์ ๋ฐฉํ ๋ฐฐ์ด ๋๋ฌธ์ length ํ๋๋ก ๋ฐ๋ณต๋ฌธ์ ์ ์ดํ๋ค.
i.length // 2์ฐจ์ ๋ฐฐ์ด i์ ํ์ ๊ฐ์, 2
i[n].length // 2์ฐจ์ ๋ฐฐ์ด i์ n๋ฒ์งธ ํ์ ์ด์ ๊ฐ์
์ ๋ฐฉํ ๋ฐฐ์ด // ๊ฐ ํ์ ๋ํ ์ด์ ๊ฐ์๊ฐ ๊ฐ์ ๋ฐฐ์ด
๋น์ ๋ฐฉํ ๋ฐฐ์ด // ๊ฐ ํ์ ๋ํ ์ด์ ๊ฐ์๊ฐ ๋ค๋ฅธ ๋ฐฐ์ด
๋น์ ๋ฐฉํ ๋ฐฐ์ด์ ์์ฑ // ํ์ ๋ํ ๋ฐฐ์ด ๊ฐ์ฒด ๋จผ์ ์์ฑํ๊ณ , ๊ฐ ํ์ ๋ํ ์ด ๋ฐฐ์ด ๊ฐ์ฒด ์์ฑํ์ฌ ๋์
ํ๋ค.
int[][] i = new int[4][];
i[0] = new int[1];
i[1] = new int[2];
i[2] = new int[3];
i[3] = new int[4];
6. ๋ฉ์๋์ ๋ฐฐ์ด ๋ฆฌํด
๋ฉ์๋์ ๋ฐฐ์ด ๋ฆฌํด // ๋ฐฐ์ด์ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฆฌํด
๋ฉ์๋ ์ ์ธ๋ถ์ ๋ฆฌํด ํ์
๊ณผ ๋ฉ์๋ ๋ด๋ถ์ ๋ฆฌํด๋ฌธ์ ๋ฆฌํด ํ์
์ด ์ผ์น ํด์ผํจ
int[] makeArray() {
int[] temp = new int[4];
return temp;
}
main() ๋ฉ์๋๋ ์๋ฐ ํ๋ก๊ทธ๋จ์ด ์คํ์ ์์ํ ๋, JVM์ ์ํด ํธ์ถ๋์ด์ผ ํ๋ฏ๋ก public์ผ๋ก ์ ์ธ๋์ด์ผ ํ๋ค.
main() ๋ฉ์๋๋ ์์ ์ ํฌํจํ๋ ํด๋์ค์ ๊ฐ์ฒด๊ฐ ์์ฑ๋๊ธฐ ์ ์, ์ฒ์๋ถํฐ JVM์ ์ํด ํธ์ถ๋๋ฏ๋ก static์ผ๋ก ์ ์ธ๋์ด์ผ ํ๋ค.
String[] args๋ main() ๋ฉ์๋์ ์ธ์๋ฅผ ์ ๋ฌํ๋ ๋ฐฉ๋ฒ // main() ๋ฉ์๋๊ฐ ์์๋๊ธฐ ์ , ๋ช ๋ นํ ์ธ์๋ค์ ๊ฐ๊ฐ ๋ฌธ์์ด๋ก ๋ง๋ค์ด์ง๊ณ , ๋ฌธ์์ด ๋ฐฐ์ด์ ์ ์ฅ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฌธ์์ด ๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค๊ฐ main() ๋ฉ์๋์ ๋งค๊ฐ๋ณ์ args์ ์ ๋ฌ๋๋ค.
7. ์์ธ์ฒ๋ฆฌ
์ปดํ์ผ ์๋ฌ compile error // ๋ฌธ๋ฒ ์ค๋ฅ, ์ปดํ์ผํ ๋ ๋ฐ๊ฒฌ
์์ธ exception // ์ค๋์์ด๋ ๊ฒฐ๊ณผ์ ์ ์ํฅ์ ๋ฏธ์น ์ ์๋ ์ค๋ฅ, ์คํ ์ค ๋ฐ์
์คํ์๊ฐ ์ค๋ฅ run time error // ์กฐ๊ฑด์ด ์๋ชป ์์ฑ๋ ๋ฐ๋ณต๋ฌธ์ด ๋ฌดํ๋ฃจํ๋ฅผ ์คํํ๊ฑฐ๋, recursion์ ์ ์ดํ๋ ์ฝ๋๋ฅผ ์๋ชป ์์ฑํ์ฌ ์คํ์ด ๊ณ์ ์์ฌ(์คํ ์ค๋ฒํ๋ก์ฐ) JVM์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๋๊น์ง ์คํ๋๋ ๋ฑ ์์ธกํ ์ ์๊ณ ๊ฐ์ ๋ก ํ๋ก๊ทธ๋จ์ ์ข ๋ฃ์ํค์ง ์์ผ๋ฉด ๋ฉ์ถ์ ์๋ ๊ฒฝ์ฐ์ด๋ค.
์์ธ exception // ์คํ์๊ฐ ์ค๋ฅ ์ค ์ ์ดํ ์ ์๋ ๊ฒฝ์ฐ์ด๋ค.
์์ธ ๋ฐ์ ์ ์์ฉํ๋ก๊ทธ๋จ์์ ๊ฐ์ฒด์ ์ ๋ณด๋ฅผ ๋ด์ ๋ฆฌํด
์์ธ์ฒ๋ฆฌ ์ฝ๋๊ฐ ์์ผ๋ฉด ๊ฐ์ ์ข
๋ฃ๋จ
try {
์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ ์คํ๋ฌธ
}
catch(์ฒ๋ฆฌํ ์์ธ ํ์
์ ์ธ) {
์์ธ ์ฒ๋ฆฌ๋ฌธ
}
finally { // ์๋ต ๊ฐ๋ฅ, ์๋ฐ์๋ง ์๊ณ , C/C++์๋ ์๋ค.
๋ฌด์กฐ๊ฑด ์คํ๋๋ ๋ฌธ์ฅ
}
์์ธ ํ์ (์์ธ ํด๋์ค) | ์์ธ ๋ฐ์ ๊ฒฝ์ฐ | ํจํค์ง |
ArithmeticException | ์ ์๋ฅผ 0์ผ๋ก ๋๋ ๋ ๋ฐ์ | java.lang |
NullPointerException | null ๋ ํผ๋ฐ์ค๋ฅผ ์ฐธ์กฐํ ๋ ๋ฐ์ | java.lang |
ClassCastException | ๋ณํํ ์ ์๋ ํ์ ์ผ๋ก ๊ฐ์ฒด๋ฅผ ๋ณํํ ๋ ๋ฐ์ | java.lang |
OutOfMemoryError | ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๊ฒฝ์ฐ ๋ฐ์ | java.lang |
ArrayIndexOutOfBoundsException | ๋ฐฐ์ด์ ๋ฒ์๋ฅผ ๋ฒ์ด๋ ์ ๊ทผ ์ ๋ฐ์ | java.lang |
IllegalArgumentException | ์๋ชป๋ ์ธ์ ์ ๋ฌ ์ ๋ฐ์ | java.lang |
IOException | ์ ์ถ๋ ฅ ๋์ ์คํจ ๋๋ ์ธํฐ๋ฝํธ ์ ๋ฐ์ | java.io |
NumberFormatException | ๋ฌธ์์ด์ด ๋ํ๋ด๋ ์ซ์์ ์ผ์นํ์ง ์๋ ํ์ ์ ์ซ์๋ก ๋ณํ ์ ๋ฐ์ | java.lang |
InputMismatchException | Scanner ํด๋์ค์ nextInt()๋ฅผ ํธ์ถํ์ฌ ์ ์๋ก ์ ๋ ฅ๋ฐ๊ณ ์ ํ์์ง๋ง, ์ฌ์ฉ์๊ฐ 'a' ๋ฑ๊ณผ ๊ฐ์ด ๋ฌธ์๋ฅผ ์ ๋ ฅํ ๊ฒฝ์ฐ | java.util |
'1. Java ์๋ฐ > 1_0. ์ฑ , ๊ฐ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 1์ฅ 37์ชฝ ์ฒดํฌ ํ์_์ ๋ต (0) | 2022.05.18 |
---|---|
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 1์ฅ 29์ชฝ ์ฒดํฌ ํ์_์ ๋ต (0) | 2022.05.18 |
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 2์ฅ ์์ฝ & ์ ๋ฆฌ (0) | 2022.05.18 |
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 1์ฅ ์์ฝ & ์ ๋ฆฌ (0) | 2022.05.18 |
[๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ] 0์ฅ ์์ฝ & ์ ๋ฆฌ (0) | 2022.05.18 |