프로그래밍을 하다 보면 비슷한 코드를 반복해서 작성하는 일이 자주 생깁니다. 예를 들어, 학생 클래스와 교사 클래스가 이름, 나이, 소개 기능을 공통으로 갖고 있다면, 각각 일일이 정의하는 것은 번거롭고 비효율적이죠. 이때 파이썬의 상속(Inheritance) 기능을 사용하면, 기존 클래스를 재사용하면서 필요한 부분만 확장할 수 있습니다.
또한, 자식 클래스가 부모 클래스의 메서드를 자신에게 맞게 바꾸는 다형성(Polymorphism) 개념을 이해하면, 하나의 메서드 이름으로 다양한 동작을 표현할 수 있어 코드의 확장성과 유연성이 크게 향상됩니다.
이번 장에서는 파이썬의 상속 문법, 오버라이딩, 다형성의 개념과 실제 활용법까지 예제를 통해 상세히 살펴보겠습니다. 객체지향 프로그래밍의 핵심을 배우는 중요한 단계입니다.
- 상속이란 무엇인가?
- 파이썬에서 상속하는 문법
- 부모 클래스의 메서드 사용하기
- 자식 클래스에서 메서드 오버라이딩
- super()로 부모 메서드 호출하기
- 다형성이란 무엇인가?
- 다형성의 실제 예: 공통 메서드 호출
- isinstance()와 다형성 검사
- 다형성을 활용한 함수 설계
- 실전 예제: 동물 클래스와 상속 구조
상속이란 무엇인가?
상속(Inheritance)은 객체지향 프로그래밍의 핵심 개념 중 하나로, 기존 클래스(부모 클래스)의 기능을 새로운 클래스(자식 클래스)가 물려받는 것을 의미합니다. 즉, 자식 클래스는 부모 클래스의 변수와 메서드를 그대로 사용할 수 있으며, 필요에 따라 자신만의 기능을 추가하거나 수정(오버라이딩)할 수 있습니다.
상속의 가장 큰 장점은 코드 재사용성과 구조화입니다. 동일한 기능을 여러 클래스에 반복 작성하는 대신, 공통 기능은 부모 클래스에 정의하고, 차이점만 자식 클래스에서 구현하면 됩니다. 이 방식은 유지보수가 쉬워지고, 클래스 간 관계를 명확하게 해주는 효과도 있습니다.
class Animal:
def speak(self):
print("동물이 소리를 냅니다.")
class Dog(Animal): # Animal 클래스를 상속
pass
dog = Dog()
dog.speak() # 출력: 동물이 소리를 냅니다.
위 예제에서 Dog 클래스는 Animal 클래스를 상속받았기 때문에, speak() 메서드를 따로 정의하지 않아도 사용할 수 있습니다. 이처럼 자식 클래스는 부모 클래스의 기능을 자동으로 물려받게 되며, 필요한 경우 오버라이딩을 통해 자신만의 버전으로 변경할 수도 있습니다.
상속은 프로그램을 계층적이고 확장 가능한 구조로 만드는 데 필수적인 개념입니다. 이번 장에서는 이러한 상속 구조의 기본 문법부터 다양한 활용법까지 실습을 통해 깊이 있게 익히게 될 것입니다.
파이썬에서 상속하는 문법
파이썬에서 클래스를 상속받는 문법은 매우 간단합니다. 자식 클래스 정의 시 괄호 안에 상속할 부모 클래스의 이름을 넣으면 됩니다. 기본 형태는 다음과 같습니다:
class 부모클래스:
# 부모 클래스의 멤버(속성, 메서드) 정의
class 자식클래스(부모클래스):
# 자식 클래스의 멤버 정의
이 문법을 활용하면 자식 클래스는 부모 클래스에 정의된 변수와 메서드를 자동으로 상속받게 됩니다. 자식 클래스는 부모 클래스의 기능을 그대로 사용할 수도 있고, 필요하다면 새로운 기능을 추가하거나 기존 메서드를 오버라이딩(재정의)할 수도 있습니다.
class Vehicle:
def move(self):
print("이동 중입니다.")
class Car(Vehicle): # Vehicle 클래스 상속
def drive(self):
print("자동차를 운전합니다.")
my_car = Car()
my_car.move() # Vehicle로부터 상속받은 메서드
my_car.drive() # Car 클래스 고유 메서드
위 예제에서 Car 클래스는 Vehicle 클래스를 상속받아 move() 메서드를 그대로 사용할 수 있고, 동시에 drive()라는 새로운 메서드도 추가할 수 있습니다. 이러한 구조는 중복 코드를 줄이고, 기능을 명확하게 분리하여 유지보수를 쉽게 만듭니다.
파이썬에서는 다중 상속도 지원하지만, 복잡성이 높아질 수 있으므로 초급 단계에서는 단일 상속을 먼저 익히는 것이 좋습니다. 상속은 코드 재사용성뿐만 아니라 프로그램의 확장성과 계층 구조를 설계하는 데 중요한 역할을 합니다.
부모 클래스의 메서드 사용하기
상속의 가장 큰 장점 중 하나는 부모 클래스에서 정의한 메서드를 자식 클래스가 그대로 사용할 수 있다는 점입니다. 자식 클래스가 어떤 동작을 특별히 수정할 필요가 없다면, 부모 클래스에 정의된 메서드를 그대로 상속받아 사용할 수 있으며, 이는 코드의 중복을 줄이고 유지보수를 쉽게 만듭니다.
자식 클래스에서 상속받은 메서드를 사용할 때는 마치 자신의 메서드처럼 self.메서드() 형식으로 호출하면 됩니다. 파이썬은 자동으로 상속 계층을 탐색하여 해당 메서드를 찾아 실행합니다.
class Animal:
def sleep(self):
print("잠을 잡니다.")
class Cat(Animal):
def meow(self):
print("야옹!")
kitty = Cat()
kitty.sleep() # Animal에서 상속받은 메서드
kitty.meow() # Cat에서 정의된 메서드
위 예제에서 Cat 클래스는 Animal 클래스를 상속받았기 때문에, 별도로 정의하지 않아도 sleep() 메서드를 사용할 수 있습니다. 만약 Cat 클래스 내부에서 sleep()을 다시 정의하지 않는다면, 부모 클래스의 메서드가 그대로 호출됩니다.
이처럼 부모 클래스의 메서드를 재정의하지 않고 그대로 활용하면, 공통 기능은 부모 클래스에 집중하고, 자식 클래스는 고유 기능에만 집중할 수 있어 코드 구조가 훨씬 명확해집니다. 이러한 상속 기반 설계는 프로그램의 확장성과 재사용성을 크게 높여줍니다.
자식 클래스에서 메서드 오버라이딩
메서드 오버라이딩(Overriding)이란 자식 클래스가 부모 클래스에서 상속받은 메서드를 자신의 방식으로 다시 정의하는 것을 말합니다. 상속을 통해 기능을 그대로 사용할 수도 있지만, 상황에 따라 동작을 변경해야 할 필요가 있을 때 오버라이딩을 사용합니다. 동일한 이름의 메서드를 자식 클래스에서 정의하면, 부모의 메서드는 가려지고 자식의 메서드가 우선 적용됩니다.
이는 객체지향에서 다형성(polymorphism)을 실현하는 핵심 수단이기도 합니다. 오버라이딩은 자식 클래스가 부모의 기본 동작을 유지하면서도, 자신만의 특수한 행동을 구현할 수 있도록 도와줍니다.
class Animal:
def speak(self):
print("동물이 소리를 냅니다.")
class Dog(Animal):
def speak(self): # 부모의 speak()를 오버라이딩
print("멍멍!")
class Cat(Animal):
def speak(self): # 부모의 speak()를 오버라이딩
print("야옹!")
dog = Dog()
cat = Cat()
dog.speak() # 출력: 멍멍!
cat.speak() # 출력: 야옹!
위 예제에서 Dog와 Cat 클래스는 모두 Animal 클래스의 speak() 메서드를 상속받았지만, 자신들의 방식대로 재정의(오버라이딩)했습니다. 이렇게 하면 동일한 메서드 이름으로도 각 객체에 맞는 동작을 수행하게 됩니다.
오버라이딩 시 함수 이름과 매개변수 개수는 반드시 부모와 동일해야 하며, 그렇지 않으면 오버라이딩이 아닌 별개의 메서드로 인식됩니다. 공통된 인터페이스 + 개별 행동이라는 객체지향의 장점을 살리는 방법으로, 오버라이딩은 매우 중요한 도구입니다.
super()로 부모 메서드 호출하기
자식 클래스에서 메서드를 오버라이딩하면, 부모 클래스의 메서드는 가려져 더 이상 자동으로 호출되지 않습니다. 하지만 부모 클래스의 메서드도 함께 활용하고 싶을 때는 어떻게 해야 할까요? 이럴 때 사용하는 것이 바로 super()입니다. super()는 자식 클래스에서 부모 클래스의 메서드를 명시적으로 호출할 수 있도록 도와주는 함수입니다.
특히 자식 클래스가 부모의 초기화 메서드(__init__)나 공통 기능을 일부만 수정하고 나머지는 그대로 유지하고 싶을 때 매우 유용합니다. 다음 예제를 살펴보겠습니다.
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name}이(가) 소리를 냅니다.")
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # 부모의 __init__ 호출
self.breed = breed
def speak(self):
super().speak() # 부모의 speak 호출
print("멍멍!")
이 코드에서 Dog 클래스는 Animal 클래스를 상속받으며, __init__과 speak()를 모두 오버라이딩합니다. 그런데 super()를 사용하여 부모의 __init__()과 speak()를 호출하고 있기 때문에, 자식 클래스에서도 부모 클래스의 로직을 재사용하고 있습니다.
dog = Dog("초코", "시츄")
dog.speak()
# 출력:
# 초코이(가) 소리를 냅니다.
# 멍멍!
super()는 다중 상속에서도 중요한 역할을 하며, 상속 계층을 따라 메서드를 순차적으로 호출하게 해줍니다. 따라서 자식 클래스가 부모의 기능을 완전히 덮어쓰지 않고 일부만 확장할 경우, super()를 적극적으로 활용하는 것이 좋습니다.
다형성이란 무엇인가?
다형성(Polymorphism)은 객체지향 프로그래밍의 가장 강력한 특징 중 하나로, 같은 인터페이스(메서드 이름)로 서로 다른 동작을 수행할 수 있게 하는 성질을 의미합니다. 즉, 동일한 메서드 이름을 사용하더라도, 객체의 타입에 따라 실행되는 동작이 달라지는 것입니다.
예를 들어, 동물이라는 공통된 클래스가 있고, 그 하위에 개, 고양이, 새 클래스가 있다고 합시다. 이들 모두 speak()라는 메서드를 갖고 있지만, 개는 '멍멍', 고양이는 '야옹', 새는 '짹짹'이라고 울 수 있겠죠. 이처럼 메서드 이름은 같지만, 각 클래스에 맞게 동작을 다르게 구현하는 것이 바로 다형성입니다.
class Animal:
def speak(self):
print("동물이 소리를 냅니다.")
class Dog(Animal):
def speak(self):
print("멍멍!")
class Cat(Animal):
def speak(self):
print("야옹!")
def make_animal_speak(animal):
animal.speak()
이제 각 객체를 생성해 동일한 함수로 실행해보면 다음과 같은 결과를 얻을 수 있습니다.
make_animal_speak(Dog()) # 출력: 멍멍!
make_animal_speak(Cat()) # 출력: 야옹!
이처럼 하나의 함수(make_animal_speak)로 여러 객체를 받아 처리할 수 있는 이유가 바로 다형성 덕분입니다. 이 구조는 코드의 유연성을 높이고, 확장이 매우 쉬운 형태로 만들어줍니다. 새로운 동물 클래스를 추가하더라도 기존 함수는 전혀 수정할 필요가 없습니다.
다형성은 특히 대규모 프로젝트에서 유지보수성과 확장성을 극대화하는 데 필수적인 개념입니다. 다음 항목에서는 이 개념이 실제 코드에서 어떻게 활용되는지를 더 구체적으로 살펴보겠습니다.
다형성의 실제 예: 공통 메서드 호출
다형성이 실질적으로 가장 많이 활용되는 순간은 여러 객체를 하나의 구조로 묶어, 동일한 메서드를 호출할 수 있을 때입니다. 이 방식은 매우 직관적이면서도 확장성이 뛰어나서, 실무에서도 자주 사용됩니다. 예를 들어 여러 종류의 객체가 각각의 방식으로 play()라는 메서드를 구현했다면, 반복문 하나로 전부 호출할 수 있게 됩니다.
이러한 방식은 리스트나 컬렉션 안에 다양한 객체를 담아 처리하는 상황에서 특히 유용합니다. 새 클래스를 추가하거나 객체가 바뀌더라도 기존 코드는 수정 없이 계속 동작하게 되는 것이죠. 다음은 대표적인 예제입니다.
class Animal:
def speak(self):
print("동물이 소리를 냅니다.")
class Dog(Animal):
def speak(self):
print("멍멍!")
class Cat(Animal):
def speak(self):
print("야옹!")
class Bird(Animal):
def speak(self):
print("짹짹!")
이제 이 동물들을 리스트에 담고, 반복문 하나로 speak()를 호출해 보겠습니다.
animals = [Dog(), Cat(), Bird()]
for animal in animals:
animal.speak()
출력 결과는 다음과 같습니다:
멍멍!
야옹!
짹짹!
이 예제는 메서드 이름은 같지만 객체의 종류에 따라 동작이 달라지는 다형성의 대표적인 활용입니다. 리스트 안에 어떤 객체가 들어오든, speak()라는 이름의 메서드만 존재하면 동일한 방식으로 처리할 수 있는 구조입니다.
이러한 설계는 유지보수를 용이하게 하고, 새로운 기능 추가 시 기존 코드를 손대지 않아도 되므로 개방-폐쇄 원칙(OCP)을 자연스럽게 따르게 됩니다. 객체지향 프로그래밍에서 다형성은 단순한 개념 이상으로, 확장 가능하고 유연한 코드를 만드는 핵심 기법입니다.
isinstance()와 다형성 검사
파이썬에서는 isinstance() 함수를 사용하여 어떤 객체가 특정 클래스의 인스턴스인지 확인할 수 있습니다. 이 함수는 다형성을 구현할 때 객체의 타입을 검사하거나 조건 분기를 할 때 유용하게 사용됩니다. 특히 여러 클래스가 공통 인터페이스를 따르지만, 세부 동작은 클래스마다 다를 경우, isinstance()를 통해 타입별 동작을 선택할 수 있습니다.
기본적인 사용법은 다음과 같습니다:
isinstance(객체, 클래스)
예제를 통해 확인해보겠습니다.
class Animal:
def speak(self):
print("동물이 소리를 냅니다.")
class Dog(Animal):
def speak(self):
print("멍멍!")
class Cat(Animal):
def speak(self):
print("야옹!")
def describe(animal):
if isinstance(animal, Dog):
print("강아지입니다.")
elif isinstance(animal, Cat):
print("고양이입니다.")
else:
print("기타 동물입니다.")
이제 각각의 객체에 대해 describe() 함수를 호출해 보겠습니다.
describe(Dog()) # 출력: 강아지입니다.
describe(Cat()) # 출력: 고양이입니다.
describe(Animal()) # 출력: 기타 동물입니다.
이처럼 isinstance()는 다형성을 활용하면서 클래스별로 조건을 나눠 처리해야 할 경우 효과적입니다. 그러나 지나치게 남용하면 객체지향 설계의 유연함을 해칠 수 있기 때문에, 가능하면 메서드 오버라이딩과 공통 인터페이스를 통해 코드 분기 없이 일관되게 처리하는 것이 바람직합니다.
즉, isinstance()는 다형성을 제어하거나 검사하는 데 사용할 수 있는 보조 도구로, 객체 구조를 이해하고 동작을 명확히 파악할 때 매우 유용한 함수입니다.
다형성을 활용한 함수 설계
객체지향 프로그래밍에서 함수 설계의 핵심은 입력되는 객체에 따라 다른 동작을 수행할 수 있는 유연성입니다. 이때 중요한 역할을 하는 것이 바로 다형성(polymorphism)입니다. 다형성을 고려하여 함수를 설계하면, 조건문 없이도 각 객체에 맞는 동작이 실행되며, 새로운 클래스가 추가되더라도 기존 함수를 수정할 필요 없이 확장이 가능합니다.
예를 들어, 동물 객체들을 받아서 울음소리를 출력하는 함수를 만든다고 해보겠습니다. 각 동물 클래스는 speak()라는 메서드를 공통으로 갖고 있지만, 실제 동작은 클래스마다 다릅니다. 이럴 때 아래처럼 작성하면 매우 깔끔한 함수 구조를 만들 수 있습니다.
class Animal:
def speak(self):
print("동물이 소리를 냅니다.")
class Dog(Animal):
def speak(self):
print("멍멍!")
class Cat(Animal):
def speak(self):
print("야옹!")
def make_it_speak(animal: Animal):
animal.speak()
이 함수 make_it_speak()는 Animal 타입의 객체를 인자로 받아, 해당 객체의 speak()를 실행합니다. 하지만 실제로는 Dog, Cat 같은 하위 클래스 객체를 받아도 잘 동작합니다.
make_it_speak(Dog()) # 멍멍!
make_it_speak(Cat()) # 야옹!
이 구조의 핵심은 공통된 메서드 인터페이스(speak)를 기준으로 동작을 설계했다는 점입니다. 이런 방식은 Open/Closed Principle(개방-폐쇄 원칙)을 만족시켜, 새로운 동물 클래스를 추가해도 기존 코드는 전혀 건드릴 필요가 없습니다. 예를 들어, Bird 클래스를 추가하고 speak()를 정의하면 그대로 사용 가능합니다.
이처럼 다형성에 기반한 함수 설계는 재사용성, 유지보수성, 확장성을 동시에 확보할 수 있는 매우 강력한 패턴이며, 객체지향 설계의 기본 중 기본이라 할 수 있습니다.
실전 예제: 동물 클래스와 상속 구조
지금까지 배운 상속과 다형성의 개념을 종합하여, 하나의 구조화된 예제를 통해 복습해 보겠습니다. 우리는 공통적인 특성을 갖는 Animal이라는 부모 클래스를 만들고, 이를 상속받는 다양한 동물 클래스들을 정의합니다. 각 동물 클래스는 공통된 speak() 메서드를 오버라이딩하여, 자신만의 소리를 출력하도록 합니다.
또한, 이 동물 객체들을 하나의 리스트에 담고 반복문을 통해 speak()를 호출해봄으로써, 다형성이 실제로 어떻게 동작하는지 확인할 수 있습니다.
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name}이(가) 소리를 냅니다.")
class Dog(Animal):
def speak(self):
print(f"{self.name}이(가) 멍멍 짖습니다.")
class Cat(Animal):
def speak(self):
print(f"{self.name}이(가) 야옹 울어요.")
class Bird(Animal):
def speak(self):
print(f"{self.name}이(가) 짹짹 울어요.")
이제 다양한 동물 객체를 만들어서 다형성을 확인해봅시다.
animals = [
Dog("초코"),
Cat("나비"),
Bird("참새")
]
for animal in animals:
animal.speak()
출력 결과:
초코이(가) 멍멍 짖습니다.
나비이(가) 야옹 울어요.
참새이(가) 짹짹 울어요.
이 예제는 상속, 메서드 오버라이딩, 다형성을 한눈에 이해할 수 있는 구조입니다. 공통 인터페이스를 유지하면서 객체별 동작을 분리할 수 있기 때문에, 이 패턴은 게임 캐릭터 시스템, 동물 사전, 채팅 봇 응답, UI 컴포넌트 처리 등 실무에서도 자주 사용됩니다.
학습자라면 이 예제를 바탕으로 Animal 외의 새로운 부모 클래스 설계나, 추가 동물 클래스 구현, 메서드 다중 정의 및 super() 활용 등으로 확장하며 객체지향 구조에 대한 이해를 넓혀볼 수 있습니다.
🔚 결론: 상속과 다형성, 객체지향의 핵심을 이해하다
이번 장에서는 객체지향 프로그래밍의 핵심 개념인 상속과 다형성에 대해 깊이 있게 알아보았습니다. 상속을 통해 기존 코드를 재사용하고, 자식 클래스에서 메서드를 자유롭게 오버라이딩함으로써 더욱 유연하고 구조화된 코드를 작성할 수 있게 되었습니다.
또한 다형성을 활용하면, 동일한 메서드 이름으로도 클래스에 따라 다른 동작을 실행할 수 있으며, 이를 통해 프로그램은 더 확장 가능하고 유지보수하기 쉬운 구조로 발전하게 됩니다. 실전 예제에서도 보았듯이, 다양한 객체를 공통된 인터페이스로 처리할 수 있다는 점은 매우 강력한 설계 전략입니다.
다음 장에서는 상속과 다형성의 응용 개념인 추상 클래스와 인터페이스의 구현을 학습하며, 더 정교한 객체 설계를 위한 개념들을 살펴보겠습니다. 지금까지 익힌 개념을 토대로 더 복잡한 클래스 관계를 자유롭게 표현할 수 있는 준비가 되셨습니다.
'프로그래밍 > 파이썬' 카테고리의 다른 글
| 12장. 메서드와 self의 의미 (0) | 2025.05.26 |
|---|---|
| 11장. 생성자 __init__()과 인스턴스 변수 (4) | 2025.05.26 |
| 10장. 클래스와 인스턴스 개념 (1) | 2025.05.19 |
| 9장. 예외 처리 (try, except, finally, raise) (0) | 2025.05.19 |
| 8장. 함수 정의와 호출 (매개변수, 반환값, 기본값, 키워드 인자) (0) | 2025.05.19 |