[Java] Interface

인터페이스 (Interface)

• 객체가 어떤 방식으로 동작해야 하는지를 정의하는 추상 타입
• 추상 메서드와 상수만으로 구성된 특수한 클래스
• 모든 메서드가 추상 메서드인 추상 클래스와 유사
• 객체의 기능을 정의하고, 실제 구현은 인터페이스를 구현하는 클래스에서 담당

인터페이스의 필요성

• 서로 다른 클래스에 대해 공통된 동작을 보장할 때
• 여러 인터페이스를 동시에 구현 가능
• 한 클래스에 대해 여러 개의 인터페이스 구현이 가능

인터페이스 구현 방법

• interface 키워드를 사용하여 선언

 

1. 멤버 변수

• public static final 특성을 가짐
• 해당 키워드들이 생략 가능
• 타입 상수명 = 값;

2. 메서드 (public abstact이 항상 포함)

• 모든 메서드는 추상 메서드여야 함 (abstract 키워드가 생략 가능)
• 해당 인터페이스의 활용을 위해 모든 클래스에서 접근 가능 (public 키워드가 생략 가능)

3. 디폴트 메서드

• 인터페이스에 새 기능을 추가하면서 기존 구현을 포함
• 기본 구현 제공, 오버라이딩(재정의) 가능

4. 정적 메서드

• 인터페이스에서 직접 구현
• 인터페이스 이름으로 직접 호출, 오버라이딩 불가능

 

인터페이스 구현

• 클래스에 implements 키워드를 사용하여 인터페이스 구현

 

(예제 코드 1)

interface PlayingCard {
	// 1. 멤버 변수
	public static final int SPADE = 4;
	final int DIAMOND = 3;
	static int HEART = 2;
	int CLOVER = 1;
	
	// 2. 메서드 (public abstract이 항상 포함)
	public abstract String getCardNumber();
	String getCardKind();
	
	// 3. 디폴트 메서드
	default void defaultMethod() {
		System.out.println("디폴트 메서드 입니다.");
	}
	
	// 4. 정적 메서드
	static void staticMethod() {
		System.out.println("정적 메서드입니다.");
	}
}

class Card implements PlayingCard {
	private String cardNumber;
	private String cardKind;
	
	public Card(String cardNumber, String cardKind) {
		this.cardNumber = cardNumber;
		this.cardKind = cardKind;
	}
	
	// 인터페이스 안의 메서드를 구현한 클래스 메서드는 public 지정
	public String getCardNumber() {
		return cardNumber;
	}
	public String getCardKind() {
		return cardKind;
	}
	
	@Override
	public void defaultMethod() {
		System.out.println("Card 클래스에서 재정의된 디폴트 메서드 입니다.");
	}
}

public class B_Interface {
	public static void main(String[] args) {
		// == 인터페이스의 추상 메서드 사용 ==
		Card card = new Card("7", "Heart");
		
		System.out.println(card.getCardNumber());
		System.out.println(card.getCardKind());
		
		// 재정의(오버라이딩)가 선택적
		card.defaultMethod();	// Card 클래스에서 재정의된 디폴트 메서드 입니다.
		
//		card.staticMethod();	- Error
		PlayingCard.staticMethod(); // 인터페이스 이름으로만 호출 가능
		
		// == 인터페이스의 필드(상수) 사용 ==
		System.out.println(PlayingCard.CLOVER);
		System.out.println(PlayingCard.DIAMOND);
		System.out.println(PlayingCard.HEART);
		System.out.println(PlayingCard.SPADE);
	}
}

 

(예제 코드 2)

package chapter09;

interface Flyable{
	// 상수 final 생략 (public static final)
	// >> UPPER_SNAKE_CASE 사용 권장
	// >> 선언과 동시에 초기화
	int MAX_SPEED = 100;
	void fly(); // (public abstract 생략)
	
	// 디폴트 메서드 >> 재정의 가능
	default void land() {
		System.out.println("Landing");
	}
	
	// 정적 메서드 >> 재정의 불가능
	static int getWingCount() {
		return 2;
	}
}

class Bird implements Flyable {
	// 인터페이스를 구현하는 클래스에서 인터페이스에 정의된 상수 사용 가능
	public void fly() {
		System.out.println("새는 최대 속력이 " + MAX_SPEED + " 입니다.");
	}
	
	@Override
	public void land() {
		System.out.println("...Landing...");
		
	}
}

public class C_Interface {
	public static void main(String[] args) {
		Bird bird = new Bird();
		
		bird.fly(); // Bird 구현 메서드
		bird.land(); // 디폴트 메서드 - 재정의 동작
		
		System.out.println(Flyable.getWingCount());	// 정적 메서드 - 인터페이스 호출
	}
}

 

다중 인터페이스 구현

• 자바에서는 여러 개의 인터페이스를 동시에 구현이 가능
• 둘 이상의 타입으로 동작 가능

다중 인터페이스 구현 방법

• implements 키워드 뒤에 여러 개의 인터페이스를 ,로 구분하여 나열

interface Example1{
	int EXAMPLE_VARIABLE = 10;
	void printVar1();
	
	default void method() {
		System.out.println("예시 1");
	}
}

interface Example2{
	void printVar2();
	
	default void method() {
		System.out.println("예시 2");
	}
}

class ExampleClass implements Example1, Example2{
	public void printVar1() {
		System.out.println(EXAMPLE_VARIABLE);
	}
	public void printVar2() {
		System.out.println("다중 인터페이스 구현");
	}
	
	@Override
	public void method() {
		System.out.println("Method, 중복되는 디폴트 메서드");
	}
}

public class D_interface {
	public static void main(String[] args) {
		ExampleClass exClass = new ExampleClass();
		exClass.printVar1();	// 10
		exClass.printVar2();	// 다중 인터페이스 구현
		exClass.method();	// Method, 중복되는 디폴트 메서드

		Example1 exInterface = exClass;
		exInterface.printVar1();	// 10
//		exInterface.printVar2();	
		exInterface.method();	// Method, 중복되는 디폴트 메서드
		
	}
}

 

(추가내용)

// cf) 다중 인터페이스의 주의 사항
// : 여러 개의 인터페이스에 같은 시그니처(선언부)를 가진 디폴트 메서드가 존재할 경우
// >> 선언이 같고 구현이 다른 메서드가 충돌

// cf) 인터페이스의 다형성
// : 인터페이스를 구현한 클래스의 객체는 해당 인터페이스 타입이 될 수 있음
// >> 해당 인터페이스 내의 구조만을 가지며
// >> 재정의 된 메서드는 유지