インタフェース

抽象メソッドの集合.他の定数、静的メソッド、defaultメソッドから構成できます.
全く実装されていない設計図で、すべてのメンバーが共通です

インタフェースの設定

interface PlayingCard {
	// 상수
	public static final int SPADE = 4;
	final int DIAMOND = 3;
	static int HEART = 2;
	int CLOVER = 1; // 항상 예외없이 public static final이 붙으며 생략 가능
	// 추상 메서드
	public abstract String getCardNumber();
	String getCardKind(); // public abstract가 생략되어 있음
}

インタフェースと抽象クラス

抽象クラス:抽象メソッドを持つ一般クラス
インタフェース:抽象メソッドの集合、多重継承可能、ivを持つことができません
抽象クラスの目的は,継承により抽象メソッドを強制的に実施することである.
異なるのは,インタフェースが継承ではなく規則を制定することによって同じ動作を実現することである.

インタフェースの継承

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

interface Attackable { void attack(Unit u); }

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

インターフェースの親はインターフェースしかできない(対象は最高先祖ではない)

多重継承可能(抽象手法は実施部がなく、衝突も問題ない)

インタフェースの実装

インタフェースで定義された抽象メソッドの完了

class Fighter implements Fightable {
	public void move(int x, int y) {}
	public void attack(Unit u) {}
}

implementsキーワードでインタフェースを実現

このキーワードを持つクラスはインタフェースのすべての抽象メソッドを実装(再定義)しなければならない

一部しか実施していない場合abstract抽象類をキーワードで表記しなければならない

インタフェースを使用したマルチフォーム化

// 상속을 받으며 구현이 가능 (다중 상속)
class Fighter extends Unit implements Fightable {
	public void move(int x, int y) {}
    
	// 인터페이스 타입의 매개변수
	public void attack(Fightable f) {}
    
	// 인터페이스 리턴타입
	Fightable getFightable() {
		Fighter f = new Fighter();
		return f;
}

// 인터페이스 타입의 참조변수
Unit u = new Fighter(); // Unit이 부모 객체라서 가능
Fightable f = (Fightable) new Fighter();
Fightable f2 = new Fighter();

インターフェースは実装クラスの親

インターフェースもタイプとして扱われる

インタフェースタイプの参照変数

Fightable f = (Fightable) new Fighter(); // 인터페이스 타입으로 형변환
Fightable f2 = new Fighter(); // Fightable를 구현한 Fighter를 참조

インタフェースタイプの参照変数は、それを実装するクラスインスタンスを参照可能

インターフェースタイプに変換しても良い

インタフェースタイプのパラメータ

public void attack(Fightable f) {}

メソッドはインタフェースタイプのパラメータを持つことができる

メソッド呼び出し時には、そのインタフェースを実現するクラスの例をパラメータとして提供する必要がある

インタフェース戻りタイプ

Fightable getFightable() {
	Fighter f = new Fighter();
	return f;
}

メソッドの戻りタイプをインタフェースタイプとして指定できる

当該インタフェースを実現するクラスインスタンスを返却しなければならない

インタフェースの多形例

interface Parseable {
	// 구문 분석작업을 수행한다
	public abstract void parse(String fileName);
}

class ParserManager {
	// 인터페이스 리턴타입
	public static Parseable getParser(String type) {
		if(type.equals("XML")) {
			return new XMLParser();
		} else {
			Parseable p = new HTMLParser();
			return p;
			// return new HTMLParser();
		}
	}
}

// 인터페이스 구현
class XMLParser implements Parseable {
	public void parse(String fileName) {
		System.out.println(fileName + "- XML parsing completed.");
	}
}

class HTMLParser implements Parseable {
	public void parse(String fileName) {
		System.out.println(fileName + "-HTML parsing completed.");
	}
}

class ParserTest {
	public static void main(String args[]) {
		Parseable parser = ParserManager.getParser("XML");
		parser.parse("document.xml");
		parser = ParserManager.getParser("HTML");
		parser.parse("document2.html");
	}
}

インタフェースの利点

開発時間短縮可能

一貫した、定型化された開発が可能

関係のないクラスを組み合わせることができる

各クラス独立プログラミング可能

class A {
	public void method(B b) { // B 객체만 받을 수 있다
		b.method();
	}
}

class A2 {
	public void method(I i) { // I를 구현한 객체를 받을 수 있다
		i.method();
	}
}

interface I {
	abstract public void method();
}

class B implements I {
	public void method() {
		System.out.println("B method");
	}
}

class C implements I {
	public void method() {
		System.out.println("C method");
	}
}


A a = new A();
a.method(new B());
// a.method(new C()); // C 객체를 받으려면 A 클래스를 수정해야 함

A2 a2 = new A2();
a2.method(new B());
a2.method(new C()); // C 객체 또한 I를 구현했기 때문에 수정할 필요가 없음

defaultメソッドとstaticメソッド

JDK1.8から、defaultメソッドと静的メソッドをインタフェースに作成できます.静的メソッドは独立したメソッドであり、インスタンスを作成する必要はありませんが、defaultメソッドでは異なります.
インタフェースにメソッドを追加することは、抽象メソッドを追加することを意味し、そのインタフェースを実現するすべてのクラスに新しいメソッドが発生する現象を意味します.defaultメソッドは、これらの問題を解決するために追加されたメソッドであり、抽象的なメソッドの基本的な実装を提供するメソッドではないので、インタフェースを実装するクラスを変更する必要はありません.

defaultメソッドと静的メソッドの例

  
class DefaultMethodTest {
	public static void main(String[] args) {
		Child c = new Child();
		c.method1();
		c.method2();
		MyInterface.staticMethod(); 
		MyInterface2.staticMethod();
	}
}

class Child extends Parent implements MyInterface, MyInterface2 {
	public void method1() {	
		System.out.println("method1() in Child");
	}			
}

class Parent {
	public void method2() {	
		System.out.println("method2() in Parent");
	}
}

interface MyInterface {
	default void method1() { 
		System.out.println("method1() in MyInterface");
	}
	
	default void method2() { 
		System.out.println("method2() in MyInterface");
	}

	static  void staticMethod() { 
		System.out.println("staticMethod() in MyInterface");
	}
}

interface MyInterface2 {
	default void method1() { 
		System.out.println("method1() in MyInterface2");
	}

	static  void staticMethod() { 
		System.out.println("staticMethod() in MyInterface2");
	}
}

method1() in Child
method2() in Parent
staticMethod() in MyInterface
staticMethod() in MyInterface2