OOP(3) 상속: 재사용과 확장 + LSP, ISP

상속은 상속이 아니다.

흔히 상속이라고 하면 부모의 유산을 상속받는다는 의미를 생각합니다.

아래 사전적 의미만 보아도 가족관계를 나타내는 단어인 것을 알 수 있습니다.

---

명사

• 2.

  법률 일정한 친족 관계가 있는 사람 사이에서, 한 사람이 사망한 후에 다른 사람에게 재산에 관한 권리와 의무의 일체를 이어 주거나, 다른 사람이 사망한 사람으로부터 그 권리와 의무의 일체를 이어받는 일.

---

흠... 대체 객체지향과 상속이 무슨 연관이 있는 것일까요?

 

맞습니다. 연관이 없습니다.

앞에 객체지향의 4대 특성이 캡슐화, 상속, 추상화, 다형성 이라고 해놓고 무슨 소리냐구요?

 

잠시만요. 말씀 끝까지 들어보세요..!

 

이는 영어를 한국어로 번역하다 생긴 오해 아닌 오해라고 말씀드리고 싶습니다.

객체지향에서의 상속은 계층도(조직도)가 아닌 분류도로 이해하는 것이 맞습니다.

 

출처 : 예스폼 <가족 계층도>

출처 : https://m.blog.naver.com/bluesomedays/120200503482 <동물 분류도>

 

분류도는 상속 관계가 아닙니다.

 

다시 말해 무척추 동물은 동물의 자식이 아닙니다.

척추동물도 조류의 부모일 수는 없지요.

 

동물이라고 하는 것을 세분화해서 무척추동물과 척추동물로 나뉘고, 

척추동물을 세분화해서 어류, 양서류, 파충류, 조류, 포유류가 나오는 것입니다.

 

객체 지향에서의 상속은 상위 클래스의 특성을 하위 클래스에서 상속하고 거기에 더해 필요한 특성을 확장(extends)해서 사용할 수 있다는 의미 입니다.

 

따라서, 부모 클래스와 자식 클래스로 쓰기 보다는 상위 클래스 - 하위클래스 혹은 슈퍼 클래스 - 서브 클래스라고  표현하는 것이 맞습니다.

🐶 여담이지만, 저도 부모와 자식 클래스로 배운터라 상속의 의미를 조금 오해했었음을 시인합니다.

 

아무튼 이러한 것을 생각해보면 상위 클래스로 갈수록 추상화/일반화 되고,

하위 클래스로 갈수록 구체화/특수화 됐다는 것을 알 수 있습니다.

 

이러한 이유로 상속 관계는 ⭐하위 클래스는 상위 클래스이다. 라는 문장을 반드시 만족해야 합니다.

 

아직 납득이 가지 않는다면 아래 코드를 통해 비교해보겠습니다.

아버지 영희 = new 딸();
// 딸이 태어났으니 아버지 역할을 하는 영희라 이름 지었다(?)

언뜻 봐도 논리적으로 맞지 않는 것을 알 수 있습니다.

동물 미키마우스 = new 쥐();
// 쥐가 한마리 태어났으니 동물 역할을 하는 미키마우스라 이름 지었다.

말이 어색하긴 하지만 논리적으로 봤을 때 크게 어색함이 없습니다.

 

마지막 결정적으로! 자바에서 상속을 할 때는 inheritance가 아닌 extends라는 키워드를 사용합니다.

자바를 만든 사람만큼 자바 객체 지향을 잘 이해한 사람은 없겠죠. 😁

상속의 강력함

이제 ⭐하위 클래스는 상위 클래스이다. 가 가져오는 상속의 강력함을 알려드리겠습니다.

public class Animal {
    String name;
    
    Animal() {
    	name = "동물";
    }
    
    void show() {
    	System.out.println(name);
    }
}

public class 포유류 extends Animal {
    포유류() {
    	name = "포유류";
    }
}

public class 조류 extends Animal {
    조류() {
    	name = "조류";
    }
}

public class Dog extends 포유류 {
    Dog() {
    	name = "강아지";
    }
}

public class 참새 extends 조류 {
    참새() {
    	name = "참새";
    }
}

public class Main {
	public static void main(String[] args) {
    	Animal animal = new Animal();
        Animal 포유류 = new 포유류();
        Animal 재롱이 = new Dog();
        
        animal.show();
        포유류.show();
        재롱이.show();
    }
}

동물
포유류
강아지

위 코드들을 보면 "하위 클래스는 상위 클래스다." 것이 확 와닿을 것 입니다.

포유류 한마리를 동물이라고 하는 것, 강아지 한마리를 동물이라고 하는 것이라고 하는데에 논리적으로 틀림이 없음을 알 수 있습니다.

이처럼 객체 지향은 인간의 논리를 그대로 코드로 옮길 수 있는 힘이 있습니다.

 

그럼 static(정적 메소드) 관련 얘기할 때 Math 클래스 예시를 들었던 것처럼...

상속은 어떤 것을 들 수 있을까요?

 

바로 모든 클래스의 상위 클래스인 Object 클래스 입니다.

Object 클래스는 자바의 클래스 상속 구조에서 최상위 클래스이기 때문에 모든 클래스는 Object  특성을 가질 수 있습니다.

그래서 어떤 클래스의 인스턴스이건 toString() 메소드를 사용할 수 있는 것이지요! 

---

다중상속이 안되는 이유

근데 여기서 잠깐!

Dog 클래스를

public class Dog extends 포유류, 동물 {
    Dog() {
    	name = "강아지";
    }
}

위와 같이 포유류와 동물 모두 상속받으면 어떻게 될까요?

아쉽게도(?) 자바에서는 다중 상속을 지원하지 않습니다.

 

C++을 발전/단순화 하면서 다중 상속을 과감히 빼버린 이유에 대해 간단히 짚고 넘어가겠습니다.

 

인어공주를 예로 설명해보겠습니다.

인어는 🧍‍♀️사람과 🐟물고기를 상속한다고 생각해 봅시다.

 

만약 인어에게 수영해! 라고 한다면 인어는 어떻게 동작해야 할까요?

사람처럼? 아니면 물고기처럼? 이와 같은 문제를 다중 상속의 다이아몬드 문제라고 합니다. 

이러한 이유로 자바는 다중 상속을 과감히 버리고, 대신 인터페이스를 도입하여 대체하였습니다.

인터페이스

혹시 인터페이스도 상속처럼 한 문장으로 나타낼 수 있을까요?

가능합니다.

---

💡 구현 클래스 is able to 인터페이스

➡️ 구현 클래스는 인터페이스 할 수 있다!

➡️ 참새는 날 수 있다.

 

인터페이스는 be able to, 즉 "무엇을 할 수 있는" 이라는 표현 형태로 만드는 것이 바람직 합니다.

• Serializable 인터페이스 : 직렬화할 수 있는
• Comparable 인터페이스 : 비교할 수 있는
• Runnable 인터페이스 : 실행할 수 있는

정리

질문 하나 하며 이상 마무리 하도록 하겠습니다.

 

상위 클래스는 하위 클래스에게 물려줄 특성이 많을 수록 좋을까요? 적을 수록 좋을까요?

인터페이스는 구현을 강제할 메소드가 많을 수록 좋을까요? 적을 수록 좋을까요?

 

생각해보면 ⭐상위 클래스는 풍성할 수록 좋고, 인터페이스는 강제할 메소드가 적을 수록 좋다는 것을 알 수 있습니다.

각각의 이유는 여기서 살펴보면 좋을텐데 그럼 글의 본질이 흐려지니 이건 다음 시간에 이어서 알아보도록 하겠습니다.

새로운 글로 작성하려 했는데 그러면 제가 나중에 볼 때 링크 이동하기 귀찮을 것 같아서 여기다 붙이겠습니다. ㅎ

(3.1 LSP, 3.2 ISP 참고)

하위 클래스 is a kind of 상위 클래스

객체 지향에서의 상속 관계를 나타내는 한 문장은 무엇일까요?

⭐하위 클래스는 상위 클래스이다. 

라고 했으니 하위 클래스 is a 상위 클래스 아님?!

 

이게 맞았으면 제가 이 글을 쓰고 있지 않았겠죠!? 😁

 

다시 등장

물론 아주 틀린 말은 아닙니다만, 좀 더 알맞은 문장이 있으니 그것으로 기억하는 것을 권장합니다.

 

⭐ 하위 클래스 is a kind of 상위 클래스

이는 마이크로소프트 개발자 사이트인 MSDN에서도 a kind of라고 명시하고 있으니 아주 이상한 소리는 아닙니다.

 

실제 예제를 한번 들어보면 확 이해가 되실겁니다.

 

펭귄 is a kind of 조류 => 펭귄은 조류의 한 분류다.

펭귄 is a kind of 동물 => 펭귄은 동물의 한 분류다.

LSP (리스코프 치환 원칙)

리스..코프 뭐요? 말이 조금 어렵고, 딱 들었을 때 무슨 의미인지 파악이 좀 힘듭니다.(저만 그럴지도

 

리스코프 치환 원칙은 객체지향 5원칙 중 하나 입니다.

객체지향 5원칙은 추후에 객체지향 기본이 끝나면 알아볼텐데요! 상속과 연관이 깊다보니 먼저 나왔네요.ㅎㅎ

 

아무튼 리스코프 지환 원칙은

 "하위 클래스는 언제나 상위 클래스를 대체할 수 있다는 원칙" 입니다.

 

원칙이라고 해서 항상 이런 사항들을 고려해서 코드를 작성할 필요는 없습니다.

앞서 배운 "하위 클래스 is a kind of 상위 클래스" 대로 구현한 프로그램이라면 이미 LSP를 잘 지키고 있는거니까요. 😁

또한 LSP로 작성한 코드는 논리적으로 이해할 때 막힘이 없어서 코드의 가독성이 매우 좋습니다.

public class Person {
    String name;
    int age;
    char gender;

    public void walk() {
        System.out.println(name + "이 걷는다.");
    }
}

public class Student extends Person {
    int studentID;

    public Student(int studentID, String name, int age, char gender) {
        this.studentID = studentID;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public void study() {
        System.out.println(name + "이 공부한다." );
    }
}

public class Soldier extends Person {
    int serialNum;

    public Soldier(int serialNum, String name, int age, char gender) {
        this.serialNum = serialNum;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public void shoot() {
        System.out.println(name + "이 사격하다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person kim = new Student(202301, "김학생", 18, 'F');
        Person lee = new Soldier(160320, "이군인", 22, 'M');
        Student park = new Student(2,"박경림", 32, 'F');

        Student s = (Student)kim;
        Soldier m = (Soldier)lee;

        s.study();
        m.shoot();
        park.walk();
    }
}

김학생이 공부한다.
이군인이 사격하다.
박경림이 걷는다.

굿!

반대로 계층도/조직도를 고려해서 작성한 코드에는 문제점이 발생합니다.

// 1. 계층도를 고려한 코드
아버지 영희 = new 딸();

딸 영희2 = (딸)영희;
영희2.꾸짖는다();

// 2. 분류도를 고려한 코드
사람 영희 = new 학생();

학생 영희2 = (학생)영희;
영희2.공부하다();

안좋은 예시 보여드리기 위해 긴 코드를 또 보여드리긴 좀 그래서 약식으로 작성해보았습니다.

 

언뜻 봐도 계층도를 고려한 코드는 갑자기 영희가 아버지 역할을 하는게 기괴해 보입니다.

반면에 분류도를 고려한 코드는 논리에 막힘이 없는 것을 확인할 수 있습니다.

 

이처럼 리스코프 치환 원칙을 이용하면 하위  객체는 상위 객체인 척 할 수 있습니다.

예) 고래는 동물 역할도 할 수 있다.

ISP (인터페이스 분리 원칙)

객체 지향 설계 5원칙 중 SRP(단일 책임 원칙)가 있습니다.

간단히 설명드리면 하나의 클래스에는 하나의 역할만 담도록 설계하는 것인데요.

 

하나의 역할(책임)만 하도록 하는 방법은 SRP 뿐이 아닙니다!

인터페이스 분리 원칙도 가능합니다. 😁

 

단일 책임 원칙은 클래스를 토막(?)내는 것이라면 인터페이스 분리 원칙은 다중 인격화(?) 하는 것이라고 할 수 있습니다.

프로젝트 요구사항과 설계자의 취향에 따라 SRP 혹은 ISP 둘 중 하나를 선택해서 설계할 수 있습니다.

하지만 특별한 경우가 아니라면 SRP를 적용하는 것을 권장합니다.

 

인터페이스가 주제로 나오면 항상 나오는 얘기가 있습니다.

바로 인터페이스 최소주의 원칙 입니다.

인터페이스를 통해 메소드를 외부에 제공할 때는 최소한의 메소드만 제공해야 합니다.

 

잠시 생각해보면 당연한 얘기 입니다.

'학생' 인터페이스에 '사격하다()' 메소드를 제공할 필요도 없고 제공해서도 안되기 때문입니다.

 

마지막으로 예제 코드 보여드리며 마무리 하겠습니다.

public interface Studiable {
    void study();
}

public interface Shootable {
    void shoot();
}

public class Person {
    String name;
    int age;
    char gender;

    public void walk() {
        System.out.println(name + "이 걷는다.");
    }
}

public class Student extends Person implements Studiable{
    int studentID;

    public Student(int studentID, String name, int age, char gender) {
        this.studentID = studentID;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    @Override
    public void study() {
        System.out.println(name + "이 공부한다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Student kim = new Student(2023, "김학생", 18, 'F');
        kim.study();
    }
}

// 김학생이 공부한다.

정리하자면!

인터페이스는 "~ 할 수 있는(is able to)" 이라는 기준으로 만드는 것이 정석 입니다.

정리

• 객체 지향의 상속은 상위 클래스의 특성을 '재사용' 하는 것이다.
• 객체 지향의 상속은 상위 클래스의 특성을 '확장' 하는 것이다.
• 객체 지향의 상속은 is a kind of 관계를 만족해야 한다.

감사합니다!