인터페이스

1. 인터페이스(interface)
1.1 인터페이스란?
- 일종의 추상클래스. 추상클래스(미완성 설계도)보다 추상화 정도가 높다.
- 실제 구현된 것이 전혀 없는 기본 설계도.(알맹이 없는 껍데기)
- 추상메서드와 상수만을 멤버로 가질 수 있다.
- 인스턴스를 생성할 수 없고, 클래스 작성에 도움을 줄 목적으로 사용된다.
- 미리 정해진 규칙에 맞게 구현하도록 표준을 제시하는데 사용된다.

1.2 인터페이스의 작성
- 'class'대신 'interface'를 사용한다는 것 외에는 클래스 작성과 동일하다.

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

- 구성요소(멤버)는 추상메서드와 상수만 가능하다.
-> 모든 멤버변수는 public static final 이어야 하며, 이를 생략할 수 있다.
-> 모든 메서드는 public abstract 이어야 하며, 이를 생략할 수 있다.
--> 컴파일시 생략된 제어자들은 컴파일러가 자동적으로 추가해주기 때문에 생략이 가능한 것이다.

interface PlayingCard {
    public static final int SPADE = 4;
    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 fianl int CLOVER = 1;
    
    public abstract String getCardNumber();
    String getCardKind(); // public abstract String getCardKind();
}

1.3 인터페이스의 상속
- 인터페이스도 클래스처럼 상속이 가능하다.(클래스와 달리 다중상속 허용)

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

interface Attackable {
    void attack(Unit u);
}

interface Fightable extends Movable, Attackable { }

- 인터페이스는 Object클래스와 같은 최고 조상이 없다.

1.4 인터페이스의 구현
- 인터페이스를 구현하는 것은 클래스를 상속받는 것과 같다.
다만, 'extends' 대신 'implements'를 사용한다.

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

- 인터페이스에 정의된 추상메서드를 완성해야 한다.

class Fighter implements Fightable {
    public void move() { /* 내용 생략 */ }
    public void attack() { /* 내용 생략 */ }
}

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

-> Fighter클래스에서 interface를 일부만(move메서드만) 구현한다면 class앞에 abstract를 붙여주어야 한다.

- 상속과 구현이 동시에 가능하다.

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

/* 자바에서는 다중상속은 안돼지만 interface는 ','를 구분자로 여러개 정의가능 */
class Fighter extends Unit implements Fightable, 인터페이스이름 {
    public void move(int x, int y) { /* 내용 생략 */ }
    public void attack(Unit u) { /* 내용 생략 */ }
}

1.5 인터페이스를 이용한 다형성
- 인터페이스 타입의 변수로 인터페이스를 구현한 클래스의 인스턴스를 참조할 수 있다.
- 인터페이스를 메서드의 매개변수 타입으로 지정할 수 있다.
-> 메서드의 매개변수 타입을 인터페이스로 한다는 것은 인터페이스를 구현한 클래스의 인스턴스를 매개변수로 제공한다는 의미이다.
- 인터페이스를 메서드의 리턴타입으로 지정할 수 있다.
-> 메서드의 리턴타입이 인터페이스라는 것은 인터페이스를 구현한 클래스의 인스턴스를 반환한다는 의미이다.

1.6 인터페이스의 장점
- 개발시간을 단추시킬 수 있다.
-> 일단 인터페이스가 작성되면, 이를 사용해서 프로그램을 작성하는 것이 가능하다. 메서드를 호출하는 쪽에서는 메서드의 내용에 관계없이 선언부만 알면 되기 때문이다. 그리고 동시에 다른 한 쪽에서는 인터페이스를 구현하는 클래스를 작성하도록 하여 인터페이스를 구현하는 클래스가 작성될 때까지 기다리지 않고도 양쪽에서 동시에 개발을 진행할 수 있다.

- 표준화가 가능하다.
-> 프로젝트에 사용되는 기본 틀을 인터페이스로 작성한 다음. 개발자들에게 인터페이스를 구현하여 프로그램을 작성하도록 함으로써 보다 일관되고 정형화된 프로그램의 개발이 가능하다.

- 서로 관계없는 클래스들에게 관계를 맺어 줄 수 있다.
-> 서로 상속관계에 있지도 않고 같은 조상클래스를 가지고 있지 않은 서로 아무런 관계도 없는 클래스들에게 하나의 인터페이스를 공통적으로 구현하도록 함으로써 관계를 맺어 줄 수 있다.
--> 관계를 맺어주면 다형성을 이용할 수 있다는 장점이 생긴다.

- 독립적인 프로그래밍이 가능하다.
-> 인터페이스를 이용하면 클래스의 선언과 구현을 분리시킬 수 있기 때문에 실제구현에 독립적인 프로그램을 작성하는 것이 가능하다. 클래스와 클래스 간의 직접적인 관계를 인터페이스를 이용해서 간접적인 관계로 변경하면, 한 클래스의 변경이 관련된 다른 클래스에 영향을 미치지 않는 독립적인 프로그래밍이 가능하다.

interface Repairable {
    void repair(Repairable r);
}

class GroundUnit extends Unit {
    GroundUnit(int hp) {
        super(hp);
    }
}

class AirUnit extends Unit {
    AirUnit(int hp) {
        super(hp);
    }
}

class Unit {
    int hitPoint;
    final int MAX_HP;
    Unit(int hp) {
        MAX_HP = hp;
    }
}

class Tank extends GroundUnit implements Repairable {
    Tank() {
        super(150); // Tank의 HP는 150이다.
        hit Point = Max_HP;
    }
    
    public String toString() {
        return "Tank";
    }
}

class Marine extends GroundUnit {
    Marine() {
        super(40);
        hitPoint = MAX_HP;
    }
}

class SCV extends GroundUnit implements Repairable {
    SCV() {
        super(60);
        hitPoint = MAX_HP;
    }
    
    void repair(Repairable r) {
        if (r instanceof Unit) {
            Unit u = (Unit)r;
            while(u.hitPoint != u.MAX_HP) {
                u.hitPoint++; // Unit의 HP를 증가시킨다.
            }
        }
    }
}

public static void main(String[] args) {
    Tank tank = new Tank();
    Marine marine = new Marine();
    SCV scv = new SCV();
    
    scv.repair(tank); // SCV가 Tank를 수리한다.
    // scv.repair(marine); // 에러!!! Marine클래스는 Repairable 인터페이스를 구현하고 있지 않기 때문
}