ch 7-35~37 인터페이스의 선언,상속,구현

인터페이스(interface)

추상 메서드의 집합(static메서드,상수,디폴트메서드도 포함은 된다.)
구현된 것이 전혀 없는 설계도. 껍데기(모든 멤버가 public)

• 작은 객체 1개 + 큰 객체 1개의 구조
• 노란색 : 메서드
• 안의 동그라미들 : iv(변수)
• 작은 객체에서 큰 객체의 변수에 접근하기 위해서는 메서드를 통해 접근해야 한다.(캡슐화)
• 캡슐화 : data(iv) 보호
• 노란색의 선 = 인터페이스
  <추상클래스와 인터페이스의 차이>
• 추상클래스 = 일반 클래스인데, 추상메서드를 가지고 있는 것(멤버변수를 가질 수 있다.)
• 인터페이스 = 추상메서드만 가지고 있는 것.(다른 것은 가질 수 없다.)

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

Ex) 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 final int CLOVER =1; / 상수
        public abstract String getCardNumber();	// 추상메서드
        String getCardKind();	// public abstract String getCardKind(); / 추상메서드 / 
	}

• 상수 = 항상 public static final이기 때문에 생략가능
• 추상메서드 = 항상 public abstract이기 때문에 생략가능

인터페이스의 상속

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

• 인터페이스는 컴파일 해도 extends Object가 들어가지 않는다.
  다중 상속이 가능.(추상메서드는 충돌해도 문제 없음)(=조상이 여러 개 가능)

interface Fightable extends Movable, Attackable {}
interface Moveable {
	/**지정된 위치(x,y)로 이동하는 기능의 메서드*/
    void move(int x, int y);
interface Attackable {
	/**지정된 대상(u)을 공격하는 기능의 메서드*/
    void attack(Unit u);
}

• 조상 A,B가 존재하고 같은 메서드를 상속받는 자손 C가 존재할 때, A와 B의 선언부는 같지만, 내용{}이 다를 때
• 선언부가 다르면 둘 다 상속받으면 그만인데, 선언부가 같고 내용{}이 다르면 어느쪽을 상속받을지 결정할 수 없다. (= 충돌)
• 하지만, 추상메서드는 몸통(내용)이 없으므로 이름이 같아도 Ok.
• Fightable은 멤버변수가 없어보이지만, Moveable 1개 + Attackable 1개, 총 2개가 된다.

인터페이스의 구현

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

• 인터페이스도 미완성 설계도(=추상 메서드 포함)

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

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

• Fighter 클래스는 Fightable 인터페이스를 구현했다. (= 추상메서드를 구현해서 몸통{}을 만들었다.)
• 추상클래스의 완성과 같지만, implements를 사용한다는 점에서 다르다.
  일부만 구현하는 경우, 클래스 앞에 abstract를 붙여야 함.

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

• 2개 중 1개만 구현했기 때문에 abstract를 붙여줘야 한다.

Q&A

Q. 인터페이스란?
A. 추상 메서드의 집합
Q2. 인터페이스의 구현이란?
A. 인터페이스의 추상메서드 몸통{} 만들기(미완성 설계도 완성하기)

Ex)
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(Unit u) { /*내용 생략*/ }
}

• 미완성 설계도를 상속을 통해 완성된 설계도로 구현했다.
  Q3. 추상클래스와 인터페이스의 공통점은?
  A. 추상메서드를 가지고 있다. (미완성 설계도)
  Q4. 추상클래스와 인터페이스의 차이점은?
  A. 인터페이스는 iv를 가질 수 없다.
  
  * 추상클래스는 iv,생성자,추상메서드/인스턴스메서드를 가지고 있다.
  • 인스턴스는 iv, 생성자, 인스턴스메서드가 불가하고 추상메서드만 가능하다.

ch 7-38 인터페이스와 다형성

인터페이스를 이용한 다형성

인터페이스도 구현 클래스의 부모? -> Yes.

• 다형성 = 조상의 참조변수로 자손객체를 가리키는 것.

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

• Fighter는 Unit을 상속받고 Fightable 인터페이스를 구현하고 있다.
• 인터페이스를 통해 다중상속의 충돌 문제를 해결하였다.

Unit	  u = new Fighter(); // 조상클래스-자손객체 가능
Fightable f = new Fighter(); // 인터페이스-자손객체 가능

• Fightable에 정의된 멤버 2개만 사용 가능하다.

interface Fightable {
	void move(int x, int y);
    void attack(Fightable f); // Fightable인터페이스를 구현한 클래스의 인스턴스만 가능
}

f.move(100,200);
f.attack(new Fighter());

인터페이스 타입 매개변수는 인터페이스 구현한 클래스의 객체만 가능
인터페이스를 메서드의 리턴타입으로 지정할 수 있다.

Fightable method() { // Fightable은 리턴(반환)타입(= Fightable인터페이스를 구현한 클래스의 인스턴스를 반환)
	...
    Fighter f = new Fighter();	//	이 두 문장을 한 문장으로 바꾸면 다음과 같다.
    return f;					//	return new Fighter();
}

• Fightable를 구현해서 Fighter 객체를 반환한다.
• 메서드의 반환타입이 인터페이스라면, 인터페이스 구현한 객체를 반환해준다. 그래서, 받는 쪽의 타입도 같은 인터페이스여야 한다.
• f는 Fighter타입이지만, Fightable의 자손이기 때문에 Fightable로 형변환이 가능하기 때문에 일치시킬 수 있다.

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