5. 다형성(polymorphism)

5.1 다형성이란?

상속과 함께 객체지향개념의 중요한 특징 중에서 하나이다.
다형성은 상속과 깊은 관계가 있으므로 상속에 대해서 충분히 알고 있는 것이 좋다.

객체지향개념에서 다형성이란 '여러 가지 형태를 가질 수 있는 능력'을 의미하며
자바에서는 한 타입의 참조변수로 여러 타입의 객체를 참조할 수 있도록 함으로써 다형성을 프로그램적으로 구현했다.

이를 좀 더 구체적으로 말하자면, 조상클래스 타입의 참조변수로 자손클래스의 인스턴스를 참조할 수 있도록 했다.

class TV {
	boolean power; // 전원상태 (on/off)
    int channel; // 채널
    
    void power() { power =!power; }
    void channelU() { ++channerl; }
    void channelDown() { --channel; }
}
class CaptionTv extends TV {
	String text; // 캡션을 보여 주기 위한 문자열
    void caption() { /*내용생략*/ }
}

Tv 클래스와 CaptionTv 클래스는 서로 상속관계에 있으며,
이 두 클래스의 인스턴스를 생성하고 상죵하기 위해서는 다음과 같이 할 수 있다.

Tv t =new Tv();
CaptionTv c = new CaptionTv();

지금까지 생성된 인스턴스를 다루기 위해서
인스턴스의 타입과 일치하는 타입의 참조변수만 사용했다.

즉, Tv인스턴스를 다루기 위해서는 Tv타입의 참조변수를 사용하고
CaptionTv인스턴스를 다루기 위해서는 CaptionTv타입의 참조변수를 사용했다.

이처럼 인스턴스의 타입과 참조변수의 타입이 일치하는 것이 보통이지만,
Tv와 CaptionTv클래스가 서로 상속관계에 있을 경우,
다음과 같이 조상 클래스 타입의 참조변수로 자손 클래스의 인스턴스를 참조하도록 하는 것도 가능하다.

Tv t = new CaptionTv(); // 조상 타입의 참조변수로 자손 인스턴스를 참조

그러면 인스턴스를 같은 타입의 참조변수로 참조하는 것과
조상타입의 참조변수로 참조하는 것은 어떤 차이가 있는지 알아보자.

CpationTv c = new CaptionTv();
TV t = new CaptionTV();

클래스 TV와 CaptionTV는 서로 상속관계에 있으며,
이 두 클래스의 인스턴스를 생성하고 사용하기 위해서는 다음과 같이 할 수 있다.

TV t = new TV();
caption TV c = new CaptionTV();

지금까지 생성된 인스턴스를 다루기 위해, 인스턴스의 타입과 일치하는 타입의 참조변수만 사용했다.
즉, TV인스턴스를 다루기 위해서는 TV타입의 참조변수를 사용하고,
CaptionTV인스턴스를 다루기 위해서는 CaptionTV타입의 참조변수를 사용했다.

이처럼 인스턴스의 타입과 참조변수의 타입이 일치하는 것이 보통이지만,
TV와 CaptionTV클래스가 서로 상속관계에 있을 경우
아래와 같이 조상 클래스 타입의 참조변수로 자손 클래스의 인스턴스를 참조하도록 하는 것도 가능하다.

TV t = new captionTV(); // 조상 타입의 참조변수로 자손 인스턴스를 참조

인스턴스를 같은 타입의 참조변수로 참조하는 것과
조상타입의 참조변수로 참조하는 것은 어떤 차이가 있을까?

CaptionTV c = new CaptionTV();
Tv t = new CaptionTV();

CaptionTV 인스턴스 2개를 생성하고 참조변수 c와 t가 생성된 인스턴스를 하나씩 참조했다.
이 경우 실제 인스턴스가 CaptionTV타입이라도 참조변수 t로 CaptionTV인스턴스의 모든 멤버를 사용할 수 없다.

TV 타입의 참조변수로는 CaptionTV 인스턴스 중에서 TV클래스의 멤버들(상속받은 멤버 포함)만 사용할 수 있다.

따라서, 생성된 CaptionTV인스턴스의 멤버 중에서 TV클래스에 정의되지 않은 멤버,
text와 caption()은 참조변수 t로 사용이 불가능하다.
즉, t.text 또는 t.caption()와 같이 할 수 없다는 것이다.
둘 다 같은 타입의 인스턴스지만 참조변수의 타입에 따라 사용할 수 있는 멤버의 개수가 달라진다.

반대로 자손타입의 참조변수로 조상타입의 인스턴스를 참조하는 것도 불가능하다.

CaptionTV c = new TV();

컴파일 에러가 발생한다.

실제 인스턴스인 TV의 멤버 개수보다 참조변수 c가 사용할 수 있는 멤버 개수보다 더 많기 때문이다.
그래서 이를 허용하지 않는 것이다.

CaptionTV클래스에는 text와 caption()이 정의되어 있으므로
참조변수 c로는 c.text, c.caption()과 같은 방식으로 c가 참조하고 있는 인스턴스에서 text와 caption()을 사용할 수 있다.

하지만 c가 참조하고 있는 인스턴스는 TV타입이고,
TV타입의 인스턴스에는 text와 caption()이 존재하지 않기 때문에 이를 사용하려고 하면 문제가 생긴다.

그래서 자손타입의 참조변수로 조상타입의 인스턴스를 참조하는 것은
존재하지 않는 멤버를 사용하고자 할 가능성이 있으므로 허용되지 않는 것이다.
참조변수가 사용할 수 있는 메버의 개수는 인스턴스의 멤버 개수보다 같거나 적어야 한다.
! 클래스는 상속을 통해서 확장될 수는 있어도 축소될 수는 없어서,
조상 인스턴스의 멤버 개수는 자손 인스턴스의 멤버 개수보다 항상 적거나 같다.

참조변수의 타입이 참조변수가 참조하고 있는
인스턴스에서 사용할 수 있는 멤버의 개수를 결정한다는 사실을 이해하는 것은 아주 중요하다.
! 모든 참조변수는 null 또는 4byte의 주소값이 저장되며,
참조변수의 타입은 참조할 수 있는 객체의 종류와 사용할 수 있는 멤버의 수를 결정한다.

조상타입의 참조변수로 자손타입의 인스턴스를 참조할 수 있다.
반대로 자손타입의 참조변수로 조상타입의 인스턴스를 참조할 수는 없다.

void doWork(Car c) {
	if (c instance of FireEngine) {
    		FireEngine fe = (FireEngine) c;
            fe.water();
            	...
    } else if (c instanceof Ambulance a = () {
    	Ambulance a = (Ambulance)c;
        a.sire();
        	...
    }
    ...
}

class BindingTest{
	public static void main(String[] args) {
    	Parent p = new Child();
        Child c = new Child();
        
        System.out.println("p.x = "+p.x);
        p.method();
        System.out.println("c.x = "+c.x);
        c.method();
    }
}
class Parent {
	int x = 100;
    
    void method() {
    	System.out.println("Parent Method");
    }
}
class Child extends Parent {
	int x = 200;
    
    void method() {
    	System.out.println("Child Method");
    }
}

class Product {
	int price; // 제품의 가격
    int bonusPoint; // 제품 구매 시 제공하는 보너스 점수
}
class TV extends Product {}
class computer extends Product {}
class Audio extends Product {}

class Buyer { // 고객, 물건을 사는 사람
	int money = 1000;  // 소유금액
    int bonusPoint = 0; // 보너슺 ㅓㅁ수
} 

void buy(TV t) {
	// Buyer가 가진 돈(money)에서 제품의 가격(t.price)만큼 뺀다.
    money = money - t.price;

	// Buyer의 보너스점수(bonusPoint)에 제품의 보너스 점수(t.bonusPoint)를 더한다.
    bonusPoint = bonusPoint + t.bonusPoint;
}

void buy(Computer c) {
	money = money - c.price;
    bonusPoint = bonusPoint + c.bonusPoint;
}

void buy(Audio c) {
	money = money - a.price;
    bonusPoint = bonusPoint + a.bonusPoint;
}

void buy(Product p) {
	money = money - p.price;
    bonusPoint = bonusPoint + p.bonusPoint;
}

Buyer b = new Buyer();
TV t = new Tv();
Computer c = new Computer();
b.buy(t);
b.buy(c);

Product p1 = new Tv();
Product p2 = new Computer();
Product p3 = new Audio();

Product p[] = new Product[3];
p[0] = new Tv();
p[1] = new Computer();
p[2] = new Audio;

class Buyer {
	int money = 1000;
    int bonusPoint = 0;
    Product[] item = new Product[10] // 구입한 제품을 저장하기 위한 배열
    int i = 0; // Product배열 item에 사용될 index
    
    void buy(Product p) {
    	if(money < p.price)
        	System.out.println("잔액이 부족해서 물건을 살 수 없습니다.");
            return;
    }
    money -= p.price; // 가진 돈에서 제품 가격을 뺀다.
    bonusPoint += p.bonusPoint; // 제품의 보너스포인트를 더한다.
    item[i++] = p; // 제품을 Produc[] item에 저장한다.
    Systme.out.println(p + "을/를 구입했습니다.");
}