๋ช ํ ์๋ฐ ํ๋ก๊ทธ๋๋ฐ 4์ฅ 236~240์ชฝ ์ฐ์ต๋ฌธ์ ์ด๋ก ๋ฌธ์ _์ ๋ต
luxury java programming ch4 p236~240 exercise theory correct answer
1๋ฒ
๋ต: 4๋ฒ ํ๋๋ ํด๋์ค ๋ด์์ private ๋ณด๋ค public์ผ๋ก ์ ์ธํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค.
1๋ฒ O // ์๋ฐ๋ ํด๋์ค ์์ ํ๋์ ๋ฉ์๋๋ฅผ ์ ์ธํ๋ค. ํด๋์ค ๋ฐ์๋ ์ด๋ค ์ฝ๋๋ ์์ฑํ ์ ์๋ค.
2๋ฒ O // ํด๋์ค๋ ๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ธฐ ์ํ ํ์ด๋ค.
3๋ฒ O // ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์๋ฅผ ํ๋, ๋ฉค๋ฒ ํจ์๋ฅผ ๋ฉ์๋๋ผ๊ณ ํ๋ค.
4๋ฒ X // ํ๋๋ private์ผ๋ก ์ ์ธํ์ฌ ์ธ๋ถ์ ์ ๊ทผ์ผ๋ก ๋ถํฐ ๋ณดํธํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค.
2๋ฒ
๋ต: 4๋ฒ ์์ฑ์์์๋ ์๋ฌด ๊ฐ๋ ๋ฆฌํดํ์ง ์๊ธฐ ๋๋ฌธ์ return๋ฌธ์ ์ฌ์ฉํ ์ ์๋ค.
1๋ฒ O // ํด๋์ค ๋ด์ ์์ฑ์๊ฐ ํ๋๋ ์์ผ๋ฉด, ์ปดํ์ผ๋ฌ๊ฐ ๋งค๊ฐ๋ณ์๋ ์๊ณ ๋จ์ ๋ฆฌํด๋ง ํ๋ ๊ธฐ๋ณธ ์์ฑ์๋ฅผ ์๋์ผ๋ก ์์ฑํด์ค๋ค.
2๋ฒ O // ์์ฑ์๋ ํด๋์ค์ ์ด๋ฆ๊ณผ ๋์ผํ ์ด๋ฆ์ ๋ฉ์๋์ด๋ค. ์๋ฐ์์ ์ด๋ฆ์ ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ๋ค.
3๋ฒ O // this() ๋ฉ์๋๋ ์์ฑ์ ๋ด์์ ๋์ผํ ํด๋์ค์ ๋ค๋ฅธ ์์ฑ์๋ฅผ ํธ์ถํ๋ ๋ฉ์๋์ด๋ค.
// ์์ฑ์ ๋ด์์๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๊ณ , ์์ฑ์์ ์ ์ผ ์ฒ์์ ์คํ๋์ด์ผ ํ๋ค.
4๋ฒ X // ์์ฑ์๋ ๋ฆฌํด์ด ์์ผ๋ฏ๋ก ๋ฆฌํด ํ์ ์ ์ง์ ํ๋ฉด ์๋๋ค. ๊ทธ๋ฌ๋, return๋ฌธ์ ๋ฉ์๋์ ์คํ์ ๋๋ด๊ณ ํธ์ถํ ๊ณณ์ผ๋ก ๋์๊ฐ๋ผ๋ ๋ช ๋ น์ด๋ฏ๋ก ์์ฑ์ ์คํ์ ๋๋ด๊ณ ์ ํ๋ค๋ฉด, ์์ฑ์ ๋ด์ ์ด๋์๋ ์ฌ์ฉ๊ฐ๋ฅํ๋ค.
3๋ฒ
๋ต: 3๋ฒ Power p [10] = new Power [10];
1๋ฒ O // ํฌ๊ธฐ๊ฐ 10์ธ Power ๊ฐ์ฒด ๋ฐฐ์ด p ์ ์ธ ๋์์ ์์ฑ
2๋ฒ O // ํฌ๊ธฐ๊ฐ 10์ธ Power ๊ฐ์ฒด ๋ฐฐ์ด p ์ ์ธ ๋์์ ์์ฑ
3๋ฒ X // ๋ฐฐ์ด ์ ์ธ ๋์์ ํฌ๊ธฐ ์ง์ ํ ์ ์๋ค.
4๋ฒ O // Power ๊ฐ์ฒด ๋ฐฐ์ด p ์ ์ธ, ์์ง ๋ ํผ๋ฐ์ค ๋ณ์ p๋ง ์์ฑ๋๊ณ null๋ก ์ด๊ธฐํ๋ ์ํ์ด๋ค.
4๋ฒ
๋ต: 2๋ฒ Book ๊ฐ์ฒด๊ฐ 10๊ฐ ๋ง๋ค์ด์ง๋ค.
// ๋ฌธ์ ์ ์ฝ๋๋ ํฌ๊ธฐ๊ฐ 10์ธ Book ๊ฐ์ฒด ๋ฐฐ์ด ์ ์ธ ๋์์ ์์ฑํ๋ ๋ฌธ์ฅ์ด๋ค.
1๋ฒ O // Book ๊ฐ์ฒด ๋ฐฐ์ด์ ๋ํ ๋ ํผ๋ฐ์ค ๋ณ์ book
2๋ฒ X // ๊ฐ์ฒด ๋ฐฐ์ด์ ๊ฐ์ฒด์ ๋ ํผ๋ฐ์ค๋ฅผ ์์์ ์ ์ฅํ๋ ๋ฐฐ์ด์ด๋ค. ์์ง Book ๊ฐ์ฒด๋ ๋ง๋ค์ด์ง์ง ์์๋ค. Book ๊ฐ์ฒด์ ๋ ํผ๋ฐ์ค๋ฅผ ์ ์ฅํ ํฌ๊ธฐ๊ฐ 10์ผ ๋ฐฐ์ด๋ง ๋ง๋ค์ด์ง ์ํ์ด๋ค.
3๋ฒ O // ๊ฐ์ฒด์ ๋ ํผ๋ฐ์ค๋ฅผ ์ ์ฅํ๋ ๋ฐฐ์ด์ new ์ฐ์ฐ์๋ก ๊ฐ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ค ๋์ ํ์ฌ์ผ ๊ฐ์ฒด ๋ฐฐ์ด์ด ์์ฑ๋๋ค.
4๋ฒ O // ๊ฐ์ฒด ๋ฐฐ์ด์ Book ๊ฐ์ฒด์ ๋ ํผ๋ฐ์ค๋ฅผ ์์์ ์ ์ฅํ๋ ๋ฐฐ์ด์ด๋ค. book์ ์ธ๋ฑ์ค i๋ฒ์งธ ์์์๋ Book ๊ฐ์ฒด์ ๋ํ ๋ ํผ๋ฐ์ค ๊ฐ์ด ์ ์ฅ๋์ด ์๋ค.
5๋ฒ
๋ต: 1๋ฒ
1
2
|
void f(int a) { x = a; }
int f(int b) { return x+b; }
|
cs |
// ๋งค๊ฐ๋ณ์์ ํ์ ์ด๋ ๊ฐ์๊ฐ intํ 1๊ฐ๋ก ๋์ผํ์ฌ, ์ด๋ ๋ฉ์๋๋ฅผ ํธ์ถํ์๋์ง ๊ตฌ๋ถ์ด ๋ถ๊ฐ๋ฅํ๋ค.
// ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ์ ๋ฉ์๋์ ์ด๋ฆ์ ๊ฐ์์ผํ๊ณ , ๋งค๊ฐ๋ณ์์ ํ์ ์ด๋ ๊ฐ์๋ ๋ฌ๋ผ์ผํ๋ค.
// ์ ๊ทผ ์ง์ ์๋ ๋ฆฌํด ํ์ ์ ์๊ด ์๋ค.
6๋ฒ
(1) ๋ต:
1
2
3
4
5
6
7
|
public TV() {
this(32, "LG"); // ๋งค๊ฐ๋ณ์๊ฐ int, String 2๊ฐ์ธ ์์ฑ์ ํธ์ถ
}
public TV(String manufacturer) {
this(32, manufacturer); // ๋งค๊ฐ๋ณ์๊ฐ int, String 2๊ฐ์ธ ์์ฑ์ ํธ์ถ
}
|
cs |
// this() ๋ฉ์๋๋ ์์ฑ์ ๋ด์์ ๋ค๋ฅธ ์์ฑ์๋ฅผ ํธ์ถํ๋ ๋ฉ์๋์ด๋ค. ์ด ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ์ฝ๋์ ์ค๋ณต์ ์ ๊ฑฐํ ์ ์๋ค.
// this() ๋ฉ์๋๋ ์์ฑ์ ๋ด์์๋ง ์ฌ์ฉ๊ฐ๋ฅํ๊ณ , ์์ฑ์์ ์ ์ผ ์ฒซ๋ฒ์งธ ์ค์์ ์คํํด์ผ ํ๋ค.
(2) ๋ต:
new TV(); ๋ฅผ ์คํํ๋ฉด ์ธ์๊ฐ ํ๋๋ ์์ผ๋ฏ๋ก ๋งค๊ฐ๋ณ์๊ฐ ์๋ ๊ธฐ๋ณธ ์์ฑ์๊ฐ ํธ์ถ๋๋ค. ๊ทธ๋ฌ๋ฉด this(32, "LG"); ๋ฉ์๋์ ์ํด 32์ธ์น LG๊ฐ ์ถ๋ ฅ๋๋ค.
new TV("์ผ์ฑ"); ๋ฅผ ์คํํ๋ฉด ์ธ์๊ฐ String 1๊ฐ์ด๋ฏ๋ก ๋งค๊ฐ๋ณ์๊ฐ String 1๊ฐ์ธ ์์ฑ์๊ฐ ํธ์ถ๋๋ค. ๊ทธ๋ฌ๋ฉด this(32, manufacturer); ๋ฉ์๋์ ์ํด 32์ธ์น ์ผ์ฑ์ด ์ถ๋ ฅ๋๋ค.
(3) ๋ต:
1
|
new TV(65, "์ผ์ฑ");
|
cs |
(4) ๋ต: ์์ฑ์ ๋ด์ ์ค๋ณต๋ ์ฝ๋๋ฅผ ์ ๊ฑฐํ ์ ์๋ค.
7๋ฒ
๋ต:
1
|
aPerson.age = 17; // Person ํด๋์ค์ private ๋ฉค๋ฒ์ ์ ๊ทผํ์ฌ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
|
cs |
// private์ผ๋ก ์ ์ธ๋ ๋ฉค๋ฒ๋ ๋์ผํ ํด๋์ค์์๋ง ์ ๊ทผํ ์ ์๋ค.
์ด ์ค๋ฅ๋ฅผ ์์ ํ๋ ๋ฐฉ๋ฒ์ ์๋ 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค.
1. // public ๋ฉ์๋๋ฅผ ์ ์ํ์ฌ ํด๋น ๋ฉ์๋๋ก age๋ฅผ ์ด๊ธฐํํ๋ค.
1
|
public void setAge(int age) {this.age = age;}
|
cs |
2. // ๋งค๊ฐ๋ณ์๊ฐ int 1๊ฐ์ธ ์์ฑ์๋ฅผ ํธ์ถํ์ฌ age๋ฅผ ์ด๊ธฐํํ๋ค.
1
|
public Person(int age) {this.age = age;}
|
cs |
๊ฐ์ฒด ์งํฅ์ ์บก์ํ ์์น์ ๊ทผ๊ฑฐํ์ฌ ํ๋๋ private์ผ๋ก ์ ์ธํ๊ณ public ๋ฉ์๋๋ฅผ ํตํด private ๋ฉค๋ฒ์ ์ ๊ทผ ํ๋ ๋ฐฉ์์ด ๋ฐ๋์งํ๋ค. ์์ฑ์๋ ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋, ์ด๊ธฐํ์ ํ์ํ ์ฝ๋๋ฅผ ์์ฑํ๋ฏ๋ก ๋งค๊ฐ๋ณ์๊ฐ int 1๊ฐ์ธ ์์ฑ์ ํธ์ถํ์ฌ age์ 17์ ๋์ ํ์ฌ ์ด๊ธฐํํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ ์ ํด๋ณด์ธ๋ค.
8๋ฒ
// ๊ฐ์ฒด ์งํฅ์ ์บก์ํ ์์น์ ๊ทผ๊ฑฐํ์ฌ ํ๋๋ private์ผ๋ก ์ ์ธํ๊ณ public ๋ฉ์๋๋ฅผ ํตํด private ๋ฉค๋ฒ์ ์ ๊ทผ ํ๋ ๋ฐฉ์์ด ๋ฐ๋์งํ๋ค.
(1) ๋ต:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Power {
private int kick;
private int punch;
// ๋งค๊ฐ๋ณ์๊ฐ int 2๊ฐ์ธ ์์ฑ์
public Power(int kick, int punch) {
this.kick = kick;
this.punch = punch;
}
}
public class Example {
public static void main(String[] args) {
// ์์ฑ์๋ new ์ฐ์ฐ์์ ์ํด ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋, ๋ฑ ํ๋ฒ๋ง ํธ์ถ๋๋ค.
Power robot = new Power(10, 20);
}
}
|
cs |
(2) ๋ต:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class Power {
private int kick;
private int punch;
public void setPower(int kick, int punch) {
this.kick = kick;
this.punch = punch;
}
}
public class Example {
public static void main(String[] args) {
Power robot = new Power();
// ๊ฐ์ฒด์ public ๋ฉ์๋ ํธ์ถ
robot.setPower(10, 20);
}
}
|
cs |
9๋ฒ
๋ต: ์๋ฉธ์ํฌ, ๋คํํ, ๋ ํผ๋ฐ์ค, ๊ฐ๋น์ง, ๊ฐ๋น์ง ์ปฌ๋ ์ , System.gc()
10๋ฒ
(1) ๋ต: ๊ฐ๋น์ง๊ฐ ๋ฐ์ํ๋ค. // ๋ฐ๋ณต๋ฌธ์ด ์คํ๋๋ ๋์ ๋ ํผ๋ฐ์ค s๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ String ๊ฐ์ฒด๋ new ์ฐ์ฐ์๋ฅผ ํตํด ์๋ก ์์ฑ๋๊ณ ๊ธฐ์กด์ s๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ฒด๋ ๋ ์ด์ ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค๊ฐ ์์ผ๋ฏ๋ก ๊ฐ๋น์ง๊ฐ ๋๋ค.
(2) ๋ต: ๊ฐ๋น์๊ฐ ๋ฐ์ํ์ง ์๋๋ค. // String ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค c๊ฐ a๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ String ๊ฐ์ฒด๋ฅผ ๊ณ์ ๊ฐ๋ฆฌํค๊ณ ์์ผ๋ฏ๋ก ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค๊ฐ ์๋ ๊ฐ์ฒด๋ ๋ฐ์๋์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
11๋ฒ
๋ต: 4๋ฒ static int g() { return getB(); }
// static ๋ฉ์๋์์ non-static ๋ฉค๋ฒ๋ ์ ๊ทผํ ์ ์๋ค. ๊ฐ์ฒด๊ฐ ์์ฑ๋๊ธฐ ์ ์ static ๋ฉ์๋๊ฐ ์คํ๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
1๋ฒ // static ๋ฉ์๋์์ static ๋ฉค๋ฒ ์ ๊ทผ
2๋ฒ // non-static ๋ฉ์๋์์ non-static ๋ฉค๋ฒ ์ ๊ทผ
3๋ฒ // non-static ๋ฉ์๋์์ static ๋ฉค๋ฒ ์ ๊ทผ
12๋ฒ
๋ต: 1๋ฒ StaticSample.x = 5; // non-static ๋ฉค๋ฒ๋ ํด๋์ค ์ด๋ฆ์ผ๋ก ์ ๊ทผํ ์ ์๋ค. ์ด๋ ๊ฐ์ฒด์ ๋ฉค๋ฒ์ธ์ง ์๋ณํ ์ ์๊ธฐ ๋๋ฌธ์
// static ๋ฉค๋ฒ๋ ํด๋์ค ์ด๋ฆ์ผ๋ก ์ ๊ทผํ๊ณ , ๊ฐ์ฒด ์์ฑ ํ์๋ ํด๋์ค ์ด๋ฆ๊ณผ ๊ฐ์ฒด ์ด๋ฆ ๋ ๋ค๋ก ์ ๊ทผ ํ ์ ์๋ค.
2๋ฒ // static ๋ฉค๋ฒ๋ฅผ ํด๋์ค ์ด๋ฆ์ผ๋ก ์ ๊ทผ
3๋ฒ // static ๋ฉค๋ฒ๋ฅผ ํด๋์ค ์ด๋ฆ์ผ๋ก ์ ๊ทผ
4๋ฒ // static ๋ฉค๋ฒ๋ฅผ ๊ฐ์ฒด ์์ฑ ํ ๊ฐ์ฒด ์ด๋ฆ์ผ๋ก ์ ๊ทผ
13๋ฒ
๋ต:
1
2
3
4
5
6
7
8
|
class Test{
public int f(int a, int b) { // public static int f(int a, int b)๋ก ์์
return a + b;
}
public static void main(String[] args) {
int sum = f(2, 4); // ํ๋ฆฐ ๋ถ๋ถ
}
}
|
cs |
// static ๋ฉค๋ฒ์ธ main() ๋ฉ์๋์์ non-static ๋ฉค๋ฒ f()์ ์ ๊ทผํ์๋ค. static ๋ฉ์๋์์๋ static ๋ฉค๋ฒ์๋ง ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ฏ๋ก f()๋ฅผ static๋ฉค๋ฒ๋ก ์์ ํด์ผ ํ๋ค.
14๋ฒ
๋ต:
1. final๋ก ์ ์ธ๋ ํ๋๋ ์์์ด๋ค. ์์๋ ์ ์ธ์์ ํ๋ฒ ์ด๊ธฐํ ๋๊ณ ๋๋ฉด, ๊ฐ ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฌ๋ฏ๋ก, f() ๋ฉ์๋ ๋ด๋ถ์์ x++;๋ก ์์ x์ ๊ฐ์ ๋ณ๊ฒฝํ๊ณ ์ ํ ๋ถ๋ถ์ด ์๋ชป๋์๋ค.
2. final๋ก ์ ์ธ๋ ํด๋์ค๋ ์์์ด ๋ถ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฌ๋ฏ๋ก, SpecialRect ํด๋์ค์์ extends ํค์๋๋ก Rect ํด๋์ค๋ฅผ ์์ํ๊ณ ์ ํ ๋ถ๋ถ์ด ์๋ชป๋์๋ค.
3. final๋ก ์ ์ธ๋ ๋ฉ์๋๋ ์ค๋ฒ๋ผ์ด๋ฉ์ด ๋ถ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฌ๋ฏ๋ก SpecialRect ํด๋์ค์์ public void f() ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๊ณ ์ ํ ๋ถ๋ถ์ด ์๋ชป๋์๋ค.
15๋ฒ
๋ต:
๊ฐ๋น์ง๋ ๊ฐ๋ฆฌํค๋ ๋ ํผ๋ฐ์ค๊ฐ ํ ๊ฐ๋ ์๋ ๊ฐ์ฒด๋ฅผ ๋งํ๋ค.
๊ฐ๋น์ง๊ฐ ๋ง์์ง๋ฉด JVM์์ ์์ฉํ๋ก๊ทธ๋จ์ ํ ๋นํด์ค ์ ์๋ ๊ฐ์ฉ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ด๋ค์ด ์ํฅ์ ์ค ์ ์์ผ๋ฏ๋ก, JVM์ ๊ฐ์ฉ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ผ์ ํฌ๊ธฐ ์ดํ๋ก ์ค์ด๋ค๊ฒ ๋๋ฉด ์๋์ผ๋ก ์๋น์ง ์ปฌ๋ ์ ์ ์ํํ์ฌ ๊ฐ๋น์ง๋ฅผ ํ์ํ๋ค.
์ฅ์ ์๋ฐ๋ C++๊ณผ ๋ฌ๋ฆฌ delete ์ฐ์ฐ์๋ ์๋ฉธ์๊ฐ ์์ด, ํ๋ก๊ทธ๋๋จธ๊ฐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ํ์ง ์์๋ ๋๋ค.
๋จ์ ๊ฐ๋น์ง ์ปฌ๋ ์ ์ด ์งํ๋๋ ๋์ ํ๋ก๊ทธ๋จ์ด ์ผ์์ ์ผ๋ก ์ค๋จ๋๋ค.
16๋ฒ
๋ต:
default | public | protected | private | |
๊ฐ์ ํจํค์ง ํด๋์ค | O | O | O | X |
๋ค๋ฅธ ํจํค์ง ํด๋์ค | X | O | X / ์์ ํด๋์ค๋ ๊ฐ๋ฅ | X |
// ์ ๊ทผ ์ง์ ์๋ public, protected, default, private 4๊ฐ์ง๊ฐ ์๋ค.
// public์ ๋ชจ๋ ํด๋์ค์์ ์ ๊ทผ ๊ฐ๋ฅ
// protected๋ ๋์ผํ ํจํค์ง์ ํด๋์ค๋ ์์ ํด๋์ค์์ ์ ๊ทผ ๊ฐ๋ฅ
// default๋ ๋์ผํ ํจํค์ง์ ํด๋์ค์์ ์ ๊ทผ ๊ฐ๋ฅ
// private์ ๋์ผํ ํด๋์ค์์๋ง ์ ๊ทผ ๊ฐ๋ฅ