컴퓨터 관련/JAVA 강의

java #15 interface, 추상클래스

승명 2016. 12. 18. 19:44

java #15 interface, 추상클래스

 
* interface

- 다중 상속 사용 시(다른 기능을 원하는 만큼 받을 수 있다.)
- 약결합의 구현으로 클래스간의 유연성을 높일 수 있다. 자바의 꽃 -> DI                              
- 객체화가 되지 않는다.
- 생성자가 들어가지 못한다.
- is a 관계의 객체화는 된다.
- 인터페이스끼리 상속된다.

interface 인터페이스
상수

추상메서드


- 문법) 접근지정자 interface 인터페이스명 extends 부모인터페이스명...{
           public : 외부 패키지에서 사용 가능
           default : 외부 패키지에서 사용 불가능
--------------------------------------------------------
구현하는 클래스) 
접근지정자 class 클래스명 extends(생략가능) 부모클래스명(생략가능) implements(생략가능) 구현할 인터페이스명(생략가능)

interface

1
2
3
4
5
6
7
8
9
10
11
12
13
package day0221;
/**
* 다중상속을 사용할 필요가 있을 때 interface를 사용한다.
* 약결합을 구현할 수 있으므로 클래스간의 유연성을 높일 수 있다.
*/
public interface Test {
  //int i; 변수작성 불가능
     public static final int CONST=100; //상수사용    
     //public Test(){ //생성자작성불가
     //}    
public void temp();
public abstract String getName();
}
cs

구현class

 
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
package day0221;
 
public class TestImpl implements Test{
     public static void main(String[] args){
     //Test = new Test(); //interface는 직접객체화를 할 수 없다.
 
     //is a 관계의 객체화 가능
     //상수, 인터페이스에 정의된 메서드 사용할 수 있다.
     Test t=new TestImpl();
     System.out.println("상수 "+t.CONST);    
     t.temp();
     System.out.println(t.getName());
 
     //자식클래스로 객체화
     //구현한 인터페이스의 상수, 추상메서드, 자신의 변수, 메서드를 호출할 수 있다.
     TestImpl ti=new TestImpl();
     t=ti; //is a 관계 이기 때문에 할당 가능
    
     /*
     TEST
     ↑
     TestImpl
    
     is a 관계의 클래스, 인터페이스끼리는 cast    
     */
    
     TestImpl ti1 = (TestImpl)t;
     }//main
 
     @Override
     public void temp() {
          System.out.println("구현한 메서드");         
     }
 
     @Override
     public String getName() {
          return "홍길동";         
     }
}
 
cs


*Abstract class(추상클래스)

- 상속을 위해 만드는 클래스

abstract class 클래스명
변수


메소드


추상메소드
body가 없는 메소드로, 구현의 강제성이 있는 메소드.
자식클래스는 반드시 이 메소드를 override 해야 한다.

- 작성법
  . 접근지정자 abstract 반환형 메서드명(매개변수 ...); 
     public
     protected
  . body({})가 없으므로 일을 할 수 없고 호출이 불가능.
  . 객체화가 되지 않고, 자식클래스가 객체화 될때만 객체화 된다. (자식클래스에 의해 객체화 된다.)

추
상
클
래
스

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
package day0220;
 
/**
* 상속을 위해서 만드는 추상클래스 직접 객체화가 될 수 없고, 
* 자식클래스를 객체화 했을 때에만 객체화가 된다. 구현의 강제성(반드시
* Override 해야한다.)을 가지는 추상메서드를 가질 수 있다.
*/
public abstract class AbstractSuper {
     int i; // instance 변수
 
     public AbstractSuper() {
          System.out.println("추상클래스 생성자");
     }// AbstractSuper
 
     public void method() {
          System.out.println("일반메서드");
     }
 
     // abstract 접근 지정자를 붙이고 body '{}'가 없이 작성하는 메서드.구현의 강제성을 가진다.
     public abstract void aMethod();
     public abstract String bMethod(int i);
     /*
     * public static void main(String[] args) { 
         new AbstractSuper(); << error, 추상클래스는 직접 객체화 불가능. 
      }
     */
 
}
cs

자
식
클
래
스

 
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
package day0220;
/**
* 추상클래스를 상속받는 자식클래스 : 부모의 추상메소드를 모두 구현(Override)해야 한다.
*/
public class AbstractSub extends AbstractSuper {
    
     public AbstractSub(){
          System.out.println("자식클래스 생성자");
     }
     public void aMethod() {
          //부모의 일반메서드 호출
          super.method(); //성공         
          //부모의 추상메서드 호출 불가능, error 발생
          //super.aMethod();// 실패
          System.out.println("구현한 메서드");                                                                      
     }
     public String bMethod(int i) {
          return i + "번";
     }
     public static void main(String[] args) {
          //부모(추상클래스)직접 객체화 할 수 없다.
          //AbstractSuper as new AbstractSuper();
          AbstractSub as= new AbstractSub();
          as.aMethod();
     }//main
}//class
 
cs


* interface와 추상클래스를 동시에 상속받아 구현하는 예제

추상클래스 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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package day0221;
 
/**
*
* 사람을 객체모델링하여 만든 클래스<br/>
* 사람의 명사적 특징 : 눈,코,입,이름<br/>
* 사람의 동사적특징 : 먹는일<br/>
* 사용예) 객체화 Person p = new Person();
*
*/
 
//클래스 작성 시 final, abstract는 같이 사용못함. 서로 상충하는 지정자
public abstract class Person {
     private int eye, nose, mouth;
     private String name;
 
     /**
     * 생성되는 사람 객체의 눈(2개), 코(1개), 입(1개)로 객체를 생성하는 기본생성자 
     * 사용법) Person p=new Person();
     */
     public Person() {
          this(2, 1, 1); // 인자있는 생성자를 호출해서 값을 넣어줌
          /*
          * eye=2;
          *
          * nose=1; mouth=1;
          */
     }// Person
 
     /**
     * 생성되는 사람 객체가 눈, 코, 입의 갯수가 2,1,1이 아닌 객체를 만들 때 사용 
     * 사용법) Person p=new Person(눈의수, 코의수, 입의수);
     *
     * @param eye
     *            눈의 갯수
     * @param nose
     *            코의 갯수
     * @param mouth
     *            입의 갯수
     */
     public Person(int eye, int nose, int mouth) {
          this.eye = eye;
          this.nose = nose;
          this.mouth = mouth;
     }// Person
 
     // 02-18-2014 : 생성자 코드 추가 시작//
     /**
     * 사람객체의 눈의 개수
     *
     * @param eye
     *            설정할 눈의 개수
     */
     public void setEye(int eye) {
          this.eye = eye;
     }
 
     /**
     * 사람객체의 코의 개수
     *
     * @param nose
     *            설정할 코의 개수
     */
     public void setNose(int nose) {
          this.nose = nose;
     }
 
     /**
     * 사람객체의 입의 개수
     *
     * @param mouth
     *            설정할 입의 개수
     */
     public void setMouth(int mouth) {
          this.mouth = mouth;
     }
 
     /**
     * 사람의 이름
     *
     * @param name
     *            설정할 이름
     */
     public void setName(String name) {
          this.name = name;
     }
 
     /**
     * 사람 눈의 갯수
     *
     * @return 눈의 갯수
     */
     public int getEye() {
          return eye;
     }
 
     /**
     * 코의 갯수
     *
     * @return 코의 갯수
     */
     public int getNose() {
          return nose;
     }
 
     /**
     * 입의 갯수
     *
     * @return 입의 갯수
     */
     public int getMouth() {
          return mouth;
     }
 
     public String getName() {
          return name;
     }
 
     /**
     * 사람이 집에서 밥을 먹는다.
     *
     * @return
     */
     public abstract String eat();
 
     /**
     * Overload된 메소드<br/>
     * 사람이 밖에서 음식을 사먹는 일.
     *
     * @param menu
     *            사먹는 음식의 종류
     * @param price
     *            사먹는 음식의 가격
     * @return 사먹는 일
     */
     public abstract String eat(String menu, int price);
    
     /**
     * 사람이 구사하는 언어를 정의하는 일
     * @return 언어
     */
     public abstract String language(); 
}
cs
interface
비행하는 사람(수퍼맨)의 기능을 정의
1
2
3
4
5
6
7
8
9
package day0221;
 
/**
* 비행하는 사람(예, 수퍼맨)이 구현해야할 기능을 정의
*/
public interface Fly {
public abstract String speed(); //속도
public String height();//높낮이
}
cs
HongGilDong클래스
추상클래스 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
package day0221;
 
/**
* Person의 자식 클래스 
* (눈, 코, 입, 이름, 먹는일은 부모클래스의 변수, 메서드로 구현되어있다.)<br/>
* 자식클래스는 부모클래스의 자원을 사용하고 자신만의 특징만 정의하면 된다.
*
*/
public class HongGilDong extends Person {
 
     private int level; 
     /**
     * 기본생성자 : instance(member) 변수에 초기값으로 level 6을 넣어준다.
     */
     public HongGilDong() {
          level = 6;
     }// HongGilDong
 
     /**
     * 싸움을 하는 메소드
     *
     * @param yourLevel
     *            상대방레벨
     * @return 싸움의 결과
     */
     public String fight(int yourLevel) {
          String result = "";
          if (level > yourLevel) { // 이긴경우
               level++; // 레벨업
               result = "이겼다";
          } else if (level < yourLevel) { // 진경우
               level--;// 레벨다운
               result = "졌다";
          } else { // 비긴경우
               result = "비겼다";
          }// end else
          return result;
     }
 
     // 부모클래스에 제공하는 메서드가 자식클래스에 맞지 않는다면 
     //자식클래스에 부모 클래스의 메서드를 동일하게 만들고 사용하는 Override 적용
     @Override
    
     public String eat(String menu, int price) {
          return getName() + "이 주막에서 " + menu + "인 음식을 " 
                                  + price + "원 내고 사먹는다.";
     }
     @Override
     public String eat(){
          return getName() + "이 집에서 밥을 먹는다.";
     }
 
     @Override
     public String language() {         
          return "한국어";
     }
}// class
cs
비행이 가능한 수퍼맨을 구현한 Clark클래스
추상클래스 Person과 인터페이스 Fly를 상속받아 구현
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
package day0221;
 
/**
* 2-21일 인터페이스를 구현하는 코드를 추가
* Person의 자식 클래스(눈,코,입,이름은 Person 클래스를 사용한다.)<br/>
* 자신의 특징만 구현.
* 클락은 수퍼맨이므로 비행이 가능한 사람이다.
* 추상클래스 Person과 인터페이스 Fly를 상속받아 구현한다.
*/
//final은 자식클래스를 가질 수 없는(상속을 해줄 수 없는) 클래스
public final class Clark extends Person implements Fly {
 
     private int power;
 
     /**
     * 객체가 생성될때 power를 9로 설정한다.
     */
     public Clark() {
          power = 9;
     }// Clark
 
     /**
     * 가지는 돌에따라 변화하는 힘의 특징
     *
     * @param stoneType
     * @return
     */
     public String power(String stoneType) {
          String result = "";
          if (stoneType.equals("크립토나이트")) {// 힘이 빠진다.
               power = 1;
               result = "힘이 빠짐";
          } else if (stoneType.equals("다이아몬드")) {// 힘이 생기는 돌
               power = 9;
               result = "감사합니다.";
          } else {// 짱돌
               power = 12;
               result = "빡침";
 
          }// end else
          return result;
     }
 
     // 클락은 집에서 빵을 먹는다.
     @Override
     public String eat() {
          return getName() + " 집에서 빵을 먹는다.";
     }
     // 클락은 레스토랑에서 음식을 먹을때 $를 지불한다.
     public String eat(String menu, int price){
          return getName()+" 이(가) 레스토랑에서 "+menu+"인 음식을 
                              $"+price+"를 내고 사먹는다.";
     }
 
     @Override
     public String language() {
          return "영어";
     }
 
     @Override
     public String speed() {
          return getName()+"가 빠른 속도로 날고 있다.";
     }//speed
 
     @Override
     public String height() {
          // TODO Auto-generated method stub
          return getName()+"가 높게 날고 있다.";
     }//height
}
cs
RunPerson
구현한 클래스를 사용하는 클래스
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
package day0221;
 
/**
* 상속관계의 자식클래스를 객체화하여 사용하는 클래스
*/
public class RunPerson {
 
     public static void main(String[] args) {
          HongGilDong gilDong = new HongGilDong();
 
          gilDong.setName("홍길동");
          System.out.println(gilDong.getEye()+" / "+gilDong.getNose()+" /
                         "+ gilDong.getMouth()+ " / "+gilDong.getName());
          System.out.println(gilDong.eat());
          System.out.println(gilDong.eat("국밥",1));
          System.out.println(gilDong.fight(5));//이김 레벨 6->7
          System.out.println(gilDong.fight(7));//비김 7
          System.out.println(gilDong.fight(8));//짐 6         
 
          Clark superman = new Clark();
 
          superman.setName("클락 켄트");
          System.out.println(superman.getEye()+" / "+superman.getNose()+" / 
                    "+ superman.getMouth()+ " / "+superman.getName());
 
          System.out.println(superman.eat());
          System.out.println(superman.eat("스테이크",5)); 
          System.out.println(superman.power("크립토나이트"));
          System.out.println(superman.power("다이아몬드"));
          System.out.println(superman.power("짱돌"));         
 
          System.out.println(s);
          System.out.println("--------------------------------------------------------------");
          System.out.println(gilDong.getName()+"이 구사하는 언어는 "+gilDong.language());
          System.out.println(superman.getName()+"이 구사하는 언어는 "+superman.language());
          System.out.println("--------------------------------------------------------------");
          System.out.println(superman.speed());
          System.out.println(superman.height());
     }
 
}
 
cs

'컴퓨터 관련 > JAVA 강의' 카테고리의 다른 글

java #17 배열(array)   (0) 2016.12.18
java #16 문자열, String클래스 메소드   (0) 2016.12.18
java #14 다형성, 오버로드(overload), 오버라이드(override), Annotation   (0) 2016.12.18
java #13 상속(inheritance), super   (0) 2016.12.18
java #12 생성자, 멤버변수와 인스턴스변수, this   (0) 2016.12.18

'컴퓨터 관련/JAVA 강의'의 다른글

  • 현재글java #15 interface, 추상클래스

관련글

티스토리툴바