이것이 자바다 의 Chapter08 을 참고하여 정리한 포스트입니다.

이전글
인터페이스 이론정리 - 1
인터페이스 이론정리 - 2
인터페이스 이론정리 - 3
인터페이스 이론정리 - 4

Chapter 08. 인터페이스 - (5)

6. 인터페이스 상속

인터페이스는 클래스와는 달리 다중 상속을 허용한다.
extends 키워드 뒤에 상속할 인터페이스를 나열한다.

1
public interface 하위인터페이스 extends 상위인터페이스1, 상위인터페이스1 {...}

하위 인터페이스를 구현하는 클래스

- 하위 클래스의 메소드뿐만 아니라 상위 인터페이스의 모든 추상 메소드에 대한 실체 메소드를 가지고 있어야 한다.
- 구현 클래스로부터 객체를 생성하고 나서 아래와 같이 하위 상위 인터페이스 타입으로 변환이 가능하다.

1
2
3
하위 인터페이스 변수 = new 구현클래스{...};
상위 인터페이스1 변수 = new 구현클래스{...};
상위 인터페이스2 변수 = new 구현클래스{...};

- 하위 인터페이스 타입 변환 : 상위, 하위 인터페이스에 선언된 모든 메소드 사용이 가능
- 상위 인터페이스 타입 변환 : 상위 인터페이스 선언 메소드만 사용 가능

ex) 인터페이스 상속 관계 예시

- interfaceC 인터페이스 변수는 methodA(), methodB(), methodC() 를 모두 호출할 수 있다.
- InterfaceA와 interfaceB 변수는 각각의 methodA 와 methodB 만 호출할 수 있다.

  • InterfaceA.java 부모 인터페이스
    1
    2
    3
    
      public interface InterfaceA {
          public void methodA();
      }
    
  • InterfaceB.java 부모 인터페이스
    1
    2
    3
    
      public interface InterfaceB {
          public void methodB();
      }
    
  • InterfaceC.java 하위 인터페이스
    1
    2
    3
    
      public interface InterfaceC extends InterfaceA, InterfaceB {
          public void methodC();
      }
    
  • Implementation.java 하위 인터페이스 구현
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
      public interface ImplementationC implements InterfaceC {
          //InterfaceA와 InterfaceB의 실체 메소드가 있어야 한다.
          public void methodA() {
              System.out.println("ImplementationC-methosA() 실행");
          }
          public void methodB() {
              System.out.println("ImplementationC-methosB() 실행");
          }
          public void methodC() {
              System.out.println("ImplementationC-methosC()실행");
          }
      }
    
  • Example.java 인터페이스 호출 가능 메소드
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
      public class Example  {
          public static void main(String[] args) {
              ImplementationC impl = new ImplementationC();
    
              //interfaceA 변수는 methodA() 만 호출 가능
              InterfaceA ia = impl;
              ia.methodA();
              System.out.println();
    
              //interfaceB 변수는 methodB() 만 호출 가능
              InterfaceB ib = impl;
              ib.methodB();
              System.out.println();
    
              //모두 호출 가능
              InterfaceC ic = impl;
              ic.methodA();
              ic.methodB();
              ic.methodC();
          }
      }
    
    실행결과
    ImplementationC-methodA() 실행

    ImplementationC-methodB() 실행

    ImplementationC-methodA() 실행
    ImplementationC-methodB() 실행
    ImplementationC-methodC() 실행

🌞 정보 : 공부 기록용 블로그입니다. 오타나 내용 오류가 있을 경우 알려주시면 감사하겠습니다.

댓글남기기