다형성 (Polymorphism)

하나의 객체가 여러 타입으로 사용되는 것

• 상속을 전제 조건
• 부모 타입에 어떠한 자식 객체든 들어갈 수 있다.

package day09.poly;

class A {}
class B extends A {}
class C extends A {}
class D extends B {}
class E extends C {}

/*
          Object
            |
            A
         /    \
        B     C
        |     |
        D     E

 */


public class Basic {

    void test() {

        // 다형성: 객체가 여러 타입을 사용할 수 있다.
        // - 부모의 타입을 사용 가능
        A x1 = new A();
        A x2 = new B();
        A x3 = new C();

        Object x4 = new D();
        Object x5 = new E();

        int a = 10;
        double b = (double) a;

        double n = 10;

        C c = new C();
        A d = (A) c;
    }

}

다형성을 사용하는 이유

1. 이종모음 (<-> 동종모음) 배열 구현 가능
-> 배열로 활용 가능

        Car sonata1 = new Sonata();
        Car sonata2 = new Sonata();
        Sonata sonata3 = new Sonata();


        Car tucson1 = new Tucson();
        Car tucson2 = new Tucson();

        Car mustang1 = new Mustang();
        Car mustang2 = new Mustang();
        Car mustang3 = new Mustang();
        Car mustang4 = new Mustang();

        // 다형성을 통해 이종모음(<->동종모음) 배열을 구현할 수 있음
        Car[] cArr = {sonata1, tucson1, mustang1, mustang2};
        for (Car car : cArr) {
            car.accelerate();
        }

2. 굳이 여러 개의 메서드를 선언할 필요 없이 하나의 메서드 만으로 여러 개의 객체를 받아 처리할 수 있음

package day09.poly.car;

public class Driver {

    // Car타입으로 받으면 다형성에 의해서 Mustang, Sonata, Tucson 모두 올 수 있음
    // 다형성이 안된다면 Car car 자리에 Sonata sonata, Tucson tuscon처럼 일일히 만들어줘야 했을 것이다.
    public void drive(Car car) {

        String carName = "";
        if (car instanceof Sonata) {
            carName = "쏘나타";
        } else if (car instanceof Tucson) {
            carName = "투싼";
        } else if (car instanceof Mustang) {
            carName = "머스탱";
        }
        // car가 Sonata냐? (boolean)
        System.out.println(car instanceof Sonata);
        System.out.println("운전을 시작합니다.");
        car.accelerate();
    }
}

##################################################

package day09.poly.car;

public class CarShop {

    // 돈을 주면 자동차를 출고하는 기능
    // return 타입을 Car로 받게되면 모두 return 가능
    public Car exportCar(int money) {
        if (money == 6000) {
            return new Mustang();
        } else if (money == 4000) {
            return new Tucson();
        } else if ( money == 3000) {
            return new Sonata();
        } else {
            return null;
        }
    }
}

다형성 특징

public class Parent {
	public int n1;

	void method1() {...}
	void method2() {...}
}

public class Child extends Parent {
	public int n2;

	@override
	void method2() {...}
	void method3() {...}
}

//////////////////////////////////////////////////////////////////////

public class Main {
	Parent p = new Child();
	p.n1 = 1;
	//p.n2 = 2; (x)
	
	p.method1();
	p.method2();
	//p.method3(); (x)
}

• 부모 타입 변수에 자식 객체를 생성했을 때 자식 고유의 속성 및 기능을 사용하지 못한다.
  이유는 부모의 정보로는 자식이 어떻게 개념을 확장 했는지에 대한 정보를 얻을 수 없기 때문이다.
  -> 자식의 고유한 속성 및 기능을 사용하기 위해서는 부모 타입의 변수를 자식 타입으로 형변환 해야한다.

Child c = (Child) p;
c.n2 = 2;
c.method3(); //주소값을 자식 타입으로 내리니까 속성 및 기능 사용 가능.

• 형변환 진행 후에는 자식의 속성 및 기능을 사용가능했다.

		// Sonata타입 대신 Car 타입으로 하게되면 Sonata에서 정의하면
        // joinSonataClub 메서드를 못쓰므로 그냥 Sonata 타입으로 사용해서 업케스팅해서 쓰는 것도 가능하다.
        Sonata mySonata = new Sonata();
        mySonata.accelerate();
        mySonata.joinSonataClub();

        Car[] cars = new Car[3];
        cars[0] = mySonata;

• 부모타입 -> 자식타입으로 형변환 하는 것 이외에도 자식 타입을 그대로 유지하여 자식의 속성 및 기능을 사용하고 업케스팅 해서 쓰는 것도 가능하다.