인터페이스의 선언, 상속, 구현

인터페이스(interface)

추상 메서드의 집합

구현된 것이 전혀 없는 설계도, 껍데기(모든 멤버가 public)

 

인터페이스 선언

변수(iv, cv) 가질 수 없다, 상수는 됨

모든 인터페이스의 멤버는 public, 메서드는 abstract(추상 메서드)

interface 인터페이스이름 {
    public static final 타입 상수이름 = 값; // 상수
    public abstract 메서드이름(매개변수목록); // 추상메서드(중요!)
}

 

여기에서 String getCardKind();는 추상 메서드인데 abstract가 없다, 이는 pulbic와 abstract를 생략한 것임

(생략 가능 이유: 인터페이스의 메서드는 public이고 abstract이기 때문)

final int DIAMOND와 같은 상수도 항상 public static final이기 때문에 생략 가능하다

interface PlayingCard {
    public static final int SPADE = 4; // int SPACE = 4;로 public static final 생략 가능
    final int DIAMOND = 3; // public static final int DIAMOND = 3; 상수
    static int HEART = 2; // public static final int HEART = 2; 상수
    int CLOVER = 1; // public static final int CLOVER = 1; 상수
    
    public abstract String getCardNumber(); // public abstract 생략 가능, 추상 메서드
    String getCardKind();  // public abstract String getCardKind(); 추상 메서드
}

 

인터페이스 상속

인터페이스의 조상은 인터페이스만 가능(Object가 최고 조상이 아니다)

다중 상속 가능(추상 메서드는 충돌해도 문제 없다)

[클래스인 경우 단일 상속만 가능하다]

인터페이스만 다중 상속 가능한 이유: 추상 메서드의 집합 -> 충돌이 발생할 것이 없다(몸통 자체가 없다)

Fightable 인터페이스는 멤버가 2개(Movable 1개, Attackable 1개)이다

interface Fightable extends Movable, Attackable { } // 다중 상속, 멤버 2개

interface Movable {
    void move(int x, int y);
}

interface Attackable {
    void attack(Unit u);
}

 

기존 메서드 충돌 문제

같은 메서드를 두 개의 부모가 가지고 있으면서 내용이 다르면 어떤 것을 선택(충돌)해야 하는지 알 수 없다)

선언부가 다르면 둘 다 상속받으면 괜찮지만, 선언부가 같고 내용{}이 다르면 어느쪽을 상속받을지 결정할 수 없다

인터페이스는 이러한 걱정이 없다

 

인터페이스 구현

인터페이스에 정의된 추상 메서드를 완성하는 것

class 클래스이름 implements 인터페이스이름 {
    // 인터페이스에 정의된 추상메서드를 모두 구현해야된다
}

 

Fightable이라는 인터페이스가 있을 때, Fighter 클래스는  Fightable이라는 인터페이스를 구현한다

(Fighter 클래스는 Fightable 인터페이스를 구현했다), (Fightable 인터페이스가 가지고 있는 두 개의 추상 메서드의 몸통{}을 완성했다)

interface Fightable {
    void move(int x, int y); // public abstract 생략
    void attack(Unit u); // public abstract 생략
}

class Fighter implements Fighterable {
    public void move(int x, int y) { /* 내용 생략 */}
    public void attack(Unit u) { /* 내용 생략 */}
}

 

추상 메서드 두 개 중 1개만 구현했을 경우, 클래스 앞에 abstract를 붙여야 한다

(attack는 구현하지 않았다)

abstract class Fighter implements Fightable {
    public void move(int x, int y) { /* 내용 생략 */ }
    // public abstract void attack(Unit u); // 안보이지만 생략되어 있다
}

---

1. 인터페이스란?

추상 메서드 집합

(상수, static 메서드, default 메서드 추가)

 

2. 인터페이스 구현이란?

인터페이스의 추상메서드 몸통{} 만들기(미완성 설계도 완성하기)

abstract class Player { // 추상클래스(미완성 클래스)
    abstract void play(int pos); // 추상메서드(몸통 {}이 없는 미완성 메서드)
    abstract void stop(); // 추상클래스
}

// 추상 클래스 구현
class AudioPlayer extends Player {
    void play(int pos) { /* 내용 생략 */} // 추상 메서드 구현
    void stop() { /* 내용 생략 */} // 추상 메서드 구현
}



interface Fightable {
    void move(int x, int y);
    void attack(Unit u);
}

// 인터페이스 구현
class Fighter implements Fightable {
    public void move(int x, int y) { /* 내용 생략 */}
    public void attack(int x, int y) { /* 내용 생략 */}
}

 

3. 추상 클래스와 인터페이스의 공통점?

추상 메서드를 가지고 있다(미완성 설계도)

 

4. 추상 클래스와 인터페이스의 차이점?

인터페이스는 iv를 가질 수 없다

인터페이스: 추상 메서드를 제외하고 아무것도 가질 수 없는 것(멤버변수를 가질 수 없다, iv, 생성자), 구현된 것이 아무것도 없다

추상클래스: 일반 클래스인데 추상 메서드를 가지고 있는 것(생성자, iv, ... 가지고 있음)