[37] 230220 Java Ch. 8 인터페이스: 1. 인터페이스, 2. 타입 변환과 다형성 [K-디지털 트레이닝 37일]

230220 Mon 37th class

Ch. 8 인터페이스
진도: p. 370 ~ (교재: 혼자 공부하는 자바, 저자: 신용권)
한빛미디어_혼공자_용어집.pdf
용어 참고

혼자 공부하는 자바 | 신용권 - 교보문고

오늘 배운 것 중 기억할 것을 정리했다. 

---

지난 수업 때 배운 것 중 다시 기억할 것

2023.02.17 - [1. Revision 2023/Java] - [36] 230217 Ch. 7 상속(3): 3. 추상 클래스

추상 클래스[부모]: 클래스들의 공통적인 특성을 추출해서 선언한 클래스
클래스들의 공통적인 필드와 메서드를 추출해서 선언한 클래스이다.

실체 클래스[자식]: 객체를 직접 생성할 수 있는 클래스 (이때까지 배운 것!) 
실체 클래스는 추상 클래스의 모든 특성을 물려받고, 추가적인 특성(필드와 메서드)을 가질 수 있다. 

An argument is a way for you to provide more information to a function.

---

기타) 

API stands for Application Programming Interface. 
API = 설명서, 순서 같은 것 
An application programming interface(API) is a way for two or more computer programs to communicate with each other.

7 Examples of APIs in Use Today

• Twitter Bots.
• Log-In Using XYZ.
• Weather Snippers.
• Pay with PayPal.
• Google Maps.
• Travel Booking.
• E-Commerce.

What is Java 8 API?

Introduced in Java 8, the Stream API is used to process collections of objects. A stream is a sequence of objects that supports various methods which can be pipelined to produce the desired result.

https://docs.oracle.com/javase/8/docs/api/

ex) Math 클릭했을 때 나오는 Method Summary를 보면 소스를 가리는 인터페이스만 제공해준다. 

---

Ch. 8 인터페이스

책의 목차
08-1 인터페이스
08-2 타입 변환과 다형성

인터페이스(interface): 객체의 사용 방법을 정의한 타입
개발 코드와 객체가 서로 통신하는 접점 역할을 한다. 
개발 코드가 인터페이스의 메서드를 호출하면 인터페이스는 객체의 메서드를 호출시킨다. 구성 멤버는 상수 필드와 추상 메서드이다.

설계 목적이 아닌 구현 목적으로 쓴다. 추상 클래스보다 더 추상적으로 한다. 
구현이 안 되어 있는 부모 클래스라고 생각하면 이해가 쉽다. 

Why And When To Use Interfaces?

1) To achieve security - hide certain details and only show the important details of an object (interface).

2) Java does not support "multiple inheritance" (a class can only inherit from one superclass). However, it can be achieved with interfaces, because the class can implement multiple interfaces. Note: To implement multiple interfaces, separate them with a comma (see example below).

참고: https://www.w3schools.com/java/java_interface.asp

인터페이스(interface)란?

자식 클래스가 여러 부모 클래스를 상속받을 수 있다면, 다양한 동작을 수행할 수 있다는 장점을 가지게 될 것입니다.
하지만 클래스를 이용하여 다중 상속을 할 경우 메소드 출처의 모호성 등 여러 가지 문제가 발생할 수 있어 자바에서는 클래스를 통한 다중 상속은 지원하지 않습니다.

하지만 다중 상속의 이점을 버릴 수는 없기에 자바에서는 인터페이스라는 것을 통해 다중 상속을 지원하고 있습니다.
인터페이스(interface)란 다른 클래스를 작성할 때 기본이 되는 틀을 제공하면서, 다른 클래스 사이의 중간 매개 역할까지 담당하는 일종의 추상 클래스를 의미합니다.

자바에서 추상 클래스는 추상 메소드뿐만 아니라 생성자, 필드, 일반 메소드도 포함할 수 있습니다.
하지만 인터페이스(interface)는 오로지 추상 메소드와 상수만을 포함할 수 있습니다.

Another way to achieve abstraction in Java, is with interfaces.
An interface is a completely "abstract class" that is used to group related methods with empty bodies:

// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}

Notes on Interfaces:

• Like abstract classes, interfaces cannot be used to create objects (in the example above, it is not possible to create an "Animal" object in the MyMainClass)
• Interface methods do not have a body - the body is provided by the "implement" class
• On implementation of an interface, you must override all of its methods
• Interface methods (추상 메서드) are by default abstract and public
• Interface attributes are by default public, static and final
• An interface cannot contain a constructor (as it cannot be used to create objects)

---

8.1.1 인터페이스 선언

인터페이스 선언은 class 키워드 대신에 interface 키워드를 사용한다. 

자바에서 인터페이스를 선언하는 방법은 클래스를 작성하는 방법과 같습니다.
인터페이스를 선언할 때에는 접근 제어자와 함께 interface 키워드를 사용하면 됩니다.
자바에서 인터페이스는 다음과 같이 선언합니다.

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

단, 클래스와는 달리 인터페이스의 모든 필드는 public static final이어야 하며, 모든 메소드는 public abstract이어야 합니다.
이 부분은 모든 인터페이스에 공통으로 적용되는 부분이므로 이 제어자는 생략할 수 있습니다.
이렇게 생략된 제어자는 컴파일 시 자바 컴파일러가 자동으로 추가해 줍니다.

class A{
// 필드 (변수, 상수)
// 생성자
// 메서드
}

interface A{
// 상수 필드
// 생성자(X)
// 추상 메서드
}

---

1) 상수 필드 (Constant field) 선언

인터페이스의 상수 필드는 기본적으로 public static final 특성을 가진다. 관례적으로 필드 이름은 모두 대문자로 작성해야 하며, 선언 시 초기값을 대입해야 한다.
(static final 생략 가능)

[public static final] 타입 상수이름 = 값;

상수 이름은 대문자로 작성하되, 서로 다른 단어로 구성되어 있을 경우에는 언더바(_)로 연결하는 것이 관례이다.
ex) MODEL, MAX_VALUE
인터페이스 상수는 반드시 선언과 동시에 초기값을 지정해야 한다.

예시) 상수 필드 선언

public interface RemoteControl {
	//상수 필드
	//public static final int MAX_VALUE = 10;
	//public static final int MIN_VALUE = 0;
	public int MAX_VOLUME = 10;
	public int MIN_VOLUME = 0;
}

---

2) 추상 메서드 선언

인터페이스에 선언된 메서드는 public abstract가 생략되고 메서드 선언부만 있는 추상 메서드이다. 구현 클래스는 반드시 추상 메서드를 재정의해야한다. 
(abstract 생략 가능)

[public abstract] 리턴타입 메서드이름(매개변수, ...);

예시) 추상 메서드 선언

public interface RemoteControl {
	//상수 필드
	//public static final int MAX_VALUE = 10;
	//public static final int MIN_VALUE = 0;
	public int MAX_VOLUME = 10;
	public int MIN_VOLUME = 0;
	
	//추상 메서드
	//public abstract void turnOn();
	//public abstract void turnOff();
	//public abstract void setVolume(int volume);
	
	public void turnOn();
	public void turnOff();
	public void setVolume(int volume);
}

---

8.1.2 인터페이스 구현

개발 코드가 인터페이스 메서드를 호출하면 인터페이스는 객체의 메서드를 호출한다.
객체는 인터페이스에서 정의된 추상 메서드와 동일한 메서드 이름, 매개 타입, 리턴 타입을 가진 실체 메서드를 가지고 있어야 한다.
이러한 객체를 인터페이스의 구현(implement) 객체라고 하고, 구현 객체를 생성하는 클래스를 구현 클래스라고 한다. 

implements: 구현 클래스는 어떤 인터페이스로 사용 가능한지(어떤 인터페이스를 구현하고 있는지)를 기술하기 위해 클래스 선언 시 implements 키워드를 사용한다.

To access the interface methods, the interface must be "implemented" (kinda like inherited) by another class with the implements keyword (instead of extends). The body of the interface method is provided by the "implement" class:

// Interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}

class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

---

1) 구현 클래스

public class 구현클래스 이름 implements 인터페이스이름{
//인터페이스에 선언된 추상 메서드의 실체 메서드 선언
}

예시 1) 구현 클래스

public class Television implements RemoteControl {
	//필드
	private int volume;
	
	//인터페이스에 선언된 추상 메서드의 구현 메서드 선언
	//turnOn() 추상 메서드의 실체 메서드
	public void turnOn() {
		System.out.println("TV를 켭니다.");
	}
	
	//turnOff() 추상 메서드의 실체 메서드
	public void turnOff() {
		System.out.println("TV를 끕니다.");
	}
	
	//setVolume() 추상 메서드의 실체 메서드
	public void setVolume(int volume) {
		if(volume>RemoteControl.MAX_VOLUME) {
			this.volume = RemoteControl.MAX_VOLUME;
		} else if (volume<RemoteControl.MIN_VOLUME) {
			this.volume = RemoteControl.MIN_VOLUME;
		} else {
			this.volume = volume;
		}
		System.out.println("현재 TV 볼륨: " + this.volume);
	}
}

예시 2) 구현 클래스

public class Audio implements RemoteControl {
	//필드
	private int volume;
	
	//인터페이스에 선언된 추상 메서드의 구현 메서드 선언
	//turnOn() 추상 메서드의 실체 메서드
	public void turnOn() {
		System.out.println("Audio를 켭니다.");
	}
	
	//turnOff() 추상 메서드의 실체 메서드
	public void turnOff() {
		System.out.println("Audio를 끕니다.");
	}
	
	//setVolume() 추상 메서드의 실체 메서드
	public void setVolume(int volume) {
		if(volume>RemoteControl.MAX_VOLUME) {
			this.volume = RemoteControl.MAX_VOLUME;
		} else if (volume<RemoteControl.MIN_VOLUME) {
			this.volume = RemoteControl.MIN_VOLUME;
		} else {
			this.volume = volume;
		}
		System.out.println("현재  Audio 볼륨: " + this.volume);
	}
}

---

인터페이스로 구현 객체를 사용하려면 인터페이스 변수를 선언하고 구현 객체를 대입해야 한다.

인터페이스 변수;
변수 = 구현객체;

인터페이스 변수 = 구현객체;

예제 3) 인터페이스 변수에 구현 객체 대입

public class RemoteControlExample {
	public static void main(String[] args) {
		//int a;
		RemoteControl rc;
		//a = 10;
		rc = new Television();
		//a = 20;
		rc = new Audio();
	}
}

---

2) 다중 인터페이스 구현 클래스

인터페이스는 다중상속이 가능하다. (추상 클래스는 다중상속이 안 된다.)
인터페이스는 소스를 가리는 목적으로 보안과 연관이 있다.
설계, 구현 구분으로도 쓰인다. 

To implement multiple interfaces, separate them with a comma.

public class 구현클래스이름 implements 인터페이스A, 인터페이스B{
	//인터페이스 A에 선언된 추상 메서드의 실체 메서드 선언
    //인터페이스 B에 선언된 추상 메서드의 실체 메서드 선언
}

예제) 

interface FirstInterface {
  public void myMethod(); // interface method
}

interface SecondInterface {
  public void myOtherMethod(); // interface method
}

class DemoClass implements FirstInterface, SecondInterface {
  public void myMethod() {
    System.out.println("Some text..");
  }
  public void myOtherMethod() {
    System.out.println("Some other text...");
  }
}

class Main {
  public static void main(String[] args) {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}

다중 인터페이스를 구현할 경우, 구현 클래스는 모든 인터페이스의 추상 메서드에 대해 실체 메서드를 작성해야 한다.

예제 1) 인터넷을 검색할 수 있는 Searchable 인터페이스
search() 추상 메서드

public interface Searchable {
	//추상 메서드
	//public abstract void search(String url);
	void search(String url); 
}

예제 2) 다중 인터페이스 구현 클래스

public class SmartTelevision implements RemoteControl, Searchable{
	private int volume;
	
	//RemoteControl의 추상 메서드에 대한 실체 메서드
	@Override
	public void turnOn() {
		System.out.println("TV를 켭니다.");
	}

	@Override
	public void turnOff() {
		System.out.println("TV를 끕니다.");
	}

	@Override
	public void setVolume(int volume) {
		if(volume>RemoteControl.MAX_VOLUME) {
			this.volume = RemoteControl.MAX_VOLUME;
		} else if (volume<RemoteControl.MAX_VOLUME) {
			this.volume = RemoteControl.MIN_VOLUME;
		} else {
			this.volume = volume;
		}
		System.out.println("현재 TV 볼륨: " + this.volume);
	}
	
	//Searchable의 추상 메서드에 대한 실체 메서드
	@Override
	public void search(String url) {
		System.out.println(url + "을 검색합니다.");
	}
}

예제 3) 인터페이스 변수에 구현 객체 대입

public class SmartTelevisionExample {
	public static void main(String[] args) {
		SmartTelevision tv = new SmartTelevision();
		
		RemoteControl rc = tv;
		Searchable searchable = tv;
	}
}

---

8.1.3 인터페이스 사용 p. 379

구현 객체가 인터페이스 변수에 대입된다는 것을 알았으니, 지금부터 인터페이스로 구현 객체를 사용하는 방법을 알아보낟. 
클래스를 선언할 때 인터페이스는 필드, 생성자 또는 메서드의 매개 변수, 생성자 또는 메서드의 로컬 변수로 선언될 수 있다.

ex) 다음은 RemoteControl 인터페이스를 필드, 생성자 또는 메서드의 매개 변수 그리고 메서드의 로컬 변수로 선언했다.

public class MyClass {
	//필드
	//int a = 10;
	RemoteControl rc = new Television();
	
	//생성자
	MyClass(){}//기본 생성자(매개변수가 없는 생성자)
	MyClass(RemoteControl rc){//매개변수가 한 개인 생성자
		this.rc = rc;
	}
	
	//메서드
	void method() {
		//로컬 변수
	RemoteControl rc = new Audio();
	}
	
	void methodB(RemoteControl rc) {...}
}

예제 1) 인터페이스 사용 MyClass.java

package ch08;

public class MyClass {
	//필드
	//int a = 10;
	RemoteControl rc = new Television();
	
	//생성자
	MyClass(){//기본 생성자(매개변수가 없는 생성자)
	}

	MyClass(RemoteControl rc){//매개변수가 한 개인 생성자
		this.rc = rc;
		rc.turnOn();
		rc.setVolume(5);
	}
	
	//메서드
	void methodA() {
		//로컬 변수
	RemoteControl rc = new Audio();
	rc.turnOn();
	rc.setVolume(5);
	}
	
	void methodB(RemoteControl rc) {
	rc.turnOn();
	rc.setVolume(5);
	}
}

예제 2) 인터페이스 사용 MyClassExample.java

public class MyClassExample {
	public static void main(String[] args) {
		System.out.println("1)------------------");
		
		MyClass myClass1 = new MyClass(); //MyClass의 기본생성자를 호출
		myClass1.rc.turnOn();
		myClass1.rc.setVolume(5);
		
		System.out.println("2)------------------");
		MyClass myClass2 = new MyClass(new Audio());//MyClass의 매개변수가 한 개인 생성자 호출
	
		System.out.println("3)------------------");
		MyClass myClass3 = new MyClass(); //MyClass의 기본생성자를 호출(Television 클래스)
		myClass3.methodA();
		
		System.out.println("4)------------------");
		MyClass myClass4 = new MyClass();
		myClass4.methodB(new Television());
	}
}

결과)

1)------------------
TV를 켭니다.
현재 TV 볼륨: 5
2)------------------
Audio를 켭니다.
현재  Audio 볼륨: 5
3)------------------
Audio를 켭니다.
현재  Audio 볼륨: 5
4)------------------
TV를 켭니다.
현재 TV 볼륨: 5

---

마무리 p. 384
5가지 키워드로 끝내는 핵심 포인트

1) 인터페이스 (interface) [8장 370쪽]: 객체의 사용 방법을 정의한 타입이며 개발 코드와 객체가 서로 통신하는 접점 역할을 한다. 개발 코드가 인터페이스의 메서드를 호출하면 인터페이스는 객체의 메서드를 호출시킨다. 그렇기 때문에 개발 코드는 객체의 내부 구조를 알 필요가 없고 인터페이스의 메서드만 알고 있으면 된다.
구성 멤버는 상수 필드와 추상 메서드이다.

2) 상수 필드: 인터페이스의 상수 필드는 기본적으로 public static final 특성을 가진다. 관례적으로 필드 이름은 모두 대문자로 작성해야 하며, 선언 시 초기값을 대입해야 한다.

3) 추상 메서드: 인터페이스에 선언된 메서드는 public abstract가 생략되고 메서드 선언부만 있는 추상 메서드이다. 구현 클래스는 반드시 추상 메서드를 재정의해야한다. 

4) implements: 구현 클래스는 어떤 인터페이스로 사용 가능한지(어떤 인터페이스를 구현하고 있는지)를 기술하기 위해 클래스 선언 시 implements 키워드를 사용한다.

5) 인터페이스 사용: 클래스를 선언할 때 인터페이스는 필드, 생성자 또는 메서드의 매개 변수, 생성자 또는 메서드의 로컬 변수로 선언될 수 있다.

인터페이스가 필드 타입으로 사용될 경우:	필드에 구현 객체를 대입할 수 있다.
인터페이스가 생성자의 매개 변수 타입으로 사용될 경우:	new 연산자로 객체를 생성할 때 구현 객체를 생성자의 매개값으로 대입할 수 있다.
인터페이스가 로컬 변수 타입으로 사용될 경우:	변수에 구현 객체를 대입할 수 있다.
인터페이스가 메서드의 매개 변수 타입으로 사용될 경우:	메서드 호출 시 구현 객체를 매개값으로 대입할 수 있다.

---

Q3) main() 메서드에서 printSound()를 호출할 때 Cat과 Dog 객체를 주고 실행하면 각각 "야옹"과 "멍멍"이 출력되도록 Cat과 Dog 클래스를 작성하라.

전체 코드

예제 1) Soundable 인터페이스
sound() 추상 메서드는 객체의 소리를 리턴한다. 

package ch08;
public interface Soundable {
	String sound();
}

예제 2) 아래를 작성하시오.

package ch08;
public class Cat implements Soundable {
	//메서드 재정의(오버라이딩)
	public String sound() {
		return "야옹";
	}
}

예제 3) 아래를 작성하시오.

package ch08;
public class Dog implements Soundable {
	//메서드 재정의(오버라이딩)
	public String sound() {
		return "멍멍";
	}
}

예제 4) SoundableExample 클래스에서 printSound() 메서드는 Soundable 인터페이스 타입의 매개 변수를 가지고 있다. 
Soundable soundable = new Cat();

package ch08;
public class SoundableExample {
	public static void printSound(Soundable soundable) {//인터페이스 타입, 변수
		System.out.println(soundable.sound());
	}
	
	public static void main(String[] args) {
		printSound(new Cat());
		printSound(new Dog());
	}
}

결과)

야옹
멍멍

---

8.2 타입 변환과 다형성 p. 386

다형성을 구현하기 위해서는 메서드 재정의와 타입 변환이 필요하다. 인터페이스도 제공하는 두 가지 기능으로 다형성을 구현하는 데 많이 사용된다. 
상속은 같은 종류의 하위 클래스를 만드는 기술이고, 인터페이스는 사용 방법이 동일한 클래스를 만드는 기술이다.

8.2.1 자동 타입 변환

자동 타입 변환: 구현 객체가 인터페이스 변수에 대입되는 것

class Tire{}
          자식                           부모
class HankookTire extends Tire{}
class KumhoTire extends Tire{}

main(){

Tire t = HankookTire //참조 자동 타입 변환 (부모(큰) ← 자식(작은))

}

Interface Tire{}
         구현클래스                       인터페이스
class HankookTire implements Tire{}

main(){
인터페이스 = 구현클래스
Tire t = HankookTire //참조 자동 타입 변환(인터페이스 ← 구현)

클래스와 클래스 간의 관계
부모 클래스 타입 변수 = 자식 클래스;

인터페이스와 클래스 간의 관계
인터페이스 변수 = 구현객체; 

---

8.2.2 필드의 다형성 p. 387

다형성: 상속은 같은 종류의 하위 클래스를 만드는 기술이고, 인터페이스는 사용 방법이 동일한 클래스를 만드는 기술이라는 개념상의 차이는 있지만 둘 다 다형성을 구현하는 방법은 비슷하다. 모두 재정의와 타입 변환 기능을 제공하기 때문이다.

타이어: 인터페이스 타입 (클래스 타입 X) 
한국 타이어, 금호 타이어: 구현 클래스 (자식 클래스 X)

필드의 다형성: Car의 run() 메서드를 수정하지 않아도 다양한 roll() 메서드의 실행결과를 얻을 수 있다.

전체 코드

예제 1) 인터페이스

package ch8_2;
//[1]
public interface Tire {
// public abstract void roll(); (추상 메서드)
	public void roll();//roll메서드 호출 사용 방법 설명
}

예제 2) 구현 클래스

package ch8_2;
//[2]
public class HankookTire implements Tire{
	@Override//메서드 재정의(오버라이딩)
	public void roll() { //Tire 인터페이스 구현 
	System.out.println("한국 타이어가 굴러갑니다.");
	}	
}

예제 3) 구현 클래스

package ch8_2;
//[3]
public class KumhoTire implements Tire{
	@Override//메서드 재정의(오버라이딩)
	public void roll() { //Tire 인터페이스 구현 
	System.out.println("금호 타이어가 굴러갑니다.");
	}	
}

예제 4) 필드 다형성

package ch8_2;
//[4]
public class Car {
	//필드: 인터페이스 타입 필드 선언과 초기 구현 객체 대입
	Tire frontLeftTire = new HankookTire();
	Tire frontRightTire = new HankookTire();
	Tire backLeftTire = new HankookTire();
	Tire backRightTire = new HankookTire();
	//생성자(따로 선언X) - 기본 생성자가 자동 추가
	
	//메서드: 인터페이스에서 설명된 rol() 메서드 호출
	void run() {
		frontLeftTire.roll();
		frontRightTire.roll();
		backLeftTire.roll();
		backRightTire.roll();
	}
}

예제 5) 필드 다형성 테스트

package ch8_2;
//[5]
public class CarExample {
	public static void main(String[] args) {
		Car myCar = new Car();
		//Car 클래스의 필드 다형성이 HankookTire로만 되어 있어 한국타이어 4개가 출력
		myCar.run();
		//Car 클래스의 frontLeftTire, frontRightTire는 금호타이어로 교체
		myCar.frontLeftTire = new KumhoTire();
		myCar.frontRightTire = new KumhoTire();
		
		myCar.run();
	}
}

결과) 

한국 타이어가 굴러갑니다.
한국 타이어가 굴러갑니다.
한국 타이어가 굴러갑니다.
한국 타이어가 굴러갑니다.
금호 타이어가 굴러갑니다.
금호 타이어가 굴러갑니다.
한국 타이어가 굴러갑니다.
한국 타이어가 굴러갑니다.

---

8.2.3 매개 변수의 다형성 

다형성: 상속은 같은 종류의 하위 클래스를 만드는 기술이고, 인터페이스는 사용 방법이 동일한 클래스를 만드는 기술이라는 개념상의 차이는 있지만 둘 다 다형성을 구현하는 방법은 비슷하다. 모두 재정의와 타입 변환 기능을 제공하기 때문이다.

예제 1) 매개 변수의 인터페이스화
Vehicle 참조 변수는 vehicle에 있는 인터페이스에 있는 것만 실행 가능하다. 

package ch8_2;
//[1]
public class Driver {
	public void drive(Vehicle vehicle) {
//Vehicle vehicle = new Bus();
//	vehicle.run();
//Vehicle vehicle = new Taxi();
		vehicle.run();
	}
}

예제 2) 인터페이스

package ch8_2;
//[2]
public interface Vehicle {
	public void run();
}

예제 3) 구현 클래스

package ch8_2;
//[3]
public class Bus implements Vehicle{
	@Override //메서드 재정의
	public void run() {
		System.out.println("버스가 달립니다.");
	}
}

예제 4) 구현 클래스

package ch8_2;
//[4]
public class Taxi implements Vehicle{
	@Override //메서드 재정의
	public void run() {
		System.out.println("택시가 달립니다.");
	}
}

예제 5) 매개 변수의 다형성 테스트

package ch8_2;
//[5]
public class DriverExample {
	public static void main(String[] args) {
		Driver driver = new Driver();
		
		Bus bus = new Bus();
		Taxi taxi = new Taxi();
		
		driver.drive(bus);//자동타입변환:Vehicle vehicle=bus;
		driver.drive(taxi);//자동타입변환:Vehicle vehicle=taxi;
	}
}

결과)

버스가 달립니다.
택시가 달립니다.

---

8.2.4 강제 타입 변환 (Casting) p. 394

구현 객체가 인터페이스 타입으로 자동 타입 변환하면, 인터페이스에 선언된 메서드만 사용 가능하다는 제약 사항이 따른다. ex) 인터페이스에 3개의 메서드가 선언되어 있고 클래스에는 5개의 메서드가 선언되어 있다면, 인터페이스로 호출 가능한 메서드는 3개 뿐이다.

구현 클래스에 선언된 필드와 메서드를 사용해야 할 경우도 발생한다. 이때 강제 타입 변환을 해서 다시 구현 클래스 타입으로 변환한 다음, 구현 클래스의 필드와 메서드를 사용할 수 있다.

강제 타입 변환: 인터페이스에 대입된 구현 객체를 다시 원래 구현 클래스 타입으로 변환하는 것

구현클래스 변수 = (구현클래스) 인터페이스변수;

int a = 65;
//int <- char
//4byte <- 2byte
int b = 'A' (자동 타입 변환) 

char c = (char)a; 

예제 1) 인터페이스

public interface Vehicle {
	public void run();
}

예제 2) 구현 클래스

public class Bus implements Vehicle {

	@Override
	public void run() {
		System.out.println("버스가 달립니다.");
	}
	
	public void checkFare() {
		System.out.println("승차요금을 체크합니다.");
	}
}

예제 3) 강제 타입 변환

public class VehicleExample {
	public static void main(String[] args) {
		//인터페이스 타입 = 구현 객체 (참조 자동 타입 변환)
		Vehicle vehicle = new Bus();
		
		vehicle.run();
		//vehicle.checkFare(); (X): Vehicle 인터페이스에는 checkFare()가 없음
		
		//Bus클래스에 checkFare메서드가 있기 때문에 호출 가능
		//구현객체타입 = 인터페이스(참조 강제 타입 변환)
		Bus bus = (Bus) vehicle; //강제 타입 변환
		
		bus.run();
		bus.checkFare(); //Bus 클래스에는 CheckFare()가 있음
	}
}

---

8.2.5 객체 타입 확인 

우리는 상속에서 객체 타입을 확인하기 위해 instanceof 연산자를 사용했고, 인터페이스 타입에서도 사용할 수 있다.

instanceof: 강제 타입 변환을 하기 전에 변환이 가능한지 조사할 때 사용한다. 상속에서는 자식 클래스 타입인지, 인터페이스에서는 구현 클래스 타입인지를 확인할 때 사용한다.

ex) Vehicle 인터페이스 타입으로 변환된 객체가 Bus인지 확인하려면 아래처럼 작성한다.

if(vehicle instanceof Bus){
	Bus bus = (Bus) vehicle;
}

예제 1) 객체 타입 확인

public class Driver{
	public void drive(Vehicle vehicle) {//vehicle: Bus, Taxi 객체
		if(vehicle instanceof Bus) {//vehicle 매개 변수가 참조하는 객체가 Bus인지 조사
			Bus bus = (Bus) vehicle;//Bus 객체일 경우 안전하게 강제 타입 변환
			bus.checkFare();//Bus 타입으로 강제 타입 변환을 하는 이유
		}
		vehicle.run();
	}
}

예제 2) 객체 타입 확인

public class DriverExample{
	public static void main(String[] args) {
		Driver driver = new Driver();
		
		Bus bus = new Bus();
		Taxi taxi = new Taxi();
		
		driver.drive(bus);
		driver.drive(taxi);
	}
}

---

좀 더 알아보기) 인터페이스 상속 p. 399

인터페이스 상속: 클래스는 다중 상속을 허용하지 않지만, 인터페이스는 다중 상속을 허용한다. 즉 extends 키워드 뒤에 상위 인터페이스가 올 수 있다.

예제) 상위 인터페이스

package ch8_2;
//[1]
public interface InterfaceA {
	//public void abstract methodA();
	public void methodA();
}

예제) 상위 인터페이스

package ch8_2;
//[2]
public interface InterfaceB {
	//public void abstract InterfaceB();
	public void methodB();
}

예제) 하위 인터페이스

package ch8_2;
//[3]
public interface InterfaceC extends InterfaceA, InterfaceB {
	//public void methodA();
	//public void methodB();
	//public void abstract methodC();
	public void methodC();
}

예제) 하위 인터페이스 구현

package ch8_2;
//[4]
public class ImplementationC implements InterfaceC{
	public void methodA() {
		System.out.println("ImplementationC-methodA() 실행");
	}
	
	public void methodB() {
		System.out.println("ImplementationC-methodB() 실행");
	}
	
	public void methodC() {
		System.out.println("ImplementationC-methodC() 실행");
	}
}

예제) 호출 기능 메서드

package ch8_2;
//[5]
public class Example {
	public static void main(String[] args) {
		ImplementationC impl = new ImplementationC();
		//인터페이스 타입 = 구현 객체 (참조 자동 타입 변환)
		InterfaceA ia = impl;
		ia.methodA();
		System.out.println();
		
		//인터페이스 타입 = 구현 객체 (참조 자동 타입 변환)
		InterfaceB ib = impl;
		ib.methodB();
		System.out.println();
		
		//인터페이스 타입 = 구현 객체 (참조 자동 타입 변환)
		InterfaceC ic = impl;
		ic.methodA();
		ic.methodB();
		ic.methodC();
	}
}

결과)

ImplementationC-methodA() 실행

ImplementationC-methodB() 실행

ImplementationC-methodA() 실행
ImplementationC-methodB() 실행
ImplementationC-methodC() 실행

---

마무리
5가지 키워드로 끝내는 핵심 포인트

1) 자동 타입 변환: 구현 객체가 인터페이스 변수에 대입되는 것

2) 다형성: 상속은 같은 종류의 하위 클래스를 만드는 기술이고, 인터페이스는 사용 방법이 동일한 클래스를 만드는 기술이라는 개념상의 차이는 있지만 둘 다 다형성을 구현하는 방법은 비슷하다. 모두 재정의와 타입 변환 기능을 제공하기 때문이다.

3) 강제 타입 변환: 인터페이스에 대입된 구현 객체를 다시 원래 구현 클래스 타입으로 변환하는 것

4) instanceof: 강제 타입 변환을 하기 전에 변환이 가능한지 조사할 때 사용한다. 상속에서는 자식 클래스 타입인지, 인터페이스에서는 구현 클래스 타입인지를 확인할 때 사용한다.

5) 인터페이스 상속: 클래스는 다중 상속을 허용하지 않지만, 인터페이스는 다중 상속을 허용한다. 즉 extends 키워드 뒤에 상위 인터페이스가 올 수 있다.

class A{}
class B extends A{}

main(){
          // 상속관계의 자동 타입 변환
          // 부모클래스 타입(A) ← 자식클래스(B)         
          A a = new B();          

          // 상속관계의 강제 타입 변환          
          // 자식클래스 타입(B) ← 부모클래스(A)         
          B() = (B) a;
}
======================================
interface A{} // 인터페이스

class B implements A{} // 구현객체

main(){
          // 인터페이스와 구현 객체 관계의 자동 타입 변환
          // 인터페이스 타입(A) ← 자식 클래스 (B)
          A a = new B();         

          // 인터페이스와 구현 객체 관계의 강제 타입 변환         
          // 구현객체 타입(B) ← 인터페이스(A)
          B b = (B) a;
}

참고: http://alecture.blogspot.com/2011/05/abstract-class-interface.html

---

확인 문제
Q1 (4) 메서드의 매개변수 타입이 인터페이스이면 매개값으로 모든 구현 객체를 대입하면 자동 타입 변환이 된다. (O)

interface A{
          // 추상 메서드
          void add(A a); //인터페이스
}

class B implements A{
          // 구현 메서드
          add(B) //구현 객체 변수 
}

인터페이스 타입 = 구현 객체 (자동 타입 변환)
          A a            = new(B);

---

Q3 DaoExample 클래스의 main() 메서드에서 dbWork() 메서드를 호출할 때 OracleDao와 MysqlDao 객체를 매개값으로 주고 호출했다. 
dbWork() 메서드는 두 객체를 모두 매개값으로 받기 위해 DataAccessObject 타입의 매개 변수를 가지고 있다.
실행 결과를 보고 DataAccessObject 인터페이스와 OracleDao, MysqlDao 구현 클래스를 각각 작성하라.

실행 결과)

OracleDB에서 검색
OracleDB에 삽입
OracleDB를 수정
OracleDB를 삭제
Mysql에서 검색
Mysql에 삽입
Mysql를 수정
Mysql를 삭제

인터페이스 타입 = 구현 객체 (자동 타입 변환)
DataAccessObject dao = new OracleDao();

전체 코드

예제 1) DaoExample.java
dbWork() 메서드를 호출할 때 OracleDao와 MysqlDao 객체를 매개값으로 주고 호출한다.

package ch08;
//[1]
public class DaoExample {
								//인터페이스 타입
	public static void dbWork(DataAccessObject dao) {
		dao.select();
		dao.insert();
		dao.update();
		dao.delete();
	}//dbWork 끝

	public static void main(String[] args) {
		//구현객체
		dbWork(new OracleDao());
		//구현객체
		dbWork(new MysqlDao());
	}
}

예제 2) DataAccessObject.java 인터페이스

package ch08;
//[2]
public interface DataAccessObject {
	//추상 메서드
	public void select();
	public void insert();
	public void update();
	public void delete();
}

예제 3) MysqlDao.java 구현 클래스

package ch08;
//[3]
public class MysqlDao implements DataAccessObject{

		public void select() {
			System.out.println("Mysql에서 검색");
		}
		public void insert() {
			System.out.println("Mysql에 삽입");
		}
		public void update() {
			System.out.println("Mysql를 수정");
		}
		public void delete() {
			System.out.println("Mysql를 삭제");
		}		
}

예제 4) OracleDao.java 구현 클래스

package ch08;
//[4]
public class OracleDao implements DataAccessObject{
	//DataAccessObject interface의 추상 메서드를 구현하는 구현메서드
	public void select() {
		System.out.println("OracleDB에서 검색");
	}
	public void insert() {
		System.out.println("OracleDB에 삽입");
	}
	public void update() {
		System.out.println("OracleDB를 수정");
	}
	public void delete() {
		System.out.println("OracleDB를 삭제");
	}
}

---