Java - 다형성(Polymorphism)

다형성은 하나의 객체가 여러가지 타입을 가질 수 있는 것을 의미한다. Java에서 이러한 다형성을 부모 클래스 타입의 참조 변수로 자식 클래스 타입의 인스턴스를 참조할 수 있도록 구현하고 있다. 다형성은 상속, 추상화와 더불어 객체 지향 프로그래밍을 구성하는 중요한 특징중 하나다.

class Parent { ... }
class Child extends Parent { ... }
...
Parent parent = new Parent();    // 허용
Child child = new Child();        // 허용
Parent parent = new Child();    // 허용
Child child = new Parent();        // 오류 발

특정 타입의 참조 변수로는 당연히 같은 타입의 인스턴스를 참조할 수있다. 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수와 같기 때문이다. 그리고 부모 클래스 타입의 참조 변수로도 자식 클래스 타입의 인스턴스를 참조할 수 있다. 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수보다 적기 때문이다.

하지만 반대의 경우인 자식 클래스 타입의 참조 변수로는 부모 클래스 타입의 인스턴스를 참조할 수 없다. 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수보다 많기 때문이다.

클래스는 상속을 통해 확장될 수는 있어도 축소될 수는 없으므로, 자식 클래스에서 사용할 수 있는 멤버의 개수가 언제나 부모 클래스와 같거나 많게 된다.

Java에서는 참조 변수도 아래와 같은 조건으로 타입 변환을 할 수있다.
1. 서로 상속 관계에 있는 클래스 사이에서만 타입 변환을 할 수 있다.
2. 자식 클래스 타입에서 부모 클래스 타입으로의 타입 변환은 생략할 수 있다.
3. 하지만 부모 클래스 타입에서 자식 클래스 타입으로의 타입 변환은 반드시 명시해야 한다.

참조 변수의 타입 변환도 기본 타입의 타입 변환과 마찬가지로 타입 캐스트 연산자(())를 사용한다.

// 참조 변수의 타입 변환
(변환할타입의클래스명) 
 
class Parent { ... }
class Child extends Parent { ... }
class Brother extends Parent { ... }
...
Parent parent01 = null;
Child child = new Child();
Parent parent02 = new Parent();
Brother brother = null;
 
parent02 = child;                // parent01 = (Parent)child;와 같고, 타입 변환을 생략할 수 있다.
brother = (Brother)parent02;    // 타입 변환을 생략할 수 없다.
brother = (Brother)child;        // 직접적인 상속 관계가 아니므로 오류가 발생한다.

이런 Java의 다형성으로 인해 런타임에 참조 변수가 실제로 참조하고 있는 인스턴스의 타입을 확인할 필요성이 생기는데, Java에서는 instanceof 연산자를 제공한다. 이것은 참조 변수가 참조하고 있는 인스턴스의 실제 타입을 확인하게 해준다.

// instanceof 연산자
참조변수 instanceof 클래스명
 
class Parent { ... }
class Child extends Parent { ... }
class Brother extends Parent { ... }
 
public class Polymorphism {
    public static void main(String[] args){
        Parent parent = new Parent();
        System.out.println(parent instanceof Object);    // true
        System.out.println(parent instanceof Parent);    // true
        System.out.println(parent instanceof Child);    // false
        System.out.println();
 
        Parent child = new Child();
        System.out.println(child instanceof Object);    // true
        System.out.println(child instanceof Parent);    // true
        System.out.println(child instanceof Child);        // true
    }    
}

추상 메서드(Abstract method)는 자식 클래스에서 반드시 오버라이딩해야만 사용할 수 있는 메서드를 의미한다. Java에서 추상 메서드를 선언해 사용하는 목적은 추상 메서드가 포함된 클래스를 상속받는 자식 클래스가 반드시 추상 메서드를 구현하도록 하기 위함이다.

예로 모듈처럼 중복되는 부분이나 공통적인 부분은 미리 다 만들어진 것을 사용하고, 이를 받아 사용하는 쪽에서는 자신에게 필요한 부분만을 재정의하여 사용함으로써 생산성이 향상되고 배포등이 쉬워지기 때문이다.

이런 추상 메서드는 선언부만이 존재한다. 구현부는 작성하지 않는다. 바로 이 작성되어 있지 않은 구현부를 자식 클래스에서 오버라이딩하여 사용하는 것이다.

추상 클래스(Abstract class)는 하나 이상의 추상 메서드를 포함하는 클래스를 의미한다. 이러한 추상 클래스는 객체 지향 프로그래밍에서 중요한 특징인 다형성을 가지는 메서드의 집합을 정의할 수 있게 한다. 즉 반드시 사용되어야 하는 메서드를 추상 클래스에 추상 메서드로 선언하면 이 클래스를 상속받는 모든 클래스에서는 이 추상 메서드를 반드시 재정의해야 한다.

// 추상(Abstract)
 
// 추상 메서드
abstract 반환타입 메서드명();
 
// 추상 클래스
abstract class 클래스명 {
    ...
    abstract 반환타입 메서드명();
    ...
}

이런 추상 클래스는 동작이 정의되어 있지 않은 추상 메서드를 포함하고 있기 때문에 인스턴스를 생성할 수 없다. 추상 클래스는 먼저 상속을 통해 자식 클래스를 만들고, 만든 자식 클래스에서 추상 클래스의 모든 추상 메서드를 오버라이딩하고 나서야 비로소 자식 클래스의 인스턴스를 생성할 수 있게 된다.

추상 클래스는 추상 메서드를 포함하고 있다는 점을 제외하면, 일반 클래스와 모든 면에서 같다. 즉 생성자와 필드, 일반 메서드도 포함될 수 있다.

abstract class Animal { abstract void cry(); }
class Cat extends Animal { void cry() { System.out.println("야옹 야옹!"); } }
class Dog extends Animal { void cry() { System.out.println("멍 멍!"); } }
 
public class Polymorphism {
    public static void main(String[] args){
        // Animal animal = new Animal(); // 추상 클래스는 인스턴스를 생성할 수 없다.
        Cat cat = new Cat();
        Dog dog = new Dog();
 
        cat.cry();
        dog.cry();
    }
}

위의 코드에서 추상 클래스인 Animal 클래스는 추상 메서드인 cry() 메서드를 가지고 있다. Animal 클래스를 상속받는 자식 클래스인 Dog 클래스와 Cat 클래스는 cry() 메서드를 오버라이딩해야만 비로소 인스턴스를 생성할 수 있다.

추상 메서드의 사용목적

Java에서 추상 메서드를 선언하여 사용하는 목적은 추상 메서드가 포함된 클래스를 상속받는 자식 클래스가 반드시 추상 메서드를 구현하도록 하기 위함이다. 만약 일반 메서드로 구현하면 사용자에 따라 해당 메서드를 구현할 수도 있고, 안 할 수도 있다. 하지만 추상 메서드가 포함된 추상 클래스를 상속받은 모든 자식 클래스는 추상 메서드를 구현해야만 인스턴스를 생성할 수 있게 되므로 반드시 구현하게 된다.