๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ 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 ๋ธ๋ก ์์ฑ์ด ๊ฐ๋ฅํ๋ค.