Skip to content

11. 다형성(Polymorphism)

1. 키워드

  • 다형성(Polymorphism)
  • 추상 클래스(Abstract Class)와 추상 메서드(Abstract Method)
  • abstract와 extends
  • 인터페이스(Interface)
  • interface와 implements
  • 내부 클래스(Inner Class)


2. 다형성(Polymorphism)의 개념

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


1) 참조 변수의 다형성

  • 자바에서는 다형성을 위해 부모 클래스 타입의 참조 변수로 자식 클래스 타입의 인스턴스를 참조할 수 있도록 하고 있다.
  • 이때 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버의 개수보다 같거나 적어야 참조할 수 있다.


  • 다음 예제는 참조 변수의 다형성을 보여주는 예제이다.


class Parent { ... }

class Child extends Prent { ... }

...

① Parent pa = new Parent(); // 허용
② Child ch = new Child(); // 허용
③ Parent pc = new Child(); // 허용
④ Child cp = new Parent(); // 오류 발생


  • ①번 라인과 ②번 라인과 같이 특정 타입의 참조 변수로는 당연히 같은 타입의 인스턴스를 참조할 수 있다.
  • 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수와 같기 때문이다.
  • 그리고 ③번 라인과 같이 부모 클래스 타입의 참조 변수로도 자식 클래스 타입의 인스턴스를 참조할 수 있다.
  • 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수보다 적기 때문이다. (Parent ≤ Child)
  • 하지만 ④번 라인과 같이 자식 클래스 타입의 참조 변수로는 부모 클래스 타입의 인스턴스를 참조할 수 없다.
  • 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수보다 많기 때문이다. (Child ≥ Parent)


Note

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


2) 참조 변수의 타입 변환

  • 자바에서는 참조 변수도 다음과 같은 조건에 따라 타입 변환을 할 수 있다.


1] 서로 상속 관계에 있는 클래스 사이에만 타입 변환을 할 수 있다.

2] 자식 클래스 타입에서 부모 클래스 타입으로의 타입 변환은 생략할 수 있다.

3] 하지만 부모 클래스 타입에서 자식 클래스 타입으로의 타입 변환은 반드시 명시해야 한다.


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


(변환할타입의클래스이름) 변환할참조변수


  • 다음 예제는 참조 변수의 타입 변환을 보여주는 예제이다.


class Parent { ... }

class Child extends Prent { ... }

class Brother extends Parent { ... }

...

Parent pa01 = null;
Child ch = new Child();
Parent pa02 = new Parent();
Brother br = null;

pa01 = ch; // pa01 = (Parent) ch;와 같으며, 타입 변환을 생략할 수 있음
br = (Brother) pa02; // 타입 변환을 생략할 수 없음
br = (Brother) ch; // 직접적인 상속 관계가 아니므로, 오류 발생


3) instanceof 연산자

  • 이러한 다형성으로 인해 런타임에 참조 변수가 실제로 참조하고 있는 인스턴스의 타입을 확인할 필요성이 생긴다.
  • 자바에서는 instanceof 연산자를 제공하여, 참조 변수가 참조하고 있는 인스턴스의 실제 타입을 확인할 수 있도록 해준다.


  • 자바에서 instanceof 연산자는 다음과 같이 사용한다.


참조변수 instanceof 클래스이름


  • 왼쪽에 전달된 참조 변수가 실제로 참조하고 있는 인스턴스의 타입이 오른쪽에 전달된 클래스 타입이면 true를 반환하고, 아니면 false를 반환한다.
  • 만약 참조 변수가 null을 가리키고 있으면 false를 반환한다.


  • 다음 예제는 참조 변수가 실제로 가리키고 있는 인스턴스의 타입을 instanceof 연산자로 확인하는 예제이다.


class Parent {}

class Child extends Parent {}

class Brother extends Parent {}

class Test {

  public static void main(String[] args) {
    Parent p = new Parent();

    System.out.println(p instanceof Object); // true
    System.out.println(p instanceof Parent); // true
    System.out.println(p instanceof Child); // false
    System.out.println();

    Parent c = new Child();

    System.out.println(c instanceof Object); // true
    System.out.println(c instanceof Parent); // true
    System.out.println(c instanceof Child); // true
  }
}


3. 추상 클래스(Abstract Class)

1) 추상 메서드(Abstract Method)

  • 추상 메서드란 자식 클래스에서 반드시 오버라이딩해야만 사용할 수 있는 메서드를 의미한다.
  • 자바에서 추상 메서드를 선언하여 사용하는 목적은 추상 메서드가 포함된 클래스를 상속받는 자식 클래스가 반드시 추상 메서드를 구현하도록 하기 위함이다.
  • 예를 들면 모듈처럼 중복되는 부분이나 공통적인 부분은 미리 다 만들어진 것을 사용하고, 이를 받아 사용하는 쪽에서는 자신에게 필요한 부분만을 재정의하여 사용함으로써 생산성이 향상되고 배포 등이 쉬워지기 때문이다.
  • 이러한 추상 메서드는 선언부만이 존재하며, 구현부는 작성되어 있지 않다.
  • 바로 이 작성되어 있지 않은 구현부를 자식 클래스에서 오버라이딩하여 사용하는 것이다.


  • 자바에서 추상 메서드는 다음과 같은 문법으로 선언한다.


abstract 반환타입 메서드이름();


  • 위와 같이 선언부만 있고 구현부가 없다는 의미로 선언부 끝에 바로 ;(세미콜론)을 추가한다.


2) 추상 클래스

  • 자바에서는 하나 이상의 추상 메서드를 포함하는 클래스를 가리켜 추상 클래스라고 한다.
  • 이러한 추상 클래스는 OOP에서 중요한 특징인 다형성을 가지는 메서드의 집합을 정의할 수 있도록 해준다.
  • 즉, 반드시 사용되어야 하는 메서드를 추상 클래스에서 추상 메서드로 선언해 놓으면, 이 클래스를 상속받는 모든 클래스에서는 이 추상 메서드를 반드시 재정의해야 한다.


  • 자바에서 추상 클래스는 다음과 같은 문법으로 선언한다.


abstract class 클래스이름 {

 ...

 abstract 반환타입 메서드이름();

 ...

}


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


Note

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


abstract class Animal {

  abstract void cry();
}

class Cat extends Animal {

 @Override
  void cry() {
    System.out.println("냐옹냐옹!");
  }
}

class Dog extends Animal {

 @Override
  void cry() {
    System.out.println("멍멍!");
  }
}

class Test {

  public static void main(String[] args) {
    Animal a = new Animal(); // 추상 클래스는 인스턴스를 생성할 수 없음 -> 컴파일 오류 발생
    Cat c = new Cat();
    Dog d = new Dog();

    c.cry(); // 냐옹냐옹!
    d.cry(); // 멍멍!
  }
}


3) 추상 메서드의 사용 목적

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


4. 인터페이스(Interface)

  • 자식 클래스가 여러 부모 클래스를 상속받을 수 있다면, 다양한 동작을 수행할 수 있다는 장점을 가지게 될 것이다.
  • 하지만 클래스를 이용하여 다중 상속을 할 경우 메서드 출처의 모호성 등 여러 가지 문제가 발생할 수 있어 자바에서는 클래스를 통한 다중 상속은 지원하지 않는다.
  • 하지만 다중 상속의 이점을 버릴 수는 없기에 자바에서는 인터페이스라는 것을 통해 다중 상속을 지원하고 있다.
  • 인터페이스란 다른 클래스를 작성할 때 기본이 되는 틀을 제공하면서, 다른 클래스 사이의 중간 매개 역할까지 담당하는 일종의 추상 클래스를 의미한다.
  • 자바에서는 추상 클래스는 추상 메서드뿐만 아니라 생성자, 필드, 일반 메서드도 포함할 수 있다.
  • 하지만 인터페이스는 오로지 추상 메서드와 상수만을 포함할 수 있다.


1) 인터페이스의 선언

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


  • 자바에서 인터페이스는 다음과 같이 선언한다.


접근제어자 interface 인터페이스이름 {
 // 무조건 public static final이어야 함
 // public static final 생략 시 자동 추가
 public static final 타입 상수이름 = 값;

 ...

 // 무조건 public abstract이어야 함
 // public abstract 생략 시 자동 추가
 public abstract 메서드이름(매개변수목록);

 ... // 내부에서는 절대로 구현 메서드를 가질 수 없음

}


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


2) 인터페이스의 구현

  • 인터페이스는 추상 클래스와 마찬가지로 자신이 직접 인스턴스를 생성할 수는 없다.
  • 따라서 인터페이스가 포함하고 있는 추상 메서드를 구현해 줄 클래스를 작성해야만 한다.


  • 자바에서 인터페이스는 다음과 같은 문법을 통해 구현한다.


class 클래스이름 implements 인터페이스이름 { ... }


  • 만약 모든 추상 메서드를 구현하지 않는다면, abstract 키워드를 사용하여 추상 클래스로 선언해야 한다.


  • 다음 예제는 인터페이스를 구현하는 예제이다.


interface Animal {
  public abstract void cry();
}

class Cat implements Animal {

 @Override
  public void cry() {
    System.out.println("냐옹냐옹!");
  }
}

class Dog implements Animal {

 @Override
  public void cry() {
    System.out.println("멍멍!");
  }
}

class Test {

  public static void main(String[] args) {
    Cat c = new Cat();
    Dog d = new Dog();

    c.cry(); // 냐옹냐옹!
    d.cry(); // 멍멍!
  }
}


  • 자바에서는 다음과 같이 상속과 구현을 동시에 할 수 있다.


class 클래스이름 extends 상위클래스이름 implements 인터페이스이름 { ... }


Note

  • 인터페이스는 인터페이스로부터만 상속을 받을 수 있으며, 여러 인터페이스를 상속받을 수 있다.


  • 다음 예제는 인터페이스를 사용한 다중 상속의 예제이다.


interface Animal {
  public abstract void cry();
}

interface Pet {
  public abstract void play();
}

class Cat implements Animal, Pet {

 @Override
  public void cry() {
    System.out.println("냐옹냐옹!");
  }

 @Override
  public void play() {
    System.out.println("쥐 잡기 놀이하기");
  }
}

class Dog implements Animal, Pet {

 @Override
  public void cry() {
    System.out.println("멍멍!");
  }

 @Override
  public void play() {
    System.out.println("산책가기");
  }
}

class Test {

  public static void main(String[] args) {
    Cat c = new Cat();
    Dog d = new Dog();

    c.cry(); // 냐옹냐옹!
    c.play(); // 쥐 잡기 놀이하기

    d.cry(); // 멍멍!
    d.play(); // 산책가기
  }
}


  • 위의 예제에서 Cat 클래스와 Dog 클래스는 각각 Animal과 Pet이라는 두 개의 인터페이스를 동시에 구현하고 있다.


3) 클래스를 이용한 다중 상속의 문제점

  • 클래스를 이용하여 다중 상속을 하면 다음 예제와 같은 메서드 출처의 모호성 등의 문제가 발생할 수 있다.


class Animal {

  public void cry() {
    System.out.println("짖기!");
  }
}

class Cat extends Animal {

  @Override
  public void cry() {
    System.out.println("냐옹냐옹!");
  }
}

class Dog extends Animal {

  @Override
  public void cry() {
    System.out.println("멍멍!");
  }
}

① class MyPet extends Cat, Dog {}; // 오류 발생

class Test {

  public static void main(String[] args) {
    MyPet p = new MyPet();
②    p.cry();
  }
}


  • 위의 예제에서 Cat 클래스와 Dog 클래스는 각각 Animal 클래스를 상속받아 cry() 메서드를 오버라이딩하고 있다.
  • 여기까지는 문제가 없지만, ①번 라인에서 MyPet 클래스가 Cat 클래스와 Dog 클래스를 동시에 상속받게 되면 문제가 발생한다.
  • ②번 라인에서 MyPet 인스턴스인 p가 cry() 메서드를 호출하면, 이 메서드가 Cat 클래스에서 상속받은 cry() 메서드인지 Dog 클래스에서 상속받은 cry() 메서드인지 구분할 수 없는 모호성을 지니게 된다.
  • 이와 같은 이유로 자바에서는 클래스를 이용한 다중 상속을 지원하지 않는 것이다.


  • 하지만 다음 예제처럼 인터페이스를 이용하여 다중 상속을 하게 되면, 위와 같은 메서드 호출의 모호성을 방지할 수 있다.


interface Animal { // 상위 인터페이스 생성
  public abstract void cry();
}

interface Cat extends Animal { // 인터페이스끼리는 extends 키워드를 사용하여 상속
 @Override
  public abstract void cry();
}

interface Dog extends Animal { // 인터페이스끼리는 extends 키워드를 사용하여 상속
 @Override
  public abstract void cry();
}

class MyPet implements Cat, Dog { // 일반 클래스에서는 implements 키워드를 사용하여 상속

 @Override
  public void cry() {
    System.out.println("멍멍! 냐옹냐옹!");
  }
}

class Test {

  public static void main(String[] args) {
    MyPet p = new MyPet();

    p.cry(); // 멍멍! 냐옹냐옹!
  }
}


  • 위의 예제에서는 Cat 인터페이스와 Dog 인터페이스를 동시에 구현한 MyPet 클래스에서만 cry() 메서드를 정의하므로, 앞선 예제에서 발생한 메서드 호출의 모호성이 없다.


4) 인터페이스의 장점

  • 인터페이스를 사용하면 다중 상속이 가능할 뿐만 아니라 다음과 같은 장점을 가질 수 있다.


1] 대규모 프로젝트 개발 시 일관되고 정형화된 개발을 위한 표준화가 가능하다.

2] 클래스의 작성과 인터페이스의 구현을 동시에 진행할 수 있으므로, 개발 시간을 단축할 수 있다.

3] 클래스와 클래스 간의 관계를 인터페이스로 연결하면, 클래스마다 독립적인 프로그래밍이 가능하다.


5. 내부 클래스(Inner Class)

  • 내부 클래스란 하나의 클래스 내부에 선언된 또 다른 클래스를 의미한다.
  • 이러한 내부 클래스는 외부 클래스(Outer Class)에 대해 두 개의 클래스가 서로 긴밀한 관계를 맺고 있을 때 선언할 수 있다.


class Outer { // 외부 클래스

 ...

 class Inner { // 내부 클래스

  ...

 }

 ...

}


1) 내부 클래스의 장점

  • 내부 클래스를 사용하면 다음과 같은 장점을 가질 수 있다.


1] 내부 클래스에서 외부 클래스의 멤버에 손쉽게 접근할 수 있게 된다.

2] 서로 관련있는 클래스를 논리적으로 묶어서 표현함으로써, 코드의 캡슐화를 증가시킨다.

3] 외부에서는 내부 클래스에 접근할 수 없으므로, 코드의 복잡성을 줄일 수 있다.


2) 내부 클래스의 종류

  • 내부 클래스는 필드와 마찬가지로 선언된 위치에 따라 다음과 같이 구분된다.


1] 정적 클래스(Static Class)

2] 인스턴스 클래스(Instance Class)

3] 지역 클래스(Local Class)

4] 익명 클래스(Anonymous Class)


  • 외부 클래스 영역에 선언된 클래스 중에서 static 키워드를 가지는 클래스를 정적 클래스라고 한다.
  • 이러한 정적 클래스는 주로 외부 클래스의 클래스 메서드에 사용될 목적으로 선언된다.
  • 외부 클래스 영역에 클래스 중에서 static 키워드를 가지지 않는 클래스를 인스턴스 클래스라고 한다.
  • 이러한 인스턴스 클래스는 주로 외부 클래스의 인스턴스 변수나 인스턴스 메서드에 사용될 목적으로 선언된다.
  • 지역 클래스란 외부 클래스의 메서드나 초기화 블록에 선언된 클래스를 의미한다.
  • 이러한 지역 클래스는 선언된 블록 내에서만 사용할 수 있다.


(1) 익명 클래스(Anonymous Class)

  • 익명 클래스란 다른 내부 클래스와는 달리 이름을 가지지 않는 클래스를 의미한다.
  • 익명 클래스는 클래스의 선언과 동시에 객체를 생성하므로, 단 하나의 객체만을 생성하는 일회용 클래스이다.
  • 따라서 생성자를 선언할 수도 없으며, 오로지 단 하나의 클래스나 단 하나의 인터페이스를 상속받거나 구현할 수 있을 뿐이다.
  • 이러하나 익명 클래스는 매우 제한적인 용도에 사용되면, 구현해야 하는 메서드가 매우 적은 클래스를 구현할 때 사용된다.


  • 자바에서 익명 클래스는 다음과 같이 선언할 수 있다.


// 익명 클래스는 선언과 동시에 생성하여 참조변수에 대입함
클래스이름 참조변수이름 = new 클래스이름() {

 // 메서드의 선언

}

References