포스트

다형성

게시
By tonyleekorea 30 분읽는 시간

다형성의 개념

다형성(polymorphism)이란?

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

참조 변수의 다형성

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

// 참조 변수의 다형성을 보여주는 예제
class Parent { ... }
class Child extends Parent { ... }
...
Parent pa = new Parent(); // 허용
Child ch = new Child();   // 허용
Parent pc = new Child();  // 허용
Child cp = new Parent();  // 오류 발생
  • 특정 타입의 참조 변수로는 당연히 같은 타입의 인스턴스를 참조할 수 있다. 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수와 같기 때문이다.
  • 그리고 부모 클래스 타입의 참조 변수로도 자식 클래스 타입의 인스턴스를 참조할 수 있다. 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수보다 적기 때문이다.
  • 하지만 반대의 경우인 자식 클래스 타입의 참조 변수로는 부모 클래스 타입의 인스턴스를 참조할 수 없다. 참조 변수가 사용할 수 있는 멤버의 개수가 실제 인스턴스의 멤버 개수보다 많기 때문이다.
  • 클래스는 상속을 통해 확장될 수는 있어도 축소될 수는 없으므로, 자식 클래스에서 사용할 수 있는 멤버의 개수가 언제나 부모 클래스와 같거나 많게 된다.

참조 변수의 타입 변환

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

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

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

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

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

1
2

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 참조 변수의 타입 변환을 보여주는 예제
class Parent { ... }
class Child extends Parent { ... }
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;   // 직접적인 상속 관계가 아니므로, 오류 발생

instanceof 연산자

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

// 문법
참조변수 instanceof 클래스이름
  • 왼쪽에 전달된 참조 변수가 실제로 참조하고 있는 인스턴스의 타입이 오른쪽에 전달된 클래스 타입이면 true를 반환하고, 아니면 false를 반환한다. 만약에 참조 변수가 null을 가리키고 있으면 false를 반환한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 참조 변수가 실제로 가리키고 있는 인스턴스의 타입을 instanceof 연산자로 확인하는 예제
class Parent { }
class Child extends Parent { }
class Brother extends Parent { }

public class prog {
	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
	}
}

이미지

추상 클래스

추상 메소드(abstract method)

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

// 문법
abstract 반환타입 메소드이름();
  • 위와 같이 선언부만 있고 구현부가 없다는 의미로 선언부 끝에 바로 세미콜론(;)을 추가한다.

추상 클래스(abstract class)

  • 자바에서는 하나 이상의 추상 메소드를 포함하는 클래스를 가리켜 추상 클래스(abstract class)라고 한다.
  • 이러한 추상 클래스는 객체 지향 프로그래밍에서 중요한 특징인 다형성을 가지는 메소드의 집합을 정의할 수 있도록 해준다.
  • 즉, 반드시 사용되어야 하는 메소드를 추상 클래스에 추상 메소드로 선언해 놓으면, 이 클래스를 상속받는 모든 클래스에서는 이 추상 메소드를 반드시 재정의해야 한다.
  • 자바에서 추상 클래스는 다음과 같은 문법으로 선언한다.
1
2
3
4
5

abstract class 클래스이름 {
    ...
    abstract 반환타입 메소드이름();
    ...
}
  • 이러한 추상 클래스는 동작이 정의되어 있지 않은 추상 메소드를 포함하고 있으므로, 인스턴스를 생성할 수 없다.
  • 추상 클래스는 먼저 상속을 통해 자식 클래스를 만들고, 만든 자식 클래스에서 추상 클래스의 모든 추상 메소드를 오버라이딩하고 나서야 비로소 자식 클래스의 인스턴스를 생성할 수 있게 된다.
  • 추상 클래스는 추상 메소드를 포함하고 있다는 점을 제외하면, 일반 클래스와 모든 점이 같다. 즉, 생성자와 필드, 일반 메소드도 포함할 수 있다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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 prog {
	public static void main(String[] args) {
		// Animal a = new Animal(); // 추상 클래스는 인스턴스를 생성할 수 없다.
		Cat c = new Cat();
		Dog d = new Dog();
		
		c.cry();
		d.cry();
	}
}

이미지

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

추상 메소드의 사용 목적

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


인터페이스

인터페이스(interface)란?

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

인터페이스의 선언

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

// 문법
접근제어자 interface 인터페이스이름 {
    public static final 타입 상수이름 = 값;
    ...
    public abstract 메소드이름(매개변수목록);
    ...
}
  • 단, 클래스와는 달리 인터페이스의 모든 필드는 public static final이어야 하며, 모든 메소드는 public abstract이어야 한다.
  • 이 부분은 모든 인터페이스에 공통으로 적용되는 부분이므로 이 제어자는 생략할 수 있다. 이렇게 생략된 제어자는 컴파일 시 자바 컴파일러가 자동으로 추가해 준다.

인터페이스의 구현

  • 인터페이스는 추상 클래스와 마찬가지로 자신이 직접 인스턴스를 생성할 수는 없다. 따라서 인터페이스가 포함하고 있는 추상 메소드를 구현해 줄 클래스를 작성해야만 한다.
  • 자바에서 인터페이스는 다음과 같은 문법을 통해 구현한다.
1
2

// 문법
class 클래스이름 implements 인터페이스이름 { ... }
  • 만약 모든 추상 메소드를 구현하지 않는다면, abstract 키워드를 사용하여 추상 클래스로 선언해야 한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 인터페이스를 구현하는 예제
interface Animal { public abstract void cry(); }

class Cat implements Animal {
	public void cry() {
		System.out.println("냐옹냐옹!");
	}
}

class Dog implements Animal {
	public void cry() {
		System.out.println("멍멍!");
	}
}

public class prog {
	public static void main(String[] args) {
		Cat c = new Cat();
		Dog d = new Dog();
		
		c.cry();
		d.cry();
	}
}

이미지


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

// 문법
class 클래스이름 extend 상위클래스이름 implements 인터페이스이름 { ... }
  • 인터페이스는 인터페이스로부터만 상속을 받을 수 있으며, 여러 인터페이스를 상속받을 수 있다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// 인터페이스를 사용한 다중 상속의 예제
interface Animal { public abstract void cry(); }
interface Pet { public abstract void play(); }

class Cat implements Animal, Pet {
	public void cry() {
		System.out.println("냐옹냐옹!");
	}
	public void play() {
		System.out.println("나비야~ 쥐 잡기 놀이하자~!");
	}
}

class Dog implements Animal, Pet {
	public void cry() {
		System.out.println("멍멍!");
	}
	public void play() {
		System.out.println("바둑아~ 산책가자~!");
	}
}

public class prog {
	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이라는 두 개의 인터페이스를 동시에 구현하고 있다.

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

  • 클래스를 이용하여 다중 상속을 하면 다음 예제와 같은 메소드 출처의 모호성 등의 문제가 발생할 수 있다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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

 

class Cat extends Animal {
    public void cry() {
        System.out.println("냐옹냐옹!");
    }
}

 

class Dog extends Animal {
    public void cry() {
        System.out.println("멍멍!");
    }
}

 
class MyPet extends Cat, Dog {} // ①

 
public class Polymorphism {
    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() 메소드인지를 구분할 수 없는 모호성을 지니게 된다. 이와 같은 이유로 자바에서는 클래스를 이용한 다중 상속을 지원하지 않는 것이다.
  • 하지만 다음 예제처럼 인터페이스를 이용하여 다중 상속을 하게되면, 위와 같은 메소드 호출의 모호성을 방지할 수 있다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

interface Animal { public abstract void cry(); }

interface Cat extends Animal {
	public abstract void cry();
}

interface Dog extends Animal {
	public abstract void cry();
}

class MyPet implements Cat, Dog {
	public void cry() {
		System.out.println("멍멍! 냐옹냐옹!");
	}
}

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

이미지

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

인터페이스의 장점

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

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

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

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


내부 클래스

내부 클래스(inner class)

  • 내부 클래스(inner class)란 하나의 클래스 내부에 선언된 또 다른 클래스를 의미한다.
  • 이러한 내부 클래스는 외부 클래스(outer class)에 대해 두 개의 클래스가 서로 긴밀한 관계를 맺고 있을 때 선언할 수 있다.
1
2
3
4
5
6
7
8

// 문법
class Outer {     // 외부 클래스
    ...
    class Inner { // 내부 클래스
        ...
    }
    ...
}

내부 클래스의 장점

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

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

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

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

내부 클래스의 종류

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

    1. 정적 클래스(static class)

    2. 인스턴스 클래스(instance class)

    3. 지역 클래스(local class)

    4. 익명 클래스(anonymous class)

  • 정적 클래스(static class): 주로 외부 클래스(outer class)의 클래스 메소드에 사용될 목적으로 선언된다. 정적 클래스는 static 키워드를 가지며, 정적 멤버만을 포함할 수 있다. 외부 클래스의 인스턴스에 속하지 않으므로 정적 클래스의 인스턴스를 생성할 때는 외부 클래스의 인스턴스 생성과는 관련이 없다.

  • 인스턴스 클래스(instance class): 주로 외부 클래스(outer class)의 인스턴스 변수나 인스턴스 메소드에 사용될 목적으로 선언된다. 인스턴스 클래스는 static 키워드를 가지지 않는다. 인스턴스 클래스는 외부 클래스의 인스턴스에 속하며, 따라서 인스턴스를 생성하기 위해서는 먼저 외부 클래스의 인스턴스를 생성해야 한다.

    따라서 정적 클래스와 인스턴스 클래스는 각각 다른 목적과 특성을 가지고 있다. 정적 클래스는 외부 클래스의 인스턴스와 무관하며 정적 멤버를 가질 수 있다. 반면에 인스턴스 클래스는 외부 클래스의 인스턴스에 종속되며, 주로 해당 인스턴스의 상태나 동작을 보조하는 역할을 한다.

  • 지역 클래스(local class): 외부 클래스의 메소드나 초기화 블록 안에서 선언되는 클래스를 의미한다. 이러한 지역 클래스는 선언된 블록 내에서만 유효하며, 해당 블록 외부에서는 접근할 수 없다.

    일반적으로 지역 클래스는 특정 메소드에서만 필요한 클래스를 정의할 때 사용된다. 이러한 클래스는 해당 메소드 내부에서만 사용되며, 메소드가 실행되면 메모리에 할당되고, 메소드의 실행이 끝나면 소멸된다. 이는 지역 변수와 유사한 동작 방식을 가지고 있다.

    따라서 지역 클래스는 외부 클래스의 특정 메소드나 초기화 블록 내에서 캡슐화되어 사용되는 경우에 유용하게 활용된다.

익명 클래스(anonymous class)

  • 익명 클래스(anonymous class)란 다른 내부 클래스와는 달리 이름을 가지지 않는 클래스를 의미한다. 익명 클래스는 클래스의 선언과 동시에 객체를 생성하므로, 단 하나의 객체만을 생성하는 일회용 클래스이다.
  • 따라서 생성자를 선언할 수도 없으며, 오로지 단 하나의 클래스나 단 하나의 인터페이스를 상속받거나 구현할 수 있을 뿐이다.
  • 익명 클래스는 주로 구현해야 할 메소드가 매우 적은 인터페이스나 추상 클래스의 구현체를 생성할 때 사용된다. 또한, 익명 클래스는 일회성으로 사용되므로 코드를 간결하게 만들어주고, 익명 클래스가 선언된 지점에서만 유효하도록 스코프를 제한하는 데에도 도움이 된다.
  • 자바에서 익명 클래스는 다음과 같이 선언할 수 있다.
1
2
3
4

// 익명 클래스는 선언과 동시에 생성하여 참조변수에 대입한다.
클래스이름 참조변수이름 = new 클래스이름(){
    // 메소드의 선언
};
Study, JavaBasic
이 기사는 저작권자의 CC BY 4.0 라이센스를 따릅니다.