[JAVA]다형성

1. 다형성 시작

- 다형성을 이해하기 위해서는 다형적 참조, 메서드 오버라이딩 두 개의 이론을 알아야 한다.

1) 다형적 참조

public Class Parent {

	public String value = "parent";

	public void parentMethod(){
    	System.out.println("Parent.parentMethod");
	}
}

public class Child extends Parent {

	public String value = "child";

	public void childMethod() {
    	System.out.println("Child.childMethod");
	}
}

//다형적 참조 : 부모는 자식을 품을 수 있다.
public class PolyMain {
	public static void main(String[] args) {

        //부모 변수가 자식 인스턴스 참조(다형적 참조)
        System.out.println("Parent -> Child");
        Parent parent = new Child();
        parent.parentMethod(); //Parent.parentMethod
        
        //자식은 부모를 담을 수 없다(Child child = new Parent(); 안됨)
	}
}

- 부모 타입은 자식 타입을 담을 수 있다.

- Parent parent는 부모 타입이다. new Child를 통해 생성된 결과는 Child 타입이다. 즉 자식 타입까지 참조할 수 있다. 손자가 있다면 그 하위 타입도 참조할 수 있다.

 

* 다형적 참조의 한계

- 위 처럼 Parent parent = new Child() 상황에서 childMethod()를 찾으면 Parent 클래스부터 시작해서 기능을 찾을텐데, 상속 관계는 부모 방향으로 올라갈 순 있지만, 자식 관계로 내려갈 순 없으므로 컴파일 오류가 발생한다.

- 캐스팅을 통해 이를 해결할 수 있다.

2. 다형성과 캐스팅

public class CastingMain {
	public static void main(String[] args){
    
    	//부모 변수가 자식 인스턴스 참조(다형적 참조)
        Parent parent = new Child();
        
        //자식의 기능은 호출 불가
        //parent.childMethod();
        
        //다운캐스팅(부모 타입 -> 자식 타입)
        Child child = (Child) parent; //다운캐스팅을 통해 부모타입을 자식 타입으로 변환 후 대입 시도
        child.childMethod();
	}
}

1) 캐스팅의 종류

* 일시적 다운 캐스팅

public class CastingMain {
	publuc static void main(String[] agrs) {
    
    	Parent parent = new Child();
    	//일시적 다운 캐스팅 - 해당 메서드를 호출하는 순간만 다운캐스팅
    	(Child)parent).childMethod(); //다운캐스팅을 통해 부모타입을 자식 타입으로 변환 후 기능 호출
    }
}

- 위 코드는 Parent 타입을 임시로 Child로 변경한다. 이후 메서드를 호출할 때 Child 타입에서 찾아 실행한다.

- 해당 참조값을 꺼내고 꺼낸 참조값이 Child타입이 되는 것이다. 따라서 parent 타입은 Parent로 유지된다.

 

* 업케스팅

public class CastingMain{
	public static void(String[] args){
    	
        Child child = new Child();
        Parent parent1 = (Parent) child; //업캐스팅은 생략 가능, 생략 권장
        Parent parent2 = child; // 생략 ver
        
        parent1.parentMethod();//Parent.parentMethod
	}
}

- Child 타입을 Parent 타입에 대입하는 경우 사용된다. 

- 부모 타입으로 변환하는 경우에는 (타입)을 생략할 수 있다.

 

* 사용할 수 없는 타입으로 다운캐스팅할 경우 ClassCastException이라는 예외를 발생시키므로, 다운캐스팅은 조심해서 사용해야 한다.

 

3. instanceof

- 변수가 참조하는 인스턴스의 타입을 확인하고 싶을 때 사용된다.

public class CastingMain{
	
    private static void call(Parent parent) {
    	if (parent instanceof Child) {
        	System.out.println("Child 인스턴스 맞음");
            Child child = (Child) parent;
            child.childMethod();
		}
	}
}

- 위 매서드는 매개변수로 넘어온 parent가 참조하는 타입에 따라서 다른 명령을 수행함.

- 다운캐스팅을 수행하기 전에는 위처럼 instanceof를 사용해 원하는 타입으로 변경 가능한지 확인한 다음 수행하는 것이 안전함.

4. 다형성과 메서드 오버라이딩

public class OverrideingMain {
	public static void main(String[] args) {
    	
        Parent parent = new Child();
		System.out.println("value = " + parent.value); //value = parent
        //메서드 오버라이딩
        parent.methid(); //Child.method
	}
}

- parent 변수는 Parent 타입. 따라서 parent.value / parent.method를 호출하면 Parent에서 찾아서 실행함

- 오버라이딩 된 메서드는 항상 우선권을 가진다. 때문에 Parent.method가 아닌, Child.method()가 실행된다.

 

5. 다형성 활용

1) 다형성의 장점

예) 각자 다른 동물 소리를 테스트 하는 프로그램을 만들기

 

- 다형성을 사용하지 않는 경우

public class Dog {
	public void sound(){
    	System.out.println("멍멍")
	}
}

public class Cat {
	public void sound(){
    	System.out.println("멍멍")
	}
}

public class Caw {
	public void sound(){
    	System.out.println("멍멍")
	}
}

public class AnimalMain {
	public static void main(String[] args) {
    	Dog dog = new Dog();
        Cat cat = new Cat();
        Caw caw = new Caw();
        
        //이부분이 계속 중복됨
        System.out.println("동물 소리 테스트 시작");
        dog.sound();
        System.out.println("동물 소리 테스트 종료");
        
        System.out.println("동물 소리 테스트 시작");
        cat.sound();
        System.out.println("동물 소리 테스트 종료");
        
        System.out.println("동물 소리 테스트 시작");
        caw.sound();
        System.out.println("동물 소리 테스트 종료");
	}
}

- 중복을 제거하기 위해서는 통상적으로 메서드를 사용하거나, 배열 또는 for문을 사용하지만 Dog, Cat, Caw는 모두 다른 클래스라 불가능하다.

 

- 다형성을 사용하여 중복 없애기

public calss Animal {
	public void sound() {
    	System.out.println("동물 울음 소리");
	}
}

calss Dog extends Animal {
	@Override
    public void sound(){
		System.out.println("멍멍");
	}
}

calss Cat extends Animal {
	@Override
	public void sound(){
		System.out.println("냐옹");
	}
}

calss Caw extends Animal {
	@Override
	public void sound(){
		System.out.println("음매");
	}
}

class AnimalPolyMain {
	public static void main(String args){
    	Dog dog = new Dog();
        Cat cat = new Cat();
		Caw caw = new Caw();
        Animal[] animalArr = {dog, cat, caw};
        
        //변하지 않는 코드
        for (Animal animal : animalArr{
        	System.out.println("동물 소리 테스트 시작");
        	animal.sound();
        	System.out.println("동물 소리 테스트 종료");
		}
	}
}

- Animal 클래스를 상속 받는 곳에서 sound() 메서드 오버라이딩을 하지 않는 실수를 방지하기 위해서는 추상 메서드를 활용하면 된다.

6. 추상 클래스

1) 추상 클래스

- Animal class와 같이 부모 클래스는 제공하지만 실제 생성되면 안되는 클래스를 추상 클래스라고 함.

- 추상 클래스는 추상적인 개념을 제공하는 클래스. 즉, 인스턴스가 존재하지 않고 상속을 목적으로 사용됨.

 

*사용 예) abstract class AbstractAnimal {...}

- 추상 클래스는 기존 클래스와 완전히 같으나 new AbstracAnima()과 같이 직접 인스턴스를 생성하지 못하는 제약이 추가됨.

2) 추상 메서드

- 자식 클래스가 반드시 오버라이딩 해야 하는 메서드를 부모 클래스에 정의하는 것.

- 실체가 존재하지 않고 메서드 바디가 없다.

 

*사용 예) public abstract void sound();

- 추상 메서드가 하나라도 있으면 추상 클래스로 선언해야 한다.

- 추상 메서드는 상속 받는 자식 클래스가 반드시 오버라이딩 해서 사용해야 한다.

3) 순수 추상 클래스

- 모든 메서드가 추상 메서드인 추상 클래스

- 인스턴스를 생성할 수 없다.

- 상속시 자식은 모든 메서드를 오버라이딩 해야 한다.

- 주로 다형성을 위해 사용된다.

- 자바는 이 기능을 편리하게 사용할 수 있는 인터페이스라는 개념을 사용한다.

7. 인터페이스

- 순수 추상 클래스를 더 편리하게 사용할 수 있는 기능

- 인스턴스를 생성할 수 없다.

- 상속시 모든 메서드를 오버라이딩 해야 한다.

- 주로 다형성을 위해 사용된다.

- 인터페이스 메서드는 모두 public, abstract 이다.

- 메서드에 public abstract를 생략할 수 있다.

- 다중 구현을 지원한다.

- 인터페이스는 class 대신에 interface로 선언된다.

- 인터페이스를 상속받을 때는 implements라는 구현 키워드를 사용한다.

 

*인터페이스를 사용해야하는 이유

- 제약을 만들어 반드시 구현해야 하는 항목들을 지정할 수 있다.

- 다중 구현이 가능하다.

1) 다중 구현

- 인터페이스는 모두 추상 메서드로 이루어져 있기 때문에 다중 구현이 가능하다.

public interface InterfaceA {
    void methodA();
    void methodCommon();
}

public interface InterfaceB {
    void methodB();
    void methodCommon();
}

public class Child implements InterfaceA, InterfaceB {
    @Override
    public void method(){
    	System.out.println("Child.methodA");
    }
    
    @Override
    public void methodB(){
    	System.out.println("Child.methodB");
    }
    
    @Override
    public void methodCommon(){
    	System.out.println("Child.methodCommon");
    }
}

public class DiamondMain {
	public static void main(String[] args){
    	InterfaceA a = new Child();
        a.methodA();
        a.methodCommon();
        
        InterfaceB b = new Child();
        b.methodB();
        b.methodCommon();
	}
}

출처 : 김영한의 실전 자바-기본편