F009 - Inheritance, Composition

✍️ 이번 시간에는 멘토님께서 질문해주셨던 상속과 조합에 대해 다뤄볼까 한다.

사실 Java 라는 언어가 왜 객체지향 언어인지, 이러한 특징을 통해 가지는 이점과 단점, 단점을 해결하기 위해 어떤 방법들이 있는지 제대로 알지 못한 채 사용하고 있었다. (지금까지도!)

이번 기록을 통해 상속과 구현, 그리고 조합(Composition)을 파헤쳐보자!

---

상속 (Inheritance)

상속은 클래스 명 우측에 extends 라는 예약어를 통해 상속 받을 수 있고, 1개의 클래스만 상속 받을 수 있다.

위의 다이어그램을 확인해보자. 먼저 Animal 클래스가 최상위 클래스로 존재하고 그 아래에 Mammal, Bird 클래스, 이 두 클래스의 각각 아래에 Dog, Whale, Eagle, Kiwi 클래스가 존재한다. 다이어그램에서는 하위 클래스들이 상위 클래스를 향해 바라보고 있는데 이는 상속을 표현한 것이다.

Animal 클래스와 그의 자식인 Mammal, Bird 클래스의 코드를 확인해보자.

// Animal
public class Animal {
    public int eyes  = 2;
    public int mouse = 1;
    public int legs  = 4;

		public Animal() {
			System.out.println("나는 동물이다.");
		}

    public void move() {
        System.out.println("걸어서 이동한다.");
    }

    public void breeding() {
        System.out.println("번식한다.");
    }

    public void getElements() {
        System.out.println("눈 : " + eyes + "개");
        System.out.println("입 : " + mouse + "개");
        System.out.println("다리 : " + legs + "개");
    }
}

// Mammal
public class Mammal extends Animal {

    public Mammal() {
        System.out.println("나는 포유류다.");
    }

    public Mammal(int legs) {
        this.legs = legs;
        System.out.println("다리가 " + this.legs + "개를 가진 포유류다.");
    }

    @Override
    public void breeding() {
        System.out.println("임신으로 자식을 낳아 세대를 잇는다.");
    }
}

// Bird
public class Bird extends Animal {

    public int wings = 2;

    public Bird() {
        this.legs = 2;
        System.out.println("나는 조류다.");
    }

    public Bird(int wings) {
        this.wings = wings;
        this.legs = 2;
        System.out.println("날개가 " + this.wings + "개를 가진 조류다.");
    }

    public void fly() {
        System.out.println("날아서 이동한다.");
    }

    @Override
    public void breeding() {
        System.out.println("알을 낳아 세대를 잇는다.");
    }

    @Override
    public void getElements() {
        super.getElements();
        System.out.println("날개 : " + wings + "개");
    }
}

상태와 행동

먼저 Animal 클래스에는 eyes, mouse, legs 3개의 멤버 필드와 move(), breeding(), getElements() 3개의 메소드가 정의되어 있다. Animal을 상속받는 자식 클래스라면 공통적으로 가지고 있어야 하는 상태(Field)와 행동(Method)이다. 즉, Mammal과 Bird 클래스는 3개의 멤버 필드와 3개의 메소드를 가지고 있다는 의미이며, 이는 SOLID 원칙에서 Liskov Substitution Principle (리스코프 치환 원칙)에 속하며 일반적인 IS-A 관계가 성립되어야 한다는 것을 의미한다.

다형성 (Polymorphism)

Mammal 클래스에서는 breeding(), Bird 클래스에서는 legs 필드와 breeding() 메소드가 재정의 되고 wings 라는 멤버 필드와 fly() 메소드가 새롭게 선언되었다. 이는 다형성(Polymorphism)의 특징을 나타내는데, Override를 통해 부모 클래스에서 선언한 멤버 필드, 메소드를 재정의하거나 해당 자식 클래스에 새로운 멤버 필드나 메소드를 선언하는 것은 하나의 구현체가 각기 다른 상태와 행동을 가질 수 있다는 것을 의미한다.

이제 Mammal, Bird 클래스의 자식 클래스 코드를 보며 추가적인 특징을 알아보자.

// Dog
public class Dog extends Mammal{

    public Dog() {
        System.out.println("나는 강아지다.");
    }
}

// Whale
public class Whale extends Mammal {
    public boolean fin = true;

    public Whale() {
        super(0);
        System.out.println("나는 고래다.");
    }

    protected void swim() {
        System.out.println("다리 대신 지느러미가 있어 헤엄쳐서 이동한다.");
    }

    @Override
    public void move() {
        System.out.println("다리가 없어 걸어서 이동 할 수 없다.");
    }

    @Override
    public void getElements() {
        super.getElements();
        System.out.println("지느러미가 있나? : " + fin);
    }
}

// Eagle
public class Eagle extends Bird {

    public Eagle() {
        System.out.println("나는 독수리다.");
    }
}

// Kiwi
public class Kiwi extends Bird {

    public Kiwi() {
        super(0);
        System.out.println("나는 키위새다.");
    }

    @Override
    public void fly() {
        System.out.println("날개가 없어 날 수 없다.");
    }
}

super()

부모 클래스를 상속 받은 자식 클래스가 new 생성자로 선언될 때, 자식 클래스만 메모리에 할당되는 것이 아니라 부모 클래스도 함께 할당된다. 자식 클래스의 생성자가 호출 될 때, super()라는 예약어가 함께 호출되는데, 별도로 부모 클래스에서 생성자를 정의하지 않는 경우 컴파일러에 의해 자동으로 자식 클래스의 생성자에 추가되어 자식 클래스와 부모 클래스가 메모리에 함께 할당될 수 있도록 한다.

단, 부모 클래스에서 기본 생성자를 정의하지 않고 매개 변수를 받도록 생성자를 정의한다면 자식 클래스의 생성자에 매개 변수를 넣은 super() 예약어를 호출해야한다. 그렇지 않으면 컴파일러가 부모 클래스의 기본 생성자를 찾을 수 없어 컴파일 에러가 발생한다. 그렇기 때문에 위 코드처럼 부모 클래스에서 여러 생성자를 정의하는 경우, 기본 생성자를 명시적으로 정의하는 것이 좋다.

리스코프 치환 원칙에 어긋나는 경우

앞에서 리스코프 치환 원칙을 잠깐 맛봤는데, 해당 원칙은 개방 폐쇄 원칙에 기반하는 원칙으로 서브 타입은 언제나 기반 타입으로 교체할 수 있어야 하는 원칙이다. 근데 위의 코드에서 리스코프 치환 원칙을 깨는 코드가 존재한다.

Whale is a Mammal.
Kiwi is a Bird.

바로 Mammal - Whale, Bird - Kiwi 의 상속 관계에서 리스코프 치환 원칙의 IS-A 관계가 성립하지 못한다. 여기서 IS-A 관계란, 부모 클래스에서 정의된 모든 것들이 자식 클래스에서 모두 사용이 가능해야 하는 것을 의미한다. 하지만 여기서 객체의 관점으로 Mammal - Whale, Bird - Kiwi 관계를 들여다보면 그렇지 못하다.
(객체관점의 프록그래밍은 추천하지 않는다. 자세한 내용은 Youtube에서 우테코 검색!)

먼저 Mammal 클래스는 Animal 클래스에서 정의한 eyes, mouse, legs를 재정의하지 않았다. 그러므로 Whale이 그대로 상속 받는다면 다리가 4개이면서 걸을 수 있는 이종 Whale이 탄생한다. 즉, Whale은 Mammal에 속하는 객체가 맞지만 부모 클래스의 구조에 의해 부모 클래스에서 정의한 move() 메소드를 사용하지 못하기 때문에 IS-A 관계를 성립하지 못해 해당 원칙을 위배한다.

Bird - Kiwi 의 관계도 동일하다. Bird 클래스는 Animal에서 정의한 legs를 2개로 재정의 했고, Bird 임을 증명하기 위해 wings 필드도 선언했다. 하지만 이를 상속받는 Kiwi는 wings(날개)가 없고, 이 때문에 fly() 메소드를 사용 할 수 없다.

이렇게 리스코프 치환 원칙이 어긋나는 경우는 다양하게 존재하며, 이에 위반되는 것은 곧 개방 폐쇄 원칙이 무너지는 것이라고 봐도 무방하다. 때문에 이러한 원칙을 위반하지 않기 위해서 Composition이라는 개념을 사용하기도 한다.

• 부모 클래스에서 명시한 값에서 벗어난 값을 리턴한다.
• 부모 클래스에서 벗어난 예외를 발생한다.
• 부모 클래스를 벗어난 기능을 수행한다.
• Array.asList() 와 List가 바로 해당 원칙에 어긋나는 대표적인 예시이다.

  public class ArrayListTest() {
  		public static void main(String[] args) {
  				List list = Arrays.asList("aa","bb","cc");
          List list2 = current(list);
          list2.forEach(l -> System.out.println(l));
      }
  
      public static List current(List list) {
          String a = "hello";
          list.add(a);
          return list;
      }
  }
  
  /*
  Exception in thread "main" java.lang.UnsupportedOperationException
  	at java.util.AbstractList.add(AbstractList.java:148)
  	at java.util.AbstractList.add(AbstractList.java:108)
  	at Inheritance.InheritanceTest.main(ArrayListTest.java:42)
  */

상속의 특징만 뽑아먹기

📍 상속은 extends 예약어를 잉용해 최대 1개의 클래스를 상속 받을 수 있다.

📍 부모 클래스에서 별도의 생성자 선언이 없다면 자식 클래스가 선언될 때, 자식 클래스의 생성자에 컴파일러가 super() 예약어를 추가하여 부모, 자식 클래스가 메모리에 할당될 수 있도록 한다.

📍 상속은 리스코프 치환 원칙을 따르지만 Array.asList()와 List 인터페이스처럼 이를 위반하는 경우도 있으며, 이를 위반할 경우 캡슐화와 개방 폐쇄 원칙을 위반하는 것이다. (이를 해결하기 위해 Composition을 사용.)

📍 @Override 를 통해 부모 클래스에서 정의된 메소드, 메소드를 자식 클래스에서 재정의를 수행하면서 다형성의 특징을 가진다.

📍 컴파일 시점에 객체의 구현체가 결정되기 때문에 설계에 유연하지 못하다.

📍 컴부모 클래스의 내부 구현이 달라지면 하위 클래스를 고쳐야하는 경우가 발생하는데, 이는 캡술화를 위반한다.

---

조합 (Composition)

앞에서 알아봤던 것 처럼 Java의 상속은 언제나 완벽하지는 않다. 이를 보완하고 해결하기 위해 Composition이라는 개념이 등장한다. Composition이란 구성이라는 의미로 클래스의 멤버 변수에 참조 객체를 선언하고, 이를 생성자를 통해 기존에 만들어진 객체를 주입하여 해당 클래스에서 참조할 객체를 상속 받지 않아도 클래스의 인스턴스 변수로 참조하고 있는 객체의 메소드를 호출 할 수 있도록 설계하는 것을 의미한다. 이를 통해 하나의 객체만 참조 할 수 있는 Inheritance와 다르게, Composition은 해당 객체에서 참조할 여러 객체를 인스턴스화 하므로써 Inheritance보다 많은 객체를 참조 할 수 있다는 이점이 있다. 또한, 참조한 객체의 메소드를 참조 객체에서 의도한 값으로 재정의 없이 리턴하여 사용 할 수 있다는 점은 리스코프 치환 원칙과 개방 폐쇄 원칙을 잘 따르는 것으로 볼 수 있다.

그 예로, 햄버거 세트를 생각해보자. 기존에 Inheritance를 이용해 햄버거 세트를 만들었다고 가정했을 때, 햄버거와 콜라 그리고 감자튀김이 햄버거 세트를 상속 받는다. 하지만 이는 IS-A 관계를 성립하지 못한다. 햄버거와 감자튀김은 먹을 수 있지만 콜라처럼 마실 수는 없다. 즉, 이 세 가지 객체는 부모 객체에서 의도한 상태와 행동을 그대로 물려받지 못하는데, 이는 햄버거 세트는 햄버거와 콜라 그리고 감자튀김 자체가 될 수 없다는 것을 의미하며 리스코프 치환 원칙 및 개방 폐쇄 원칙에 어긋난다.

public class HamburgerSet extends Menu {
    public Hamburger   hamburger;
    public Coke        coke;
    public FrenchFries frenchFries;

    public HamburgerSet(Hamburger hamburger, Coke coke, FrenchFries frenchFries) {
        this.hamburger = hamburger;
        this.coke = coke;
        this.frenchFries = frenchFries;

        this.name = hamburger.getName() + " 세트";
        this.price = (this.hamburger.getPrice() + this.coke.getPrice() + this.frenchFries.getPrice()) - 2000;
        System.out.println(this.name + " 가격 : " + this.price + "원");
    }

    public void getHamburger() {
        System.out.println("단품 메뉴명 : " + this.hamburger.getName());
        System.out.println("단품 가격 : " + this.hamburger.getPrice() + "원");
    }

    public void getCoke() {
        System.out.println("단품 메뉴명 : " + this.coke.getName());
        System.out.println("단품 가격 : " + this.coke.getPrice() + "원");
    }

    public void getFrenchFries() {
        System.out.println("단품 메뉴명 : " + this.frenchFries.getName());
        System.out.println("단품 가격 : " + this.frenchFries.getPrice() + "원");
    }
}

Composition의 특징 뽑아먹기

📍 다른 객체를 인스턴스 변수로 선언하므로써 해당 인스턴스의 메소드를 호출 할 수 있다.

📍 인스턴스로 선언된 객체의 내부 구조가 바뀌더라도 영향을 받지 않는다.

📍 인터페이스로 Composition을 구현하면 구현체의 Type을 손쉽게 바꿀 수 있다.

---

Inheritance, Composition

맥도날드의 메뉴판을 가지고 왔다. 적절한 예시가 아닐 수 있지만, 직접 코드로 구현해보니까 많은 글에서 설명하고 있는 내용들이 더 와닿는 것 같아 설명해보려고 한다.

먼저 Menu 객체는 모든 객체들의 조상이기 때문에 하위 객체들은 Menu 객체를 상속 받으며, 자식 객체들을 기본 생성자를 하나씩 가지고 있고 이 때 해당 객체의 메뉴명(name)과 가격(price)을 재정의한다.

HamburgerSet의 경우, 인자로 받는 객체의 종류에 따라 상태가 달라지며 인스턴스 변수로 선언한 hamburger, coke, frenchfies를 생성자에서 주입 받아 각 객체의 메소드를 제약없이 호출 할 수 있다. 이렇게 HamburgerSet을 여러 참조 객체로 구성한 것을 Composition이라고 한다.

public class CompositionTest {
    public static void main(String[] args) {
        // 빅맥 세트만들기
        // 코크 > 다이어트 콜라로 변경
        // 프렌치프라이 > 치즈 프렌치프라이 변경
        Hamburger   bigMac            = new BigMac();
        Coke        dietCoke          = new DietCoke();
        FrenchFries cheeseFrenchFries = new CheeseFrenchFries();

        HamburgerSet bigMacSet = new HamburgerSet(bigMac, dietCoke, cheeseFrenchFries);
        bigMacSet.getHamburger();
        bigMacSet.getCoke();
        bigMacSet.getFrenchFries();

        System.out.println();

        // 치즈버거
        // 기본 구성
        Hamburger    cheeseBurger    = new CheeseBurger();
        Coke         coke            = new Coke();
        FrenchFries  frenchFries     = new FrenchFries();
        HamburgerSet cheeseBurgerSet = new HamburgerSet(cheeseBurger, coke, frenchFries);
        cheeseBurgerSet.getHamburger();
        cheeseBurgerSet.getCoke();
        cheeseBurgerSet.getFrenchFries();
    }
}
/*
	빅맥 세트 가격 : 7500원
	단품 메뉴명 : 빅맥
	단품 가격 : 4500원
	단품 메뉴명 : 다이어트 콜라
	단품 가격 : 2000원
	단품 메뉴명 : 치즈 프렌치프라이
	단품 가격 : 3000원
	
	치즈버거 세트 가격 : 3500원
	단품 메뉴명 : 치즈버거
	단품 가격 : 2500원
	단품 메뉴명 : 코카콜라
	단품 가격 : 1500원
	단품 메뉴명 : 프렌치프라이
	단품 가격 : 1500원
*/

---

🤔 사실 지금까지 왜 상속을 받아야 하는지 모른채 개발했었다.
이번 시간을 통해 직접 상속을 구현해보면서 어떻게 하면 더 좋은 코드로 작성 할 수 있을지 많은 고민을 할 수 있었던 시간이였고, Composition을 구현하며 Spring Boot의 Bean 생성과 굉장히 비슷하다고 느꼈는데 Spring에 대해서 공부하게 되면 조금 더 알아보려고 한다.

지금까지 아무 의미도 모르고 썼던 코드들이 리스코프 치환 원칙이나 개방 폐쇄 원칙, 다형성과 캡술화 등 다양한 이론에 근거하여 만들어졌다는 것에 정말 놀랍다. 더 깊이 공부해서 여러 사항들을 고려한 좋은 코드를 작성 할 수 있는 개발자로 성장해야겠다.

---

참고 자료

SOLID - LSP ( 리스코프 치환 원칙) 에 대하여