Inheritance
๐ Inheritance(์์)
์์์ ์ฅ์
โ ์ค๋ณต๋๋ ์ฝ๋๋ฅผ ์ค์ฌ์ค๋ค.
โ ํจ์จ์ ์ด๊ณ , ๊ฐ๋ฐ์๊ฐ ๋จ์ถ.
โ ์ ์ง๋ณด์ ์๊ฐ์ ์ต์ํ ๊ฐ๋ฅ.
ํด๋์ค ์์
extends ๋ค์ ๋ ๊ฐ ์ด์์ ๋ถ๋ชจํด๋์ค๋ ์ฌ ์ ์๋ค.
์ฆ, java์์๋ ๋จ์ผ ์์๋ง ๊ฐ๋ฅํ๋ค.
1
์์ํด๋์ค extends ๋ถ๋ชจํด๋์ค {}
์ถ๊ฐ์ ์ผ๋ก ์กฐ์(๋ถ๋ชจ)๊ฐ ์๋ ํด๋์ค๋ ์๋์ ์ผ๋ก Object ํด๋์ค๋ฅผ
์์๋ฐ๊ฒ ๋๋๋ฐ ์๋ตํ ๊ฒฝ์ฐ ์ปดํ์ผ๋ฌ์ ์ํด ์๋์ผ๋ก ์์ฑ๋๋ค.
์ฆ, ์์๊ณ์ธต์ ์ต์์์๋ Objectํด๋์ค๊ฐ ์์นํ๋ค๊ณ ํด์ํ ์ ์๋ค.
๋ํ Object ํด๋์ค์๋ 11๊ฐ์ ๋ฉ์๋๊ฐ ์๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// class
public class People extends Object{
// Field
public String name;
public String ssn;
// Constructor
public People(String name; String ssn;) {
this.name = name;
this.ssn = ssn;
}
}
๋ถ๋ชจ ์์ฑ์๋ ์์ ์์ฑ์์ ๋งจ ์์ค์ ํธ์ถ๋๋ค.
๋ฐ๋ก ์ ์ธํด์ฃผ์ง ์์๋ ์ปดํ์ผ๋ฌ์ ์ํด ๊ธฐ๋ณธ ์์ฑ์๊ฐ ์ ์ธ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
package practice.java;
public class Student extends People {
// Field
int age = age;
// Constructor
public Student(String name; String ssn; int age;) {
super(name, ssn); // ๋ถ๋ชจ ์์ฑ์ ํธ์ถ
this.age = age;
}
}
๐ Composite(ํฌํจ)
ํฌํจ์ด๋?
ํ ํด๋์ค์ ๋ฉค๋ฒ๋ณ์๋ก ๋ค๋ฅธ ํด๋์ค๋ฅผ ์ ์ธํ๋ ๊ฒ์ด๋ค.
์์ ๋จ์์ ํด๋์ค๋ฅผ ๋จผ์ ๋ง๋ค๊ณ , ์ด ๋ค์ ์กฐํฉํด์ ํ๋์ ์ปค๋ค๋
ํด๋์ค๋ฅผ ๋ง๋ ๋ค. ๊ฐ๋ฅํ ํ ๋ง์ ๊ด๊ณ๋ฅผ ๋งบ์ด์ฃผ์ด ์ฌ์ฌ์ฉ์ฑ์ ๋์ด๊ณ
์ฝ๋๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ฝ๊ฒ ํ๋ค. ํด๋์ค๋ฅผ ์ค๊ณํ ๋ ํฌํจ๊ณผ ์์ ์ฌ์ด์์
ํท๊ฐ๋ฆฐ๋ค๋ฉด is-a, has-a ๋ฅผ ๊ฐ์ง๊ณ ๋ฌธ์ฅ์ ๋ง๋ค์ด ๋ณด๋ฉด ๋๋ค.
์๋์ฐจ์ ๋ฐํด๋ฅผ ์๋ก ๋ค๋ฉด
-
is-a : ์๋์ฐจ๋ ๋ฐํด์ด๋ค.
-
has-a : ์๋์ฐจ๋ ๋ฐํด๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
์ ๋ ๋ฌธ์ฅ์ค ์๋์ ๋ฌธ์ฅ์ด ๋ ์์ฐ์ค๋ฝ๋ค.
๋ฐ๋ผ์ ๋ฐํดํด๋์ค๋ ์๋์ฐจ ํด๋์ค์ ํฌํจ ๋์ด์ผ ํ๋ค.
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
// Tire ํด๋์ค
class Tire {
String tire;
}
// newCarํด๋์ค ํฌํจ
class newCar {
Tire t = new Tire();
String name;
}
public class inheritanceTest {
public static void main(String[] args) {
newCar myCar = new newCar();
myCar.t.tire = "kumho";
myCar.name = "Sonata";
System.out.println(myCar.t.tire);
System.out.println(myCar.name);
}
}
/*
[์ถ๋ ฅ ๊ฒฐ๊ณผ]
kumho
Sonata
*/
๐ Method Override
Method overriding์ด๋?
์์ ๋ฐ์ ์กฐ์(๋ถ๋ชจ)์ ๋ฉ์๋๋ฅผ ์์ ์๊ฒ ๋ง๊ฒ ์ฌ์ ์ ํ๋ ๊ฒ.
๊ท์น
โ ์ ์ธ๋ถ๊ฐ ๊ฐ์์ผํ๋ค. (์ด๋ฆ, ๋งค๊ฐ๋ณ์, ๋ฆฌํดํ์ )
โ ์ ๊ทผ์ ์ด์๋ฅผ ์ข์ ๋ฒ์๋ก ๋ณ๊ฒฝํ ์ ์๋ค.
- ์กฐ์์ ๋ฉ์๋๊ฐ protected๋ผ๋ฉด, ๋ฒ์๊ฐ ๊ฐ๊ฑฐ๋ ๋์ protected, public์ผ๋ก ๋ณ๊ฒฝํ ์ ์๋ค.
โ ์กฐ์(๋ถ๋ชจ)ํด๋์ค์ ๋ฉ์๋๋ณด๋ค ๋ง์ ์์ ์์ธ๋ฅผ ์ ์ธํ ์ ์๋ค.
โ @Override ๋ฅผ ์ ์ธํด์ฃผ๋ฉด ์ข๋ค(ํ์๋ ์๋๋ฏ)
ํ์(์์)ํด๋์ค์์ ์กฐ์(๋ถ๋ชจ)ํด๋์ค ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ์ง๋ง, ์ฌ์ ์ ํ๊ธฐ ์ ์
๋ฉ์๋(๋ถ๋ชจํด๋์ค์ ๋ฉ์๋)๋ฅผ ํธ์ถํ๊ณ ์ถ์ ๋, ์๋์ ๊ฐ์ด ์ฌ์ฉํ๋ค.
1
super.parentMethod();
์ค๋ฒ๋ก๋ฉ๊ณผ ์ค๋ฒ๋ผ์ด๋ฉ์ ์ฐจ์ด
์ค๋ฒ๋ก๋ฉ : ๊ธฐ์กด์ ์๋ ์๋ก์ด ๋ฉ์๋๋ฅผ ์ ์ํ๋ ๊ฒ (new)
์ค๋ฒ๋ผ์ด๋ฉ : ์์๋ฐ์ ๋ฉ์๋์ ๋ด์ฉ์ ๋ณ๊ฒฝํ๋ ๊ฒ (change, modify)
๐ super
์ฐธ์กฐ ๋ณ์ super
์กฐ์์ ๋ฉค๋ฒ์ ์์ ์ ๋ฉค๋ฒ๋ฅผ ๊ตฌ๋ณํ๋๋ฐ ์ฌ์ฉ๋๋ค.
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
class Test {
public static void main(String args[]) {
Child c = new Child();
c.method();
}
}
class Parent {
int x=10; // super.x
}
class Child extends Parent {
int x=20; // this.x
void method() {
System.out.println("x=" + x);
System.out.println("this.x=" + this.x);
System.out.println("super.x="+ super.x);
}
}
/*
[์ถ๋ ฅ๊ฒฐ๊ณผ]
20
20
10
*/
super() ์์ฑ์
์์ํด๋์ค์์ ์กฐ์ํด๋์ค์์ ์ ์ธ๋ ๋ฉค๋ฒ๋ฅผ ์ด๊ธฐํ ํ๊ธฐ ์ํด์๋
์กฐ์์ ์์ฑ์ ํด๋์ค๋ฅผ ํธ์ถํด์ผ ํ๋๋ฐ ์ด ๋ super() ๋ฅผ ์ฌ์ฉํ๋ค.
1
2
3
4
5
6
7
8
9
10
public class Person {
String name;
String gender;
Person(String name, String gender) {
this.name = name;
this.gender = gender;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Student extends Person {
int age;
String school;
Student(String name, String gender, int age, String school) {
super(name, gender);
this.age = age;
this.school = school;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class SuperTest {
public static void main(String[] args) {
Student gilbert = new Student("ํ๊ธธ๋", "๋จ์", 28, "ํ๊ตญ๋ํ๊ต");
System.out.println("์ด๋ฆ: " + gilbert.name);
System.out.println("์ฑ๋ณ: " + gilbert.gender);
System.out.println("๋์ด: " + gilbert.age);
System.out.println("ํ๊ต: " + gilbert.school);
}
}
/*
[์ถ๋ ฅ๊ฒฐ๊ณผ]
์ด๋ฆ: ํ๊ธธ๋
์ฑ๋ณ: ๋จ์
๋์ด: 28
ํ๊ต: ํ๊ตญ๋ํ๊ต
*/