[ 클래스의 상속 ]
* 상속 : 어떤 클래스가 가지고 있는 메서드와 변수를 상속해서 다른 클래스가 갖도록 하는 것
> 부모 클래스의 method, 변수를 그대로 물려받는다.
> (자식 : 부모의 확장판)
> 부모 클래스의 private는 물려 받을 수 없다.
- this : 나 자신을 가리키는 참조변수
- this() : 내 클래스의 기본 생성자
- super: 부모를 가리키는 참조변수
- super() : 부모 클래스의 기본 생성자
| < 접근 지정자 > +: public #: protected 없음 : default -: private |
[ method overloading vs method overriding ]
* method overloading : 다중정의
- 방법 : method 명 동일
매개변수의 갯수, 자료형, 순서를 다르게
* method overriding : 재정의 (상속)
- 부모가 물려준 메서드를 새롭게 다시 정의해서 사용하는 것
- 방법 : method 명 동일
매개변수의 갯수, 자료형, 순서까지 동일 (부모 메서드와 동일)
메서드 시그니처가 동일
method signature가 동일
단, 접근 지정자는 부모와 동일하거나 허용적이면 OK
-> 자식의 메서드가 부모의 메서드와 접근 지정자가 같거나 더 허용적이어야
- annotation @XXXXX
컴파일러에 XXXX라는 특정한 기능을 요청
@Override : 오버라이드 메소드라고 컴파일러에 알려주는 것(오타 있으며 잡아냄)
void method() { --> method signature
--> method body
}
public void method() { --> method signature
--> method body
}
* Person 클래스를 상속받은 SuperMan 클래스
|
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
44
45
46
47
48
49
|
package day10;
// 상속 : 어떤 클래스가 가지고 있는 메서드와 변수를 상속해서 다른 클래스가 갖도록 하는 것
// > 부모 클래스의 method, 변수를 그대로 물려받는다.
// > (자식 : 부모의 확장판)
// > 부모 클래스의 private는 물려 받을 수 없다.
// Person 클래스의 코드를 그대로 가지고 와..
// SuperMan 클래스는 Person 클래스의 확장판
public class SuperMan extends Person{
float height;
float weight;
// 생성자 작성하지 않으면 클래스와 같은 이름으로 자동 생성(있다고 간주)
SuperMan(){
// Person 클래스에서 상속 받은 멤버변수의 초기화 필요!
super(); // Person 클래스의 기본생성자를 호출 (내부적으로 자동 생성)
// this : 나 자신을 가리키는 참조변수
// this() : 내 클래스의 기본 생성자
// super: 부모를 가리키는 참조변수
// super() : 부모 클래스의 기본 생성자
height = 0.0f;
weight = 0.0f;
System.out.println("SuperMan 기본생성자 호출");
}
SuperMan(String name, String job, int age, float height, float weight) {
// super(); // 생략
// this.name = name;
// this.job = job;
// person 클래스에 name과 job이 있는 생성자가 있다면?
super(name, job);
this.age = age;
this.height = height;
this.weight = weight;
System.out.println("name, job, age, height, weight 생성자 호출");
}
public void 레이져발사() {
System.out.println("뿅뿅~~~");
}
public void 비행하기() {
System.out.println("날아라 슈웅~~~~");
}
}
|
cs |
- Person 클래스(참고)
|
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
package day10;
public class Person {
String name;
int age;
int eye;
int nose;
int mouth;
String gender;
String job;
String tel;
public void setage(int age) {
this.age = age;
}
public int getage() {
return this.age;
}
public void setjob(String job) {
this.job = job;
}
public String getjob() {
return this.job;
}
// checkAge()
// 성인이면 20
// 15~18 : 15
// 그 이하면 10을 리턴하는 메서드를 정의
public int checkAge() {
if (this.age >= 20) {
return 20;
} else if(this.age >= 18) {
return 18;
} else if(this.age >= 15) {
return 15;
} else
return 10;
}
public Person() {
eye = 2;
nose = 1;
mouth = 1;
System.out.println("Person 클래스의 기본 생성자");
}
// 추가
public Person(String name, String job) {
this();
this.name = name;
this.job = job;
System.out.println("person name, job 생성자");
}
void eating() {
System.out.println("맛난 걸 먹어요 냠냠");
}
void sleeping() {
System.out.println("쿨쿨~~~");
}
void talking() {
System.out.println("쏙닥쏙닥...");
}
void thinking() {
System.out.println("나는 생각한다 고로 존재한다...");
}
}
|
cs |
- SuperMan 클래스 테스트
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package day10;
public class TestMain {
public static void main(String[] args) {
// 생성자 특징 : 생성자의 이름은 클래스의 이름과 동일
// 주 목적이 멤버변수의 초기화
SuperMan sm = new SuperMan("클라크", "사진기자", 20, 190.0f, 70.0f);
// 멤버변수와 method 출력
System.out.println("슈퍼맨의 키 : " + sm.height);
System.out.println("눈 : "+sm.eye);
sm.eating();
sm.레이져발사();
sm.비행하기();
}
}
|
cs |
* 윈도우 창 띄우기
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package day10;
// 윈도우 창 띄우기
import java.awt.Frame; // ctrl+shift+O
public class TestMain02 {
public static void main(String[] args) {
Frame f = new Frame();
f.setSize(600, 400);
f.setLocation(300, 300);
f.setVisible(true);
}
}
|
cs |
* 클래스 다이어그램
| < Parent > + String name # String job - int age 먹기() : void 노래부르기() : void 자기() : void 잔소리하기() : void |
| < Child > String snsid; 먹기() 노래부르기() 클럽가기() |
* Parent 클래스
|
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
|
package day10;
public class Parent {
String name, job;
int age;
Parent() {
System.out.println("Parent 기본생성자");
}
Parent(String name, int age, String job) {
this.name = name;
this.age = age;
this.job = job;
System.out.println("Parent String int String 생성자");
}
public void eating() {
System.out.println("맛난 걸 먹어요");
}
public void singing() {
System.out.println("뽕짝뽕짝~~~");
}
public void sleeping() {
System.out.println("쿨쿨 자요");
}
public void nagging() {
System.out.println("엄마 친구 아들이...");
}
}
|
cs |
* Parent 클래스 상속 받은 Child 클래스
|
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
|
package day10;
// public class 자식클래스명 extends 부모클래스명 {} : 상속
public class Child extends Parent{
String snsid;
Child() {
super(); // 부모클래스의 기본생성자 호출(작성하지 않아도 내부적으로 자동 호출)
this.name = "홍길동";
this.age = 20;
this.job = "도적";
System.out.println("Child 클래스의 기본생성자");
}
//
// Parent에서 상속받는 내용이 맘에 들지 않아 내 마음대로 수정(eating, singing)
public void eating() {
System.out.println("마라탕을 먹어요!!");
}
// method overriding > 상속이 전제
// 재정의
// 부모가 물려준 메서드를 새롭게 다시 정의해서 사용하는 것
// annotation @XXXXX
// 컴파일러에 XXXX라는 특정한 기능을 요청
@Override // 아래는 오버라이드 메소드라고 컴파일러에 알려주는 것(오타 있으며 잡아냄)
public void singing() {
System.out.println("on the street~~");
}
public void goClub() {
System.out.println("클럽 댄스~~~");
}
}
|
cs |
< 클래스 다이어그램 및 코드 > ==> Parent, Marine 참조
* Parent p1 = new Parent("홍판서", 40, "판서");
* Marine m1 = new Marine();
- m1 = p1; (다른 클래스끼리 참조값을 할당할 수 없음)
* Parent p2;
p2 = p1;
S.O.P(p2.name) --> 홍판서
==> 같은 클래스 끼리는 참조값을 줄 수 있음
>> 클래스 다이어그램 구현
| stack | heap |
| p1 #100 m1 #100 p2 #100 |
#100 name 홍판서 age 40 job 판서 eating() sleeping() singing() nagging() #200 int hp int x int y int 사거리 int 공격력 int 방어력 int 공격속도 int 이동속도 공격하기() ... |
|
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
44
45
46
47
48
|
package day10;
import day08.Marine;
public class TestMain03 {
public static void main(String[] args) {
// Parent p1 = new Parent();
Parent p1 = new Parent("홍판서", 40, "판서");
System.out.println(p1.name); // 홍판서
System.out.println(p1.age); // 40
System.out.println(p1.job); // 판서
System.out.println();
p1.eating();
p1.sleeping();
p1.singing();
p1.nagging();
System.out.println();
Marine m1 = new Marine(); // 사용하기 위해서는 Marine을 public으로
// m1 = p1; // 다른 클래스끼리는 참조값을 줄 수 없음
// 클래스 : 사용자가 정의한 새로운 자료형
// 서로 다른 자료형 : Marine, Parent
// m1 = p1; 할 수 없음
// 같은 클래스 끼리는 참조값을 줄 수 있음
Parent p2;
p2 = p1;
System.out.println(p2.name); // 홍판서
p2.age = 50; // 수정하면 p1에서도 바뀜(둘 다 같은 클래스 참조해서)
System.out.println(p1.age);
System.out.println(p2.age);
}
}
|
cs |
< 클래스 다이어그램 및 코드 > ==> Parent, Child 참조
* Parent p1 = new Parent("홍판서", 40, "판서");
Child c1 = new Child();
p1 = c1;
Child c2;
c2 = c1;
>> 클래스 다이어그램 구현
| stack | heap |
| p1 #100 -> 200 c1 #200 c2 #200 |
#100 name 홍판서 age 40 job 판서 eating() sleeping() singing() nagging() #200 name 홍길동 age 20 job 도적 snsid null eating() sleeping() singing() nagging() goClub() |
- Parent 클래스 상속 받은 Child 클래스 Test
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package day10;
public class TestMain04 {
public static void main(String[] args) {
Child c1 = new Child();
System.out.println(c1.name);
System.out.println(c1.age);
System.out.println(c1.job);
c1.eating();
c1.sleeping();
c1.singing();
c1.nagging();
c1.goClub();
}
}
|
cs |
- Child, Parent 클래스 Test
|
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
package day10;
import day08.Marine;
public class TestMain05 {
public static void main(String[] args) {
Parent p1 = new Parent();
p1.singing();
Child c1 = new Child();
c1.eating();
c1.singing();
c1.goClub();
System.out.println("p1 : " + p1);
System.out.println("c1 : " + c1);
Marine m1;
// m1 = p1; // 안됨
// m1 = c1; // 안됨
p1 = c1; // 부모 자식 간의 관계가 성립하기 때문에 가능(예외적)
// 부모참조변수 = 자식의 참조값만 ok
// c1 = p1; xxx 이건 안됨
// 부모참조변수 = 자식의 참조값
// 자식참조변수 xxx=xxx 부모의 참조값
// 자식이 구현한 메서드가 그대로 나옴
// 부모가 알고 있는 모든 메서드가 자식에게도 있고, 자식에게도 구현
System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.job);
p1.singing();
p1.eating();
p1.sleeping();
System.out.println("--------------------------");
// 대신, 부모 때는 없고 자식에만 있는 메서드(ex. snsid)는 모름
// p1.snsid <== xxx
// p1.goClub <== xxx
Child c2;
// c2 = p1; // xxx
c2 = c1; // 가능
c2.goClub();
c2 = (Child)p1; // Child의 참조값을 전달하여 사용할 수 있게 형변환
System.out.println(c2.snsid);
c2.goClub();
}
}
|
cs |
* Marine, Medic, SiegeTank 모두 사용 가능한 멤버 메서드 > void 공격하기 (Terran x) { }
Marine, Medic, SiegeTank 통틀어서 'Terran'
Terran x = 자식의 참조값 가능
Terran과 Terran의 모든 후손까지 가능
void 공격하기(Terran x) {
System.out.println("공격하기 메서드 내부 x : "+x);
x.hp -= 공격력;
System.out.println("적 캐릭터 공격!!!");
}
* Marine, Medic, SiegeTank 모두 Terran을 상속
- Marine > Terran을 상속
|
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
|
package day10;
public class Marine extends Terran {
// 클래스의 전역변수
Marine() {
hp = 100;
x = 0;
y = 0;
사거리 = 4;
공격력 = 5;
방어력 = 3;
공격속도 = 3;
이동속도 = 4;
System.out.println("마린 기본생성자 호출");
// return XXX
}
Marine(int hp, int x, int y) { // 체력 500짜리 마린
// 기본 생성자를 실행하고와
this(); // 항상 가장 첫번째 라인에 등장해야 한다.
this.hp = hp;
this.x = x;
this.y = y;
System.out.println("hp x y 생성자 호출");
}
Marine(int hp, int 공격력, int 공격속도, int 이동속도) {
// 기본생성자를 호출한 후에 다른값을 대입
this();
this.hp = hp;
this.공격력 = 공격력;
this.공격속도 = 공격속도;
this.이동속도 = 이동속도;
System.out.println("hp 공격력 공격속도 이동속도 생성자 호출");
}
Marine(int hp, int x, int y, int 공격력, int 이동속도) {
this(hp, x, y); // 생성자 중 int, int, int 매개변수 생성자를 호출
// this.hp = hp;
// this.x = x;
// this.y = y;
this.공격력 = 공격력;
this.이동속도 = 이동속도;
System.out.println("hp x y 공격력 이동속도 생성자 호출");
}
void 공격하기() {
System.out.println("뚜뚜뚜뚜뚜");
}
// Marine, Medic, SiegeTank 통틀어서 'Terran'
// Terran x = 자식의 참조값 가능
// Terran과 Terran의 모든 후손까지 가능
void 공격하기(Terran x) {
System.out.println("공격하기 메서드 내부 x : "+x);
x.hp -= 공격력;
System.out.println("적 캐릭터 공격!!!");
}
// void 공격하기(Marine x) {
// System.out.println("공격하기 메서드 내부 x : "+x);
// x.hp -= 공격력;
// System.out.println("적 캐릭터 공격!!!");
// }
//
// // 추가
// void 공격하기(Medic x) {
// System.out.println("공격하기 메서드 내부 x : "+x);
// x.hp -= 공격력;
// System.out.println("적 캐릭터 공격!!!");
// }
//
// // 추가
// void 공격하기(SiegeTank x) {
// System.out.println("공격하기 메서드 내부 x : "+x);
// x.hp -= 공격력;
// System.out.println("적 캐릭터 공격!!!");
// }
void 스팀팩() {
System.out.println();
if(hp >3 ) {
System.out.println("오우예~~~");
hp -= 3;
공격속도 += 2;
이동속도 += 2;
} else {
System.out.println("체력이 부족합니다.");
}
}
}
|
cs |
- Medic > Terran을 상속
|
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
44
45
|
package day10;
// 클래스의 구성요소
// 1. 멤버변수(멤버 필드)
// 2. 생성자
// 3. 멤버메서드
public class Medic extends Terran {
int 치료력;
int 치료속도;
Medic() {
hp = 100;
x = 0;
y = 0;
사거리 = 4;
치료력 = 5;
방어력 = 3;
치료속도 = 3;
이동속도 = 4;
}
// Terran의 모든 후손까지 치료 가능
void 치료하기(Terran x) {
if(x.hp <= 100-치료력) {
System.out.println("호 해줄게~~~");
x.hp += 치료력;
}
}
// void 치료하기(Marine x) {
// if(x.hp <= 100-치료력) {
// System.out.println("호 해줄게~~~");
// x.hp += 치료력;
// }
// }
void status() {
System.out.println("---------------------");
System.out.println("체력 : "+hp);
System.out.println("x : "+x+" , y : "+y);
}
}
|
cs |
- SiegeTank > Terran을 상속
|
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
44
|
package day10;
// Terran 상속
public class SiegeTank extends Terran {
boolean isMode; // true : siege mode
// false : tank mode
SiegeTank() {
hp = 500;
x = 0;
y = 0;
사거리 = 5;
공격력 = 4;
이동속도 = 3;
방어력 = 10;
공격속도 = 4;
}
void changeMode() {
if(isMode) {
isMode = false;
System.out.println("탱크모드로 전환");
// 탱크모드
이동속도 = 4;
사거리 -= 10;
공격력 -= 3;
}else {
System.out.println("시즈모드로 전환");
isMode = true;
이동속도 = 0;
사거리 += 10;
공격력 += 3;
}
}
@Override
public void 이동하기() {
if(isMode) {
System.out.println("시즈모드에서는 이동이 불가능합니다.");
} else {
System.out.println("GOGOGO~~~");
}
}
}
|
cs |
- Terran > 다른 클래스들이 다 Terran을 상속받음
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package day10;
public class Terran {
int hp, x, y, 사거리, 공격력, 방어력;
int 공격속도, 이동속도;
void 이동하기() {
System.out.println("GOGOGO~~~");
}
void 정지() {
System.out.println("정지");
}
void 패트롤() {
System.out.println("순찰중~~~");
}
void status() {
System.out.println("---------------------");
System.out.println("체력 : "+hp);
System.out.println("x : "+x+" , y : "+y);
}
}
|
cs |
* Marine, Medic, SiegeTank의 Terran 상속 Test
|
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
44
45
46
47
|
package day10;
public class TestMain06 {
public static void main(String[] args) {
Marine m1 = new Marine();
Marine m2 = new Marine();
Medic me = new Medic();
System.out.println("m2 : "+m2);
m2.status();
m1.공격하기(m2);
m2.status();
m1.공격하기(me);
me.status();
SiegeTank st = new SiegeTank();
// st.changeMode();
// System.out.println(st.사거리);
// System.out.println("---------------------------");
// st.changeMode();
// System.out.println(st.사거리);
// st.이동하기();
// st.changeMode();
// st.이동하기();
// System.out.println("---------------------------");
m1.공격하기(st);
// st.status();
me.치료하기(m2);
// 향후에 모든 테란 유닛의 후손까지 치료할 수 있도록 해주기
me.치료하기(st); // 메딕으로 시즈탱크 치료하기
}
}
|
cs |
더보기
[ 응용 ]
코드1)
public class HandPhone{
String productName;
String productType;
int price;
String phoneNumber;
}
Q01. 각 변수마다 setter, getter method를 추가
ackage day10;
public class HandPhone {
String productType;
public void setproductType(String productType) {
this.productType = productType;
}
public String getproductType() {
return this.productType;
}
int price;
public void setprice(int price) {
this.price = price;
}
public int getprice() {
return this.price;
}
String phoneNumber;
public void setphoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
public String getphoneNumber() {
return this.phoneNumber;
}
}
Q02. 접근지정자의 접근범위가 작은것에서 큰순으로 기술하시요.
private < default < protected < public
Q03. 생성자와 일반 메세드의 차이점?
멤버 변수의 초기화를 목적으로 가지고 있는 메서드로,
리턴하지도 않고 리턴 키워드도 없으며 void도 사용하지 않음.
또한, 클래스명과 동일한 이름을 갖는다.
Q04. 사각형 클래스를 생성하시오
멤버변수 : int width, int height
넓이를 구하는 메서드 : getCalArea()
setter, getter
package day10;
public class Rectangle {
// 전역변수
int width, height;
// 멤버메서드
void getCalArea(int width, int height) {
System.out.println(width * height);
}
// setter
public void setwidth(int width) {
this.width = width;
}
// getter
public int getwidth() {
return this.width;
}
// setter
public void setheight(int height) {
this.width = height;
}
// getter
public int getheight() {
return this.height;
}
}
Q05. 원 클래스를 생성하시오
멤버변수 : 반지름 : int r
넓이를 구하는 메서드 : getCalArea() : Math.PI
setter, getter
package day10;
public class Circle {
// 전역변수
int r;
// 멤버 메서드
void getCalArea(int r) {
System.out.println(r*r*Math.PI);
}
// setter
public void setr(int r) {
this.r = r;
}
// getter
public int getr() {
return this.r;
}
}
Q06 . 삼각형 클래스를 생성하시오.
멤버변수 : int width, int height
넓이를 구하는 메서드 : getCalArea()
setter, getter
package day10;
public class Triangle {
// 전역변수
int width, height;
// 멤버메서드
void getCalArea(int width, int height) {
System.out.println((width * height)/2);
}
// setter
public void setheight(int height) {
this.width = height;
}
// getter
public int getheight() {
return this.height;
}
}
package day10;
public class Day10Q004 {
public static void main(String[] args) {
// 변수 선언
int width, height, r;
// 객체 할당 연산자
Rectangle r1 = new Rectangle();
Circle c1 = new Circle();
Triangle t1 = new Triangle();
// 아래 숫자는 예시
r1.getCalArea(2, 3);
c1.getCalArea(3);
t1.getCalArea(2, 3);
}
}