๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ 3์ฅ 161~163์ชฝ ์ฐ์ต๋ฌธ์  ์ด๋ก ๋ฌธ์ _์ ๋ต
luxury java programming ch3 p161~163 exercise theory correct answer
1๋ฒ
๋ต:
| 
 1 
 | 
 1 3 5 7 9 
 | 
cs | 
1 ์ด์๋ถํฐ 10๋ฏธ๋ง๊น์ง ํ์๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋์ด๋ค.
2๋ฒ
๋ต: 3๋ฒ for(int i = 0; i > 10; i++) sum++;
1. // i๋ 0๋ถํฐ 10๋ฏธ๋ง๊น์ง ๋ชจ๋ ์ ์๋ฅผ ํฉํจ, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
2. // i๋ 9๋ถํฐ 0๋ณด๋ค ํด๋๊น์ง ๋ชจ๋ ์ ์๋ฅผ ํฉํจ, 9, 8, 7, 6, 5, 4, 3, 2, 1
3. // i๋ 0๋ถํฐ 10๋ณด๋ค ํด ๋์ ๋ณ์ sum์ +1, i๋ 0๋ถํฐ ์์์ด๋ฏ๋ก ๋ฐ๋ณต๋ฌธ์ ์กฐ๊ฑด์์ธ i>10์ด ๊ฑฐ์ง์ด ๋์ด ์คํ๋ฌธ์ฅ์ด ํ ๋ฒ๋ ์คํ๋์ง ์๋๋ค.
4. // i๋ 0๋ถํฐ 10๋ฏธ๋ง๊น์ง ๋ชจ๋ ์ ์๋ฅผ ํฉํจ, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
3๋ฒ
๋ต: continue;
// continue;๋ฌธ์ ๋ฐ๋ณต๋ฌธ์ ๋น ์ ธ๋๊ฐ์ง ์์ผ๋ฉด์, ๋ค์ ๋ฐ๋ณต์ ์งํํ๋ค. while๋ฌธ์์ continue;๋ฌธ์ ๋ง๋๋ฉด ์กฐ๊ฑด์์ผ๋ก ๋ถ๊ธฐํ๋ค.
4๋ฒ
๋ต: i > 50
// ๋ฌดํ๋ฐ๋ณต์ ๋น ์ง์ง ์๋๋ก ๋น ์ ธ๋๊ฐ๋ ์กฐ๊ฑด์ ์ ์์ฑํด์ผ ํ๋ค.
5๋ฒ
๋ต: 4๋ฒ int n[3] = new int [3]; // ๋ฐฐ์ด ์ ์ธ ์ ํฌ๊ธฐ๋ฅผ ์ง์ ํ์ง ์์ int n[] = new int[3];์ด ์ณ์ ํํ์ด๋ค.
1. O // ๋ฐฐ์ด ์ ์ธ ๋์์ ์ด๊ธฐํ ๋ธ๋ญ์ผ๋ก ๊ฐ ์ด๊ธฐํ ์ new ์ฐ์ฐ์๋ก ๋ฐ๋ก ๋ฐฐ์ด ์์ฑํ ํ์ ์๋ค.
2. O // ๋ฐฐ์ด ์ ์ธ ๋์์ ์ด๊ธฐํ ๋ธ๋ญ์ผ๋ก ๊ฐ ์ด๊ธฐํ ์ new ์ฐ์ฐ์๋ก ๋ฐ๋ก ๋ฐฐ์ด ์์ฑํ ํ์ ์๋ค.
3. O // ํฌ๊ธฐ๊ฐ 3์ธ intํ ๋ฐฐ์ด ์ ์ธ ๋ฐ ์์ฑ
4. X // C/C++๊ณผ ๋ฌ๋ฆฌ ์๋ฐ์์๋ ๋ฐฐ์ด ์ ์ธ ์ ํฌ๊ธฐ ์ง์ ์ ํ ์ ์๋ค.
6๋ฒ
๋ต: 4๋ฒ array[array.length] = 100;
// ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํด์ ํฌ๊ธฐ-1๊น์ง์ ๋ฒ์๋ฅผ ๊ฐ๋๋ค. ๋ฐฐ์ด array์ ์ธ๋ฑ์ค๋ 0๋ถํฐ 4๊น์ง๋ง ๊ฐ๋ฅํ๋ฐ array[5]๋ก ์ธ๋ฑ์ค์ ๋ฒ์์์ ๋ฒ์ด๋ ArrayIndexOutOfBounds ์์ธ๊ฐ ๋ฐ์ํ๋ค.
1. O // ๋ฐฐ์ด array์ 0๋ฒ์งธ ์์์ -1 ๋์
2. O // intํ ๋ฐฐ์ด ๋ ํผ๋ฐ์ค list์ ๋ฐฐ์ด array์ ๋ ํผ๋ฐ์ค ๊ฐ ๋์ , 1๊ฐ์ ๋ฐฐ์ด ๊ฐ์ฒด๋ฅผ ์ฌ๋ฌ๊ฐ์ ๋ฐฐ์ด ๋ ํผ๋ฐ์ค๊ฐ ์ฐธ์กฐํ ์ ์๋ค.
3. O // ๋ฐฐ์ด array์ 4๋ฒ์งธ ์์์ ์ ์ฅ๋ ๊ฐ 5๋ฅผ ์ถ๋ ฅํ๋ค.
7๋ฒ
(1) ๋ต:
| 
 1 
 | 
 char[] c = new char[10]; 
 | 
cs | 
๋๋
| 
 1 
 | 
 char c[] = new char[10]; 
 | 
cs | 
(2) ๋ต:
| 
 1 
2 
3 
4 
5 
 | 
 int[] n = new int[6]; 
for(int i = 0; i < n.length; i++) { 
    n[i] = i; 
} 
 | 
cs | 
๋๋
| 
 1 
 | 
 int[] n = {0, 1, 2, 3, 4, 5}; 
 | 
cs | 
๋๋
| 
 1 
 | 
 int[] n = new int[]{0, 1, 2, 3, 4, 5,}; 
 | 
cs | 
(3) ๋ต:
| 
 1 
 | 
 char[] day = {'์ผ', '์', 'ํ', '์', '๋ชฉ', '๊ธ', 'ํ '}; 
 | 
cs | 
// ์์ ๋ฐ์ดํ๋ก ๋๋ฌ์ธ์ฌ์๋ ๋ฆฌํฐ๋ด์ ๋ฌธ์์ด์ด ์๋ ๋ฌธ์์ด๋ค. ๊ทธ๋ฌ๋ฏ๋ก charํ ๋ฐฐ์ด์ ์ ์ฅํด์ผํ๋ค.
8๋ฒ
(1) ๋ต:
| 
 1 
2 
3 
4 
5 
 | 
 boolean[] bool = new boolean[4]; 
bool[0] = true; 
bool[1] = false; 
bool[2] = false; 
bool[3] = true; 
 | 
cs | 
๋๋
| 
 1 
 | 
 boolean[] bool = {true, false, false, true}; 
 | 
cs | 
(2) ๋ต:
| 
 1 
 | 
 double[][] d = new double[5][4]; 
 | 
cs | 
๋๋
| 
 1 
 | 
 double d [][]= new double[5][4]; 
 | 
cs | 
(3) ๋ต:
| 
 1 
2 
3 
4 
5 
 | 
 int[][] val = { 
        {1, 2, 3, 4}, 
        {5, 6, 7, 8}, 
        {9, 10, 11, 12} 
}; 
 | 
cs | 
๋๋
| 
 1 
2 
3 
4 
5 
 | 
 int[][] val = new int[][]{ 
        {1, 2, 3, 4}, 
        {5, 6, 7, 8}, 
        {9, 10, 11, 12} 
}; 
 | 
cs | 
9๋ฒ
(1) ๋ต:
| 
 1 
2 
3 
 | 
 int myArray[]; 
myArray[0] = 1;                     // ์ด ๋ถ๋ถ์์ ์ปดํ์ผ ์ค๋ฅ ๋ฐ์ 
myArray[1] = myArray[0] + 1; 
 | 
cs | 
์ค๋ฅ์ ๋ฐ์ ์์ธ // ์์ง myArray ๋ฐฐ์ด์ด ์ ์ธ๋ง ๋๊ณ ์์ฑ์ ๋์ง ์์๋๋ฐ, ๋ฐฐ์ด ์์์ ์ ๊ทผํ์ฌ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ์๋ค.
// myArray๋ ๋ฐฐ์ด ์์ฒด๊ฐ ์๋, intํ ๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค ๋ณ์์ด๋ค.
(2) ๋ต:
| 
 1 
2 
3 
 | 
 int myArray[] = new int[2];         // ํฌ๊ธฐ๊ฐ 2์ธ intํ ๋ฐฐ์ด์ ์์ฑํ์๋ค. 
myArray[0] = 1;                      
myArray[1] = myArray[0] + 1; 
 | 
cs | 
// ์์ง myArray ๋ฐฐ์ด์ด ์์ฑ๋์ง ์์๋๋ฐ, ๋ฐฐ์ด ์์์ ์ ๊ทผํ์ฌ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ์์ผ๋ฏ๋ก new ์ฐ์ฐ์๋ก ๋ฐฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ค ๋์ ํ์๋ค.
10๋ฒ
(1) ๋ต:
| 
 1 
 | 
 int i = 0; i < alpha.length; i++ 
 | 
cs | 
// System.out.print() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ, alpha[i]๋ฅผ ์ถ๋ ฅํ๋ค.
// ๋ฐฐ์ด์ ๋ฐ๋ณต ํ์๋ฅผ ์ ์ดํ ๋, ๋งค์ง ๋๋ฒ๋ฅผ ์ฌ์ฉํ ํ๋ ์ฝ๋ฉ ๋ณด๋ค๋ length ํ๋๋ก ์ ์ดํ๋ ๊ฒ์ด ๋ ์ข์ ์ฝ๋์ด๋ค.
(2) ๋ต:
| 
 1 
 | 
 char c : alpha 
 | 
cs | 
// System.out.print() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ, ๋ณ์ c๋ฅผ ์ถ๋ ฅํ๋ฏ๋ก for each๋ฌธ์ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
11๋ฒ
๋ต:
| 
 1 
 | 
 1 3 1 4 2 
 | 
cs | 
| 
 1 
2 
3 
4 
5 
6 
7 
 | 
 public class P163_11 {                                          // P163_11 ํด๋์ค ์ ์ ์์ 
    public static void main(String[] args) {                    // main() ๋ฉ์๋ ์ ์ ๋ 
        int n[][] = {{1}, {1, 2, 3}, {1}, {1, 2, 3, 4}, {1, 2}};// 2์ฐจ์ intํ ๋ฐฐ์ด n ์ ์ธ ๋์์ ์ด๊ธฐํ ๋ธ๋ญ์ผ๋ก ์ด๊ธฐํํ์ฌ ๋ฐฐ์ด ์์ฑ 
        for(int j = 0; j < n.length; j++)                       // intํ ๋ณ์ j ์ ์ธ ๋์์ 0 ๋์
ํ์ฌ ์ด๊ธฐํ, j๊ฐ ๋ฐฐ์ด n์ ํ์ ํฌ๊ธฐ๋ณด๋ค ์์ ๋์ ๋ฐ๋ณต, j์ +1 
            System.out.print(n[j].length + " ");               // System.out.print() ๋ฉ์๋ ํธ์ถํ์ฌ ๋ฐฐ์ด n์ j๋ฒ์งธ ํ์ ์ด์ ํฌ๊ธฐ ์ถ๋ ฅ 
    }                                                           // main() ๋ฉ์๋ ์ ์ ๋ 
}                                                               // P163_11 ํด๋์ค ์ ์ ๋  
 | 
cs | 
// ๋ฐฐ์ด n์ ์ธ๋ฑ์ค j๋ฒ์งธ ํ์ ์ด์ ํฌ๊ธฐ๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋์ด๋ค.
12๋ฒ
๋ต:
| 
 1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 
21 
22 
23 
24 
25 
26 
27 
28 
29 
30 
31 
32 
33 
34 
35 
36 
37 
38 
39 
40 
41 
42 
43 
 | 
 public class P163_12 { 
    public static void main(String[] args) { 
        // 2์ฐจ์ ๋น์ ๋ฐฉํ ๋ฐฐ์ด 
        // ๋ฐฉ๋ฒ 1 
        double[][] array = new double[4][]; 
        array[0] = new double[4]; 
        array[1] = new double[2]; 
        array[2] = new double[3]; 
        array[3] = new double[1]; 
        array[0][0] = 1.1; 
        array[0][1] = 1.2; 
        array[0][2] = 1.2; 
        array[0][3] = 1.4; 
        array[1][0] = 2.1; 
        array[1][1] = 2.2; 
        array[2][0] = 3.1; 
        array[2][1] = 3.2; 
        array[2][2] = 1.2; 
        array[3][0] = 4.1; 
        // ๋ฐฉ๋ฒ 2 
        double[][] array2 = new double[][]{ 
                {1.1, 1.2, 1.2, 1.4}, 
                {2.1, 2.2}, 
                {3.1, 3.2, 1.2}, 
                {4.1} 
        }; 
        // == 
        double[][] array3 = { 
                {1.1, 1.2, 1.2, 1.4}, 
                {2.1, 2.2}, 
                {3.1, 3.2, 1.2}, 
                {4.1} 
        }; 
    } 
} 
 | 
cs | 
13๋ฒ
๋ต: 1๋ฒ ์ํ์ public abstract void main(String[] args)์ด๋ค.
1. X // main() ๋ฉ์๋๋ public static void main(String[] args) ํ์์ด๋ค.
2. O // main() ๋ฉ์๋๋ ์๋ฐ ํ๋ก๊ทธ๋จ์ ์์์ด๋ค.
3. O // ๋ช ๋ นํ ์ธ์์ธ abc 5๋ ๊ฐ๊ฐ ๋ฌธ์์ด๋ก ๋ง๋ค์ด์ง๊ณ ๋ฌธ์์ด ๋ฐฐ์ด์ ์ ์ฅํ์ฌ ๊ทธ ๋ฐฐ์ด์ ๋ ํผ๋ฐ์ค ๊ฐ์ด main() ๋ฉ์๋์ ๋งค๊ฐ๋ณ์ args์ ์ ๋ฌ๋๋ค.
4. O // main() ๋ฉ์๋๊ฐ ์์ผ๋ฉด ์คํ ์์ ํ ๋ฐ๋ก ์ค๋ฅ๋ฅผ ๋ด๋ฉด์ ์ข ๋ฃํ๋ค.
// C:\Workspaces\luxury_java_programming_review1\_03_loop_array_and_exception\src\main\java\com\sh\exercise\theory> java Hello abc 5
์ค๋ฅ: ๊ธฐ๋ณธ ํด๋์ค Hello์(๋ฅผ) ์ฐพ๊ฑฐ๋ ๋ก๋ํ ์ ์์ต๋๋ค.
์์ธ: java.lang.ClassNotFoundException: Hello
// ์๋ฐ ํ๋ก๊ทธ๋จ์ main() ๋ฉ์๋๋ถํฐ ์์๋๋ฏ๋ก, main() ๋ฉ์๋๊ฐ ์๋ ํด๋์ค๋ถํฐ ๋ก๋ฉ๋๋๋ฐ main() ๋ฉ์๋๊ฐ Hello ํด๋์ค์ ์์ผ๋ฏ๋ก ์๋ฐ ํ๋ก๊ทธ๋จ์ด ์คํ๋์ง ๋ชปํ๋ค.
14๋ฒ
๋ต: ์ปดํ์ผ๋ฌ, ์์ธ, ๋ฐ๋ก ์ข ๋ฃ, try, catch, finally
// ์ปดํ์ผ ์๋ฌ๋ ๋ฌธ๋ฒ ์ค๋ฅ์ด๋ค.
// ์์ธ๊ฐ ๋ฐ์ํ๋ฉด JVM ๊ทธ์ ๊ดํ ์ ๋ณด๋ค์ ๊ฐ์ฒด์ ๋ด์ ๋ฆฌํดํ๋ค.
// ์์ธ ์ฒ๋ฆฌํ ํ์ ๋ณ๋ก catch ๋ธ๋ก์ ์์ฑํด์ผํ๋ค. ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ, ์ฐ์์ ์ผ๋ก catch ๋ธ๋ก ์์ฑ์ด ๊ฐ๋ฅํ๋ค.