[JAVA] 다형성 왜 쓸까?

아래의 코드가있다.
여기서 생성자를 Berry A = new Apple(); 으로 A 변수를 선언한 이유가 궁금했다.

class Berry {
	String Str;
	void meth() {
		func();
	}
	void func() {
		System.out.println(Str);
	}
}
class Apple extends Berry {
	String Str;
	void func() {
		Str = "Apple";
		super.Str = "Berry";
		super.func();
		System.out.println(Str);
	}
}
public class Gisafirst {
	public static void main(String[] args) {
		Berry A = new Apple();
		A.meth();
	}
}

왜.. 굳이??
Apple A = new Apple(); 로 선언하면 좋지않나?

"Apple A = new Apple();"도 올바른 문법이긴하다
그러나 다형성으로 나타내는것이 코드의 유연성과 재 사용성을 높일 수 있다고한다

**Tip
Berry A = new Apple();
부모 클래스 타입의 변수인 'A'가 자식 클래스 'Apple'의 객체를 참조하고 있다고 해석하면 된다.



이해가 되지 않으니까 아래의 코드가 있다고 보자..

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

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

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 다형성 적용
        Animal animal2 = new Cat(); // 다형성 적용
        
        animal1.sound(); // Dog의 sound() 메서드 호출
        animal2.sound(); // Cat의 sound() 메서드 호출
    }
}

위의 예시 코드에서는 다형성을 활용하여 Animal 클래스를 상속받은 Dog와 Cat 클래스의 객체를 Animal 타입의 변수로 참조하고 있다

이렇게 하면 Animal 타입의 변수인 animal1과 animal2는 각각 Dog와 Cat 객체를 참조하고 있지만, 컴파일러는 부모 클래스 타입으로 인식한다

그러므로 animal1.sound()와 animal2.sound()를 호출하면 각각 Dog 클래스와 Cat 클래스에서 오버라이딩한 sound() 메서드가 실행된다.



그렇다면 다형성을 적용 하지 않는다면??
코드가 어떻게 달라질까??

예를 들어
동물의 종류가 더 추가되어야 하는 상황으로
Bird, Cow, Fish 등의 동물이 추가된다고 가정해 보면 자식 클래스내부는 차이가 없지만 main메소드에서 차이가 난다.


<다형성이 없는 경우>

// 다형성이 없는 경우
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

class Cow extends Animal {
    public void makeSound() {
        System.out.println("Cow moos");
    }
}

class Bird extends Animal {
    public void makeSound() {
        System.out.println("Bird chirps");
    }
}

class Fish extends Animal {
    public void makeSound() {
        System.out.println("Fish bubbles");
    }
}

public class MainWithoutPolymorphism {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        Cow cow = new Cow();
        Bird bird = new Bird();
        Fish fish = new Fish();
        
        dog.makeSound();
        cat.makeSound();
        cow.makeSound();
        bird.makeSound();
        fish.makeSound();
    }
}

새로운 동물이 추가될 때마다 해당 동물에 대한 객체 생성과 그에 따른 메서드 호출을 추가해 주어야 한다.
이는 유지보수가 어려워지고 중복된 코드가 발생할 가능성이 높다.



<다형성을 사용하는 main 메소드 경우>

// 다형성이 있는 경우
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

class Cow extends Animal {
    public void makeSound() {
        System.out.println("Cow moos");
    }
}

class Bird extends Animal {
    public void makeSound() {
        System.out.println("Bird chirps");
    }
}

class Fish extends Animal {
    public void makeSound() {
        System.out.println("Fish bubbles");
    }
}

public class MainWithPolymorphism {
    public static void main(String[] args) {
        Animal[] animals = new Animal[5];
        animals[0] = new Dog();
        animals[1] = new Cat();
        animals[2] = new Cow();
        animals[3] = new Bird();
        animals[4] = new Fish();
        
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}

새로운 동물이 추가되더라도 단순히 배열에 새로운 동물 객체를 추가하기만 하면 된다. main 메서드의 변경은 최소화되며, 기존 코드를 수정할 필요가 없어 유지보수가 훨씬 간편해진다

따라서 이러한 상황에서는 다형성을 사용하면 코드의 유지보수성이 향상되고 중복을 줄일 수 있다.