Ver2.0 C# 상속과 다형성 이해하기 🚀

C# 상속과 다형성 이해하기 🚀
객체지향의 핵심을 파헤쳐보자!
안녕? 오늘은 C#의 가장 중요한 개념 중 두 가지인 상속과 다형성에 대해 함께 알아볼 거야. 이 두 개념은 객체지향 프로그래밍의 핵심이자, 효율적인 코드를 작성하는 데 필수적인 요소지! 😊
프로그래밍을 처음 배울 때는 이런 개념들이 좀 어렵게 느껴질 수 있어. 하지만 걱정마! 오늘 이 글에서는 마치 친구와 대화하듯 쉽고 재미있게 설명해 줄게. 예제 코드와 시각적 요소도 많이 준비했으니 끝까지 따라와 봐! 🎮
📚 목차
- 상속이란 무엇인가? - 기본 개념 이해하기
- C#에서 상속 구현하기
- 다형성의 개념과 중요성
- 오버라이딩과 오버로딩 - 차이점 알아보기
- 추상 클래스와 인터페이스
- 실전 예제로 배우는 상속과 다형성
- 상속과 다형성의 모범 사례와 주의점
- 마무리 및 다음 단계
1. 상속이란 무엇인가? 🤔
상속은 객체지향 프로그래밍의 핵심 기둥 중 하나야. 간단히 말하면, 기존 클래스의 특성을 새로운 클래스가 물려받는 것을 말해. 이렇게 하면 코드 재사용성이 높아지고, 유지보수가 쉬워지지.
🏠 현실 세계의 상속 예시
상속을 이해하기 위해 현실 세계의 예를 들어볼게. 부모가 자식에게 재산이나 특성을 물려주는 것처럼, 프로그래밍에서도 '부모 클래스'가 '자식 클래스'에게 속성과 메서드를 물려줘.
예를 들어, '차량'이라는 부모 클래스가 있다고 생각해봐. 이 클래스는 모든 차량이 공통으로 가지는 특성(바퀴 수, 색상, 속도 등)과 기능(가속, 감속, 정지 등)을 가지고 있어. 그리고 '자동차', '오토바이', '트럭' 같은 자식 클래스들은 이 기본 특성을 상속받으면서 각자의 고유한 특성도 추가할 수 있지!
위 그림에서 볼 수 있듯이, Vehicle 클래스는 모든 차량의 공통 특성을 가지고 있고, 각 자식 클래스(Car, Motorcycle, Truck)는 이 특성을 상속받으면서 자신만의 고유한 특성을 추가하고 있어.
💡 상속의 장점
- 코드 재사용성: 같은 코드를 여러 번 작성할 필요가 없어져.
- 유지보수 용이성: 부모 클래스의 변경이 모든 자식 클래스에 자동으로 적용돼.
- 계층적 구조화: 프로그램을 더 논리적이고 체계적으로 구성할 수 있어.
- 확장성: 기존 코드를 수정하지 않고도 새로운 기능을 추가할 수 있어.
재능넷에서 프로그래밍 강의를 찾아보면, 상속 개념을 활용한 다양한 프로젝트 예제를 볼 수 있을 거야. 특히 게임 개발이나 웹 애플리케이션 분야에서는 상속을 활용한 코드 구조가 많이 사용되고 있지! 😉
2. C#에서 상속 구현하기 💻
이제 C#에서 어떻게 상속을 구현하는지 알아볼게. C#에서는 콜론(:)을 사용해서 상속 관계를 표현해.
📝 기본 상속 구문
class 자식클래스 : 부모클래스
{
// 자식 클래스의 멤버들
}
실제 예제를 통해 살펴보자! 앞서 설명한 차량 예제를 코드로 구현해볼게:
// 부모 클래스
public class Vehicle
{
public string Color { get; set; }
public int Speed { get; set; }
public int WheelCount { get; set; }
public void Accelerate(int amount)
{
Speed += amount;
Console.WriteLine($"속도 증가! 현재 속도: {Speed}km/h");
}
public void Brake(int amount)
{
Speed = Math.Max(0, Speed - amount);
Console.WriteLine($"속도 감소! 현재 속도: {Speed}km/h");
}
public void Stop()
{
Speed = 0;
Console.WriteLine("정지했습니다!");
}
}
// 자식 클래스
public class Car : Vehicle
{
public int DoorCount { get; set; }
public void OpenWindow()
{
Console.WriteLine("창문을 열었습니다!");
}
}
// 다른 자식 클래스
public class Motorcycle : Vehicle
{
public string HandleType { get; set; }
public void Lean()
{
Console.WriteLine("오토바이를 기울였습니다!");
}
}
위 코드에서 Car와 Motorcycle 클래스는 Vehicle 클래스를 상속받았어. 그래서 Color, Speed, WheelCount 속성과 Accelerate(), Brake(), Stop() 메서드를 별도로 구현하지 않아도 사용할 수 있지!
🚗 상속 클래스 사용 예제
// 자동차 객체 생성 및 사용
Car myCar = new Car();
myCar.Color = "빨강";
myCar.Speed = 0;
myCar.WheelCount = 4;
myCar.DoorCount = 4;
// 부모 클래스의 메서드 사용
myCar.Accelerate(50); // 출력: 속도 증가! 현재 속도: 50km/h
// 자식 클래스의 고유 메서드 사용
myCar.OpenWindow(); // 출력: 창문을 열었습니다!
// 오토바이 객체 생성 및 사용
Motorcycle myBike = new Motorcycle();
myBike.Color = "검정";
myBike.Speed = 0;
myBike.WheelCount = 2;
myBike.HandleType = "스포츠";
// 부모 클래스의 메서드 사용
myBike.Accelerate(70); // 출력: 속도 증가! 현재 속도: 70km/h
// 자식 클래스의 고유 메서드 사용
myBike.Lean(); // 출력: 오토바이를 기울였습니다!
🔄 생성자와 상속
상속 관계에서 생성자는 어떻게 동작할까? 자식 클래스의 객체가 생성될 때, 부모 클래스의 생성자가 먼저 호출되고 그 다음에 자식 클래스의 생성자가 호출돼. 이때 base 키워드를 사용해서 부모 클래스의 생성자에 매개변수를 전달할 수 있어.
public class Vehicle
{
public string Color { get; set; }
public int Speed { get; set; }
// 부모 클래스 생성자
public Vehicle(string color)
{
Color = color;
Speed = 0;
Console.WriteLine($"{color}색 차량이 생성되었습니다.");
}
}
public class Car : Vehicle
{
public int DoorCount { get; set; }
// 자식 클래스 생성자
public Car(string color, int doorCount) : base(color) // base 키워드로 부모 생성자 호출
{
DoorCount = doorCount;
Console.WriteLine($"{doorCount}개의 문이 있는 자동차가 생성되었습니다.");
}
}
이렇게 하면 Car 객체를 생성할 때 다음과 같이 출력돼:
Car myCar = new Car("파랑", 4);출력:
파랑색 차량이 생성되었습니다.4개의 문이 있는 자동차가 생성되었습니다.
⚠️ C#의 단일 상속
C#에서는 한 클래스가 여러 클래스를 동시에 상속받을 수 없어(다중 상속 불가). 이건 Java와 같은 특성이야. 하지만 인터페이스는 여러 개를 구현할 수 있어. 이에 대해서는 나중에 더 자세히 알아볼게!
3. 다형성의 개념과 중요성 🔄
다형성(Polymorphism)은 객체지향 프로그래밍의 또 다른 핵심 개념이야. 다형성이란 '여러 형태를 가질 수 있는 능력'을 의미해. 프로그래밍에서는 같은 인터페이스나 메서드가 다양한 형태로 동작할 수 있다는 걸 말하지.
🎭 현실 세계의 다형성 예시
다형성을 이해하기 위한 현실 세계의 예를 들어볼게. 리모컨의 '볼륨 올리기' 버튼을 생각해봐. 이 버튼은 TV, 오디오, 에어컨 등 다양한 기기에서 각각 다르게 동작하지만, 사용자 입장에서는 그냥 '볼륨 올리기' 버튼을 누르기만 하면 돼. 이처럼 같은 인터페이스(버튼)가 다양한 객체(기기)에 따라 다르게 동작하는 것이 다형성의 개념이야.
C#에서 다형성은 주로 두 가지 방식으로 구현돼:
- 메서드 오버라이딩(Method Overriding): 자식 클래스에서 부모 클래스의 메서드를 재정의하는 것
- 메서드 오버로딩(Method Overloading): 같은 이름의 메서드를 매개변수를 다르게 하여 여러 개 정의하는 것
👨👦 다형성의 실제 예제
앞서 본 차량 예제를 확장해서 다형성을 적용해 볼게:
public class Vehicle
{
public string Color { get; set; }
public int Speed { get; set; }
// 가상 메서드 - 자식 클래스에서 오버라이드 가능
public virtual void MakeSound()
{
Console.WriteLine("일반적인 차량 소리");
}
public void DisplayInfo()
{
Console.WriteLine($"이 차량은 {Color}색이고, 현재 속도는 {Speed}km/h입니다.");
}
}
public class Car : Vehicle
{
// 부모 클래스의 메서드 오버라이딩
public override void MakeSound()
{
Console.WriteLine("부릉부릉!");
}
}
public class Motorcycle : Vehicle
{
// 부모 클래스의 메서드 오버라이딩
public override void MakeSound()
{
Console.WriteLine("오토바이 엔진 소리: 드르르르륵!");
}
}
public class Truck : Vehicle
{
// 부모 클래스의 메서드 오버라이딩
public override void MakeSound()
{
Console.WriteLine("큰 트럭 소리: 구구구구!");
}
}
이제 다형성을 활용해서 이 클래스들을 사용해보자:
// 다형성 활용 예제
Vehicle vehicle1 = new Car();
Vehicle vehicle2 = new Motorcycle();
Vehicle vehicle3 = new Truck();
vehicle1.Color = "빨강";
vehicle2.Color = "파랑";
vehicle3.Color = "검정";
// 같은 메서드 호출이지만 각 객체 타입에 따라 다르게 동작
vehicle1.MakeSound(); // 출력: 부릉부릉!
vehicle2.MakeSound(); // 출력: 오토바이 엔진 소리: 드르르르륵!
vehicle3.MakeSound(); // 출력: 큰 트럭 소리: 구구구구!
// DisplayInfo는 오버라이드하지 않았으므로 부모 클래스의 메서드가 호출됨
vehicle1.DisplayInfo(); // 출력: 이 차량은 빨강색이고, 현재 속도는 0km/h입니다.
vehicle2.DisplayInfo(); // 출력: 이 차량은 파랑색이고, 현재 속도는 0km/h입니다.
vehicle3.DisplayInfo(); // 출력: 이 차량은 검정색이고, 현재 속도는 0km/h입니다.
위 코드에서 부모 타입의 변수(Vehicle)로 자식 객체(Car, Motorcycle, Truck)를 참조하고 있어. 이것이 바로 다형성의 핵심이야! 같은 타입의 변수로 다양한 객체를 다룰 수 있게 되는 거지.
💡 다형성의 장점
- 코드 유연성: 같은 인터페이스로 다양한 객체를 다룰 수 있어.
- 확장성: 새로운 클래스를 추가해도 기존 코드를 수정할 필요가 없어.
- 유지보수 용이성: 코드가 더 모듈화되고 구조화되어 유지보수가 쉬워져.
- 코드 재사용: 공통 기능은 부모 클래스에 구현하고, 특수한 기능만 자식 클래스에서 재정의할 수 있어.
다형성은 특히 대규모 프로젝트에서 빛을 발해. 재능넷에서 프로그래밍 프로젝트를 의뢰할 때, 다형성을 잘 활용한 코드는 확장성과 유지보수성이 뛰어나 장기적으로 더 가치 있는 결과물을 얻을 수 있어! 🌟
4. 오버라이딩과 오버로딩 - 차이점 알아보기 🔄
앞서 다형성을 구현하는 두 가지 방법으로 오버라이딩과 오버로딩을 언급했어. 이 둘은 비슷하게 들리지만 완전히 다른 개념이야. 자세히 알아보자!
🔄 메서드 오버라이딩 (Method Overriding)
부모 클래스에서 정의한 메서드를 자식 클래스에서 재정의하는 것을 말해.
오버라이딩의 특징:
- 메서드 이름, 매개변수, 반환 타입이 모두 동일해야 함
- 부모 클래스의 메서드는
virtual,abstract, 또는 이미override된 메서드여야 함 - 자식 클래스의 메서드는
override키워드를 사용해야 함 - 런타임 다형성(동적 바인딩)을 구현함
🔀 메서드 오버로딩 (Method Overloading)
같은 이름의 메서드를 매개변수의 타입이나 개수를 다르게 하여 여러 개 정의하는 것을 말해.
오버로딩의 특징:
- 메서드 이름은 같지만, 매개변수의 타입, 개수, 순서가 달라야 함
- 반환 타입만 다른 것은 오버로딩으로 인정되지 않음
- 같은 클래스 내에서 발생함 (상속과 직접적인 관련 없음)
- 컴파일 타임 다형성(정적 바인딩)을 구현함
📝 오버라이딩 예제
public class Animal
{
// virtual 키워드로 오버라이딩 가능하게 함
public virtual void MakeSound()
{
Console.WriteLine("동물이 소리를 냅니다.");
}
}
public class Dog : Animal
{
// override 키워드로 부모 메서드 재정의
public override void MakeSound()
{
Console.WriteLine("멍멍!");
}
}
public class Cat : Animal
{
// override 키워드로 부모 메서드 재정의
public override void MakeSound()
{
Console.WriteLine("야옹!");
}
}
사용 예:
Animal myDog = new Dog();
Animal myCat = new Cat();
myDog.MakeSound(); // 출력: 멍멍!
myCat.MakeSound(); // 출력: 야옹!
📝 오버로딩 예제
public class Calculator
{
// 정수 두 개를 더하는 메서드
public int Add(int a, int b)
{
return a + b;
}
// 정수 세 개를 더하는 메서드 (매개변수 개수가 다름)
public int Add(int a, int b, int c)
{
return a + b + c;
}
// 실수 두 개를 더하는 메서드 (매개변수 타입이 다름)
public double Add(double a, double b)
{
return a + b;
}
// 문자열 두 개를 연결하는 메서드 (매개변수 타입이 다름)
public string Add(string a, string b)
{
return a + b;
}
}
사용 예:
Calculator calc = new Calculator();
int result1 = calc.Add(5, 3); // 정수 두 개 더하기: 8
int result2 = calc.Add(5, 3, 2); // 정수 세 개 더하기: 10
double result3 = calc.Add(5.5, 3.2); // 실수 두 개 더하기: 8.7
string result4 = calc.Add("Hello, ", "World!"); // 문자열 연결: "Hello, World!"
🔑 오버라이딩과 오버로딩의 핵심 차이점
| 특성 | 오버라이딩 | 오버로딩 |
|---|---|---|
| 발생 위치 | 상속 관계의 클래스 간 | 같은 클래스 내 또는 상속 관계 |
| 메서드 시그니처 | 동일해야 함 | 달라야 함 (매개변수) |
| 바인딩 시점 | 런타임 (동적 바인딩) | 컴파일 타임 (정적 바인딩) |
| 키워드 | virtual, override | 필요 없음 |
| 목적 | 기존 기능 변경/확장 | 다양한 매개변수로 같은 기능 제공 |
오버라이딩과 오버로딩을 잘 이해하고 적절히 활용하면 더 유연하고 확장성 있는 코드를 작성할 수 있어. 특히 라이브러리나 프레임워크를 개발할 때 이 개념들은 필수적이지! 😊
5. 추상 클래스와 인터페이스 🏗️
상속과 다형성을 더 효과적으로 활용하기 위한 두 가지 중요한 개념인 추상 클래스(Abstract Class)와 인터페이스(Interface)에 대해 알아보자. 이 둘은 객체지향 설계에서 매우 중요한 역할을 해!
🧩 추상 클래스 (Abstract Class)
추상 클래스는 하나 이상의 추상 메서드를 포함할 수 있는 불완전한 클래스야. 추상 메서드는 선언만 있고 구현은 없는 메서드를 말해. 추상 클래스는 직접 인스턴스화할 수 없고, 반드시 상속을 통해 자식 클래스에서 추상 메서드를 구현해야 해.
// 추상 클래스 정의
public abstract class Shape
{
// 일반 속성
public string Color { get; set; }
// 일반 메서드
public void SetColor(string color)
{
Color = color;
Console.WriteLine($"도형의 색상을 {color}로 설정했습니다.");
}
// 추상 메서드 (구현 없음, 자식 클래스에서 반드시 구현해야 함)
public abstract double CalculateArea();
public abstract double CalculatePerimeter();
}
// 추상 클래스 상속 및 구현
public class Circle : Shape
{
public double Radius { get; set; }
public Circle(double radius)
{
Radius = radius;
}
// 추상 메서드 구현
public override double CalculateArea()
{
return Math.PI * Radius * Radius;
}
public override double CalculatePerimeter()
{
return 2 * Math.PI * Radius;
}
}
// 또 다른 구현
public class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }
public Rectangle(double width, double height)
{
Width = width;
Height = height;
}
// 추상 메서드 구현
public override double CalculateArea()
{
return Width * Height;
}
public override double CalculatePerimeter()
{
return 2 * (Width + Height);
}
}
사용 예:
// 추상 클래스는 직접 인스턴스화할 수 없음
// Shape shape = new Shape(); // 컴파일 오류!
// 자식 클래스로 인스턴스화
Shape circle = new Circle(5);
Shape rectangle = new Rectangle(4, 6);
circle.SetColor("빨강");
rectangle.SetColor("파랑");
Console.WriteLine($"원의 넓이: {circle.CalculateArea()}");
Console.WriteLine($"사각형의 넓이: {rectangle.CalculateArea()}");
// 출력:
// 도형의 색상을 빨강로 설정했습니다.
// 도형의 색상을 파랑로 설정했습니다.
// 원의 넓이: 78.53981633974483
// 사각형의 넓이: 24
🔌 인터페이스 (Interface)
인터페이스는 클래스가 구현해야 하는 메서드, 속성, 이벤트 등의 시그니처를 정의하는 계약과 같은 역할을 해. 인터페이스는 구현을 포함하지 않고 오직 선언만 있어. C# 8.0부터는 기본 구현(default implementation)도 가능해졌지만, 기본적으로는 구현 없이 선언만 포함해.
// 인터페이스 정의
public interface IDrawable
{
void Draw(); // 메서드 선언만 있음 (구현 없음)
string GetDescription(); // 메서드 선언
}
// 또 다른 인터페이스
public interface IResizable
{
void Resize(double factor);
}
// 인터페이스 구현
public class Square : IDrawable, IResizable
{
public double Side { get; set; }
public Square(double side)
{
Side = side;
}
// IDrawable 인터페이스 구현
public void Draw()
{
Console.WriteLine($"한 변의 길이가 {Side}인 정사각형을 그립니다.");
}
public string GetDescription()
{
return $"정사각형 (변의 길이: {Side})";
}
// IResizable 인터페이스 구현
public void Resize(double factor)
{
Side *= factor;
Console.WriteLine($"정사각형의 크기를 {factor}배로 조정했습니다. 새 변의 길이: {Side}");
}
}
사용 예:
Square square = new Square(5);
// 인터페이스 타입으로 참조
IDrawable drawable = square;
IResizable resizable = square;
drawable.Draw(); // 출력: 한 변의 길이가 5인 정사각형을 그립니다.
Console.WriteLine(drawable.GetDescription()); // 출력: 정사각형 (변의 길이: 5)
resizable.Resize(2); // 출력: 정사각형의 크기를 2배로 조정했습니다. 새 변의 길이: 10
🧩 추상 클래스의 특징
- abstract 키워드로 선언
- 일반 메서드와 추상 메서드를 모두 포함할 수 있음
- 필드, 생성자, 소멸자 등을 가질 수 있음
- 접근 제한자(public, protected 등) 사용 가능
- 다중 상속 불가능 (한 클래스는 하나의 추상 클래스만 상속 가능)
- 인스턴스 변수를 가질 수 있음
🔌 인터페이스의 특징
- interface 키워드로 선언
- 기본적으로 모든 멤버는 추상적 (C# 8.0부터 기본 구현 가능)
- 필드나 생성자를 가질 수 없음
- 모든 멤버는 암시적으로 public
- 다중 구현 가능 (한 클래스가 여러 인터페이스 구현 가능)
- 인스턴스 변수를 가질 수 없음
🤔 언제 추상 클래스를 사용하고, 언제 인터페이스를 사용해야 할까?
추상 클래스를 사용하는 경우:
- 관련된 클래스들 간에 공통 기능을 공유하고 싶을 때
- 상속받는 클래스들이 공통 메서드나 필드를 가질 때
- 추상 클래스를 상속받는 클래스들이 밀접하게 관련되어 있을 때
- non-public 멤버를 선언하고 싶을 때
인터페이스를 사용하는 경우:
- 서로 관련 없는 클래스들이 같은 동작을 구현해야 할 때
- 특정 동작을 다양한 클래스에서 구현하고 싶을 때
- 클래스가 여러 유형의 동작을 구현해야 할 때 (다중 상속 효과)
- API의 특정 기능만 노출하고 싶을 때
추상 클래스와 인터페이스는 객체지향 설계에서 매우 중요한 도구야. 재능넷에서 프로그래밍 관련 프로젝트를 진행할 때, 이런 개념들을 잘 활용하면 더 유연하고 확장성 있는 코드를 작성할 수 있어! 🚀
6. 실전 예제로 배우는 상속과 다형성 💪
지금까지 배운 개념들을 실제 프로그래밍에 어떻게 적용할 수 있는지 좀 더 복잡한 예제를 통해 알아보자! 간단한 게임 캐릭터 시스템을 구현해볼게.
🎮 게임 캐릭터 시스템 시나리오
RPG 게임에서 다양한 캐릭터 타입(전사, 마법사, 궁수 등)을 구현해야 해. 모든 캐릭터는 기본적인 속성(이름, 레벨, 체력)과 행동(공격, 방어, 이동)을 가지지만, 각 캐릭터 타입마다 특별한 능력과 행동 방식이 있어.
1. 기본 캐릭터 추상 클래스 정의
public abstract class GameCharacter
{
// 속성
public string Name { get; set; }
public int Level { get; private set; }
public int Health { get; protected set; }
public int MaxHealth { get; protected set; }
// 생성자
protected GameCharacter(string name, int level)
{
Name = name;
Level = level;
MaxHealth = CalculateMaxHealth();
Health = MaxHealth;
}
// 일반 메서드
public void LevelUp()
{
Level++;
MaxHealth = CalculateMaxHealth();
Health = MaxHealth;
Console.WriteLine($"{Name}이(가) 레벨 {Level}로 올랐습니다!");
OnLevelUp(); // 템플릿 메서드 패턴
}
public bool IsAlive()
{
return Health > 0;
}
public void TakeDamage(int damage)
{
if (damage < 0) throw new ArgumentException("데미지는 음수가 될 수 없습니다.");
int actualDamage = Math.Max(1, damage - GetDefense());
Health = Math.Max(0, Health - actualDamage);
Console.WriteLine($"{Name}이(가) {actualDamage}의 데미지를 입었습니다. 남은 체력: {Health}/{MaxHealth}");
if (Health <= 0)
{
Console.WriteLine($"{Name}이(가) 쓰러졌습니다!");
}
}
public void Heal(int amount)
{
if (amount < 0) throw new ArgumentException("회복량은 음수가 될 수 없습니다.");
int previousHealth = Health;
Health = Math.Min(MaxHealth, Health + amount);
int actualHeal = Health - previousHealth;
Console.WriteLine($"{Name}이(가) {actualHeal}만큼 체력을 회복했습니다. 현재 체력: {Health}/{MaxHealth}");
}
// 가상 메서드 (자식 클래스에서 오버라이드 가능)
protected virtual int CalculateMaxHealth()
{
return 100 + (Level * 10);
}
protected virtual void OnLevelUp()
{
Console.WriteLine("기본 레벨업 효과가 적용되었습니다.");
}
protected virtual int GetDefense()
{
return Level * 2;
}
// 추상 메서드 (자식 클래스에서 반드시 구현해야 함)
public abstract void Attack(GameCharacter target);
public abstract void SpecialAbility();
public abstract string GetCharacterType();
}
2. 인터페이스 정의
// 마법 능력을 가진 캐릭터를 위한 인터페이스
public interface IMagicUser
{
int ManaPoints { get; }
int MaxManaPoints { get; }
void CastSpell(string spellName, GameCharacter target);
void RegenerateMana(int amount);
}
// 원거리 공격이 가능한 캐릭터를 위한 인터페이스
public interface IRangedAttacker
{
int Range { get; }
void RangedAttack(GameCharacter target, int distance);
}
3. 구체적인 캐릭터 클래스 구현
// 전사 클래스
public class Warrior : GameCharacter
{
public int Strength { get; private set; }
public bool IsRaging { get; private set; }
public Warrior(string name, int level) : base(name, level)
{
Strength = 10 + level * 2;
}
protected override int CalculateMaxHealth()
{
// 전사는 체력이 더 많음
return 120 + (Level * 15);
}
protected override void OnLevelUp()
{
base.OnLevelUp();
Strength += 2;
Console.WriteLine($"힘이 {Strength}로 증가했습니다!");
}
protected override int GetDefense()
{
// 전사는 방어력이 더 높음
return Level * 3;
}
public override void Attack(GameCharacter target)
{
int damage = Strength + Level * 3;
if (IsRaging)
{
damage = (int)(damage * 1.5);
IsRaging = false;
Console.WriteLine($"{Name}의 분노가 가라앉았습니다.");
}
Console.WriteLine($"{Name}이(가) 검으로 {target.Name}을(를) 공격합니다. 기본 데미지: {damage}");
target.TakeDamage(damage);
}
public override void SpecialAbility()
{
if (!IsRaging)
{
IsRaging = true;
Console.WriteLine($"{Name}이(가) 분노합니다! 다음 공격의 데미지가 50% 증가합니다.");
}
else
{
Console.WriteLine($"{Name}은(는) 이미 분노 상태입니다.");
}
}
public override string GetCharacterType()
{
return "전사";
}
}
// 마법사 클래스
public class Wizard : GameCharacter, IMagicUser
{
public int Intelligence { get; private set; }
public int ManaPoints { get; private set; }
public int MaxManaPoints { get; private set; }
public Wizard(string name, int level) : base(name, level)
{
Intelligence = 10 + level * 3;
MaxManaPoints = 50 + level * 10;
ManaPoints = MaxManaPoints;
}
protected override int CalculateMaxHealth()
{
// 마법사는 체력이 적음
return 80 + (Level * 8);
}
protected override void OnLevelUp()
{
base.OnLevelUp();
Intelligence += 3;
MaxManaPoints += 10;
ManaPoints = MaxManaPoints;
Console.WriteLine($"지능이 {Intelligence}로, 최대 마나가 {MaxManaPoints}로 증가했습니다!");
}
public override void Attack(GameCharacter target)
{
int damage = Intelligence + Level * 2;
Console.WriteLine($"{Name}이(가) 지팡이로 {target.Name}을(를) 공격합니다. 기본 데미지: {damage}");
target.TakeDamage(damage);
}
public void CastSpell(string spellName, GameCharacter target)
{
int manaCost;
int damage;
switch (spellName.ToLower())
{
case "fireball":
manaCost = 20;
damage = Intelligence * 2 + Level * 5;
break;
case "ice spike":
manaCost = 15;
damage = Intelligence * 1.5 + Level * 4;
break;
case "lightning":
manaCost = 30;
damage = Intelligence * 3 + Level * 6;
break;
default:
Console.WriteLine($"{Name}은(는) {spellName} 주문을 알지 못합니다.");
return;
}
if (ManaPoints >= manaCost)
{
ManaPoints -= manaCost;
Console.WriteLine($"{Name}이(가) {spellName} 주문을 시전합니다! 마나 {manaCost} 소모. 남은 마나: {ManaPoints}/{MaxManaPoints}");
Console.WriteLine($"{target.Name}에게 {damage}의 마법 데미지를 입혔습니다!");
target.TakeDamage(damage);
}
else
{
Console.WriteLine($"{Name}의 마나가 부족합니다! 필요 마나: {manaCost}, 현재 마나: {ManaPoints}");
}
}
public void RegenerateMana(int amount)
{
int previousMana = ManaPoints;
ManaPoints = Math.Min(MaxManaPoints, ManaPoints + amount);
int actualRegen = ManaPoints - previousMana;
Console.WriteLine($"{Name}이(가) {actualRegen}의 마나를 회복했습니다. 현재 마나: {ManaPoints}/{MaxManaPoints}");
}
public override void SpecialAbility()
{
int healAmount = Intelligence + Level * 3;
Console.WriteLine($"{Name}이(가) 자신을 치유합니다.");
Heal(healAmount);
int manaRegen = Intelligence / 2;
RegenerateMana(manaRegen);
}
public override string GetCharacterType()
{
return "마법사";
}
}
// 궁수 클래스
public class Archer : GameCharacter, IRangedAttacker
{
public int Dexterity { get; private set; }
public int Range { get; private set; }
public int ArrowCount { get; private set; }
public Archer(string name, int level) : base(name, level)
{
Dexterity = 10 + level * 3;
Range = 10 + level;
ArrowCount = 20;
}
protected override int CalculateMaxHealth()
{
// 궁수는 중간 정도의 체력
return 90 + (Level * 10);
}
protected override void OnLevelUp()
{
base.OnLevelUp();
Dexterity += 3;
Range += 1;
Console.WriteLine($"민첩이 {Dexterity}로, 사거리가 {Range}로 증가했습니다!");
}
public override void Attack(GameCharacter target)
{
if (ArrowCount > 0)
{
int damage = Dexterity + Level * 2;
ArrowCount--;
Console.WriteLine($"{Name}이(가) 활로 {target.Name}을(를) 공격합니다. 기본 데미지: {damage}, 남은 화살: {ArrowCount}");
target.TakeDamage(damage);
}
else
{
int damage = Level * 2;
Console.WriteLine($"{Name}의 화살이 떨어져 맨손으로 공격합니다. 기본 데미지: {damage}");
target.TakeDamage(damage);
}
}
public void RangedAttack(GameCharacter target, int distance)
{
if (ArrowCount <= 0)
{
Console.WriteLine($"{Name}의 화살이 떨어졌습니다!");
return;
}
if (distance > Range)
{
Console.WriteLine($"대상이 사거리({Range}m) 밖에 있습니다! 현재 거리: {distance}m");
return;
}
ArrowCount--;
// 거리가 가까울수록 데미지 증가
double distanceFactor = 1.0 + (1.0 - (double)distance / Range);
int damage = (int)((Dexterity + Level * 2) * distanceFactor);
Console.WriteLine($"{Name}이(가) {distance}m 거리에서 {target.Name}을(를) 저격합니다. 데미지: {damage}, 남은 화살: {ArrowCount}");
target.TakeDamage(damage);
}
public void CollectArrows(int count)
{
ArrowCount += count;
Console.WriteLine($"{Name}이(가) {count}개의 화살을 주웠습니다. 현재 화살: {ArrowCount}개");
}
public override void SpecialAbility()
{
Console.WriteLine($"{Name}이(가) 연속 사격을 시전합니다!");
if (ArrowCount >= 3)
{
int totalDamage = 0;
for (int i = 0; i < 3; i++)
{
int damage = (int)(Dexterity * 0.7) + Level;
totalDamage += damage;
}
ArrowCount -= 3;
Console.WriteLine($"{Name}이(가) 3발의 화살을 연속으로 발사하여 총 {totalDamage}의 데미지를 입힐 수 있습니다. 남은 화살: {ArrowCount}");
}
else
{
Console.WriteLine($"연속 사격을 위한 화살이 부족합니다! 필요: 3개, 현재: {ArrowCount}개");
}
}
public override string GetCharacterType()
{
return "궁수";
}
}
4. 게임 시스템 사용 예제
// 게임 캐릭터 생성
Warrior warrior = new Warrior("아서", 5);
Wizard wizard = new Wizard("메를린", 5);
Archer archer = new Archer("로빈", 5);
// 다형성을 활용한 캐릭터 목록
List<GameCharacter> characters = new List<GameCharacter> { warrior, wizard, archer };
// 모든 캐릭터 정보 출력
Console.WriteLine("=== 게임 캐릭터 정보 ===");
foreach (var character in characters)
{
Console.WriteLine($"이름: {character.Name}, 타입: {character.GetCharacterType()}, 체력: {character.Health}");
}
Console.WriteLine("\n=== 전투 시작 ===");
// 전사의 공격
warrior.Attack(archer);
// 마법사의 주문 시전
wizard.CastSpell("fireball", warrior);
// 궁수의 원거리 공격
archer.RangedAttack(wizard, 8);
Console.WriteLine("\n=== 특수 능력 사용 ===");
// 각 캐릭터의 특수 능력 사용
foreach (var character in characters)
{
Console.WriteLine($"\n{character.Name}의 특수 능력:");
character.SpecialAbility();
}
// 다시 공격
Console.WriteLine("\n=== 두 번째 라운드 ===");
warrior.Attack(wizard); // 분노 상태에서의 공격
// 레벨업
Console.WriteLine("\n=== 레벨업 ===");
foreach (var character in characters)
{
character.LevelUp();
}
위 예제에서 볼 수 있듯이, 상속과 다형성을 활용하면 다양한 캐릭터 타입을 효과적으로 구현할 수 있어. 각 캐릭터는 공통된 기능을 GameCharacter 추상 클래스에서 상속받으면서, 자신만의 고유한 특성과 행동을 가지고 있지.
또한 인터페이스를 통해 특정 능력(마법 사용, 원거리 공격)을 필요한 클래스에만 추가할 수 있어. 이렇게 하면 코드 재사용성을 높이면서도 각 캐릭터의 특성을 명확하게 표현할 수 있어.
🔑 이 예제에서 사용된 객체지향 원칙들
- 상속: 모든 캐릭터가
GameCharacter클래스를 상속 - 다형성: 같은 메서드(
Attack,SpecialAbility등)가 각 캐릭터 타입에 따라 다르게 동작 - 추상화:
GameCharacter는 추상 클래스로, 공통 기능을 정의하면서 일부 메서드는 자식 클래스에서 구현하도록 함 - 인터페이스:
IMagicUser,IRangedAttacker인터페이스를 통해 특정 능력을 가진 캐릭터를 정의 - 캡슐화: 속성들은 적절한 접근 제한자를 사용하여 보호됨
이런 방식으로 코드를 구성하면 나중에 새로운 캐릭터 타입(예: 도적, 성직자 등)을 추가하기도 쉬워져. 기존 코드를 수정하지 않고도 새로운 클래스를 추가하기만 하면 되니까! 이것이 바로 객체지향 프로그래밍의 확장성이야. 😊
7. 상속과 다형성의 모범 사례와 주의점 ⚠️
상속과 다형성은 강력한 도구지만, 잘못 사용하면 오히려 코드를 복잡하게 만들 수 있어. 여기서는 상속과 다형성을 사용할 때의 모범 사례와 주의해야 할 점들을 알아보자!
👍 모범 사례
1. 'is-a' 관계에만 상속 사용하기
상속은 'is-a'(~이다) 관계일 때만 사용해야 해. 예를 들어, '자동차는 차량이다'는 상속에 적합하지만, '자동차는 엔진을 가지고 있다'는 상속보다는 컴포지션(composition)이 더 적합해.
// 좋은 예: is-a 관계
public class Vehicle { ... }
public class Car : Vehicle { ... } // 자동차는 차량이다
// 나쁜 예: has-a 관계를 상속으로 표현
public class Engine { ... }
public class Car : Engine { ... } // 자동차는 엔진이 아니라, 엔진을 가지고 있다
// 좋은 예: has-a 관계는 컴포지션으로 표현
public class Car
{
private Engine engine; // 자동차는 엔진을 가지고 있다
public Car(Engine engine)
{
this.engine = engine;
}
}
2. 리스코프 치환 원칙(LSP) 준수하기
자식 클래스는 부모 클래스를 대체할 수 있어야 해. 즉, 부모 클래스 타입의 변수에 자식 클래스의 인스턴스를 할당해도 프로그램이 정상적으로 동작해야 해.
// 좋은 예: LSP 준수
public class Bird
{
public virtual void Eat() { ... }
}
public class Sparrow : Bird
{
public override void Eat() { ... } // 기본 동작 유지
}
// 나쁜 예: LSP 위반
public class Bird
{
public virtual void Fly() { ... }
}
public class Penguin : Bird
{
public override void Fly()
{
throw new NotSupportedException("펭귄은 날 수 없습니다."); // 기본 동작 변경
}
}
3. 상속 계층을 너무 깊게 만들지 않기
상속 계층이 너무 깊어지면 코드를 이해하고 유지보수하기 어려워져. 일반적으로 3~4단계 이상의 상속은 피하는 것이 좋아.
// 나쁜 예: 너무 깊은 상속 계층
public class Animal { ... }
public class Mammal : Animal { ... }
public class Carnivore : Mammal { ... }
public class Feline : Carnivore { ... }
public class BigCat : Feline { ... }
public class Tiger : BigCat { ... } // 너무 깊은 상속 계층
// 좋은 예: 더 평평한 계층 구조
public class Animal { ... }
public class Mammal : Animal { ... }
public class Tiger : Mammal { ... } // 더 단순한 계층 구조
4. 인터페이스 분리 원칙(ISP) 적용하기
큰 인터페이스보다는 작고 특화된 여러 인터페이스를 사용하는 것이 좋아. 클래스는 자신이 사용하지 않는 메서드에 의존하지 않아야 해.
// 나쁜 예: 너무 큰 인터페이스
public interface IWorker
{
void Work();
void Eat();
void Sleep();
}
// 좋은 예: 분리된 인터페이스
public interface IWorkable
{
void Work();
}
public interface IEatable
{
void Eat();
}
public interface ISleepable
{
void Sleep();
}
// 필요한 인터페이스만 구현
public class Human : IWorkable, IEatable, ISleepable
{
public void Work() { ... }
public void Eat() { ... }
public void Sleep() { ... }
}
public class Robot : IWorkable // 로봇은 일만 함
{
public void Work() { ... }
}
5. 다형성을 위한 가상 메서드 사용하기
다형성을 활용하려면 오버라이드할 메서드를 virtual로 선언해야 해. 그렇지 않으면 런타임 다형성이 동작하지 않아.
// 나쁜 예: virtual 키워드 없음
public class Shape
{
public double CalculateArea() // virtual 키워드 없음
{
return 0;
}
}
public class Circle : Shape
{
public double Radius { get; set; }
public new double CalculateArea() // 오버라이드가 아닌 숨김(hiding)
{
return Math.PI * Radius * Radius;
}
}
// 다형성이 동작하지 않음
Shape circle = new Circle { Radius = 5 };
double area = circle.CalculateArea(); // 결과: 0 (Shape의 메서드가 호출됨)
// 좋은 예: virtual과 override 사용
public class Shape
{
public virtual double CalculateArea() // virtual 키워드 사용
{
return 0;
}
}
public class Circle : Shape
{
public double Radius { get; set; }
public override double CalculateArea() // override 키워드 사용
{
return Math.PI * Radius * Radius;
}
}
// 다형성이 정상 동작
Shape circle = new Circle { Radius = 5 };
double area = circle.CalculateArea(); // 결과: 78.54... (Circle의 메서드가 호출됨)
⚠️ 주의해야 할 점
1. 상속보다 컴포지션을 우선 고려하기
"상속보다 컴포지션을 선호하라"는 객체지향 설계의 중요한 원칙이야. 상속은 강한 결합을 만들어 유연성을 떨어뜨릴 수 있어.
// 상속 대신 컴포지션 사용 예
// 상속 방식
public class Stack : ArrayList // ArrayList의 모든 기능을 상속받음
{
// 불필요한 메서드들도 모두 노출됨
}
// 컴포지션 방식
public class Stack
{
private ArrayList list = new ArrayList(); // ArrayList를 내부에 포함
public void Push(object item)
{
list.Add(item);
}
public object Pop()
{
object item = list[list.Count - 1];
list.RemoveAt(list.Count - 1);
return item;
}
// 필요한 기능만 노출
}
2. 부모 클래스의 구현에 너무 의존하지 않기
자식 클래스가 부모 클래스의 구현 세부사항에 너무 의존하면 취약한 기반 클래스 문제가 발생할 수 있어. 부모 클래스가 변경되면 자식 클래스가 예상치 못하게 영향을 받을 수 있어.
// 나쁜 예: 부모 클래스 구현에 의존
public class Parent
{
protected int counter = 0;
public virtual void DoSomething()
{
counter++;
// 다른 작업...
}
}
public class Child : Parent
{
public override void DoSomething()
{
// counter가 특정 방식으로 증가한다고 가정
base.DoSomething();
Console.WriteLine($"Counter: {counter}");
}
}
// 만약 Parent 클래스에서 counter 증가 방식이 변경되면 Child 클래스가 영향을 받음
3. 상속을 위한 설계가 아니면 sealed 클래스 사용하기
상속을 위해 특별히 설계되지 않은 클래스는 sealed로 선언하는 것이 좋아. 이렇게 하면 의도하지 않은 상속으로 인한 문제를 방지할 수 있어.
// 상속을 위해 설계되지 않은 클래스
public sealed class CreditCardProcessor
{
// 상속을 고려하지 않고 설계된 클래스
// sealed로 선언하여 상속 방지
}
4. 생성자에서 가상 메서드 호출 피하기
부모 클래스의 생성자에서 가상 메서드를 호출하면 예상치 못한 동작이 발생할 수 있어. 자식 클래스의 생성자가 아직 실행되지 않은 상태에서 자식 클래스의 오버라이드된 메서드가 호출될 수 있기 때문이야.
// 나쁜 예: 생성자에서 가상 메서드 호출
public class Parent
{
public Parent()
{
Initialize(); // 가상 메서드를 생성자에서 호출
}
protected virtual void Initialize()
{
Console.WriteLine("Parent initialization");
}
}
public class Child : Parent
{
private string name;
public Child(string name)
{
this.name = name; // 이 시점에서는 아직 name이 초기화되지 않음
}
protected override void Initialize()
{
Console.WriteLine($"Child initialization: {name}"); // name이 null일 수 있음
}
}
// Child 객체 생성 시 출력:
// Child initialization: null
// (Parent 생성자가 먼저 실행되어 Initialize()를 호출하지만, 이 시점에서 Child의 name은 아직 초기화되지 않음)
5. 다중 상속의 한계 이해하기
C#은 클래스의 다중 상속을 지원하지 않아. 이 제한을 이해하고 인터페이스를 활용하는 방법을 익혀야 해.
// 다중 상속 대신 인터페이스 활용
public class Animal { ... }
public interface ISwimmable
{
void Swim();
}
public interface IFlyable
{
void Fly();
}
// 다중 상속 대신 인터페이스 구현
public class Duck : Animal, ISwimmable, IFlyable
{
public void Swim() { ... }
public void Fly() { ... }
}
상속과 다형성은 객체지향 프로그래밍의 강력한 도구지만, 적절하게 사용하는 것이 중요해. 재능넷에서 프로그래밍 프로젝트를 진행할 때 이런 원칙들을 염두에 두면, 더 유지보수하기 쉽고 확장성 있는 코드를 작성할 수 있을 거야! 🚀
8. 마무리 및 다음 단계 🎯
지금까지 C#의 상속과 다형성에 대해 깊이 있게 알아봤어! 이 개념들은 객체지향 프로그래밍의 핵심이며, 잘 활용하면 코드의 재사용성, 유지보수성, 확장성을 크게 향상시킬 수 있어. 😊
📋 배운 내용 요약
- 상속: 기존 클래스의 특성을 새로운 클래스가 물려받는 메커니즘
- 다형성: 같은 인터페이스나 메서드가 다양한 형태로 동작할 수 있는 능력
- 오버라이딩 vs 오버로딩: 메서드 재정의와 다양한 매개변수로 같은 이름의 메서드 정의하기
- 추상 클래스와 인터페이스: 상속과 다형성을 더 효과적으로 활용하기 위한 도구
- 모범 사례와 주의점: 상속과 다형성을 올바르게 사용하는 방법
이제 이 개념들을 실제 프로젝트에 적용해보면서 더 깊이 이해하는 것이 중요해. 코딩은 이론보다 실전에서 더 많이 배울 수 있으니까! 🚀
프로그래밍 실력을 더 향상시키고 싶다면, 재능넷에서 C# 관련 강의나 프로젝트를 찾아보는 것도 좋은 방법이야. 다른 개발자들의 코드를 보고 배우거나, 자신의 프로젝트를 공유하면서 피드백을 받을 수 있어! 🌟
💪 계속해서 코딩하고 배우자!
프로그래밍은 끊임없이 배우고 성장하는 여정이야. 오늘 배운 상속과 다형성 개념을 실제 프로젝트에 적용해보면서 더 깊이 이해해보자. 어려움이 있더라도 포기하지 말고 계속 도전해봐! 모든 프로그래머가 처음에는 초보자였으니까. 😊
질문이나 도움이 필요하면 재능넷 커뮤니티에서 다른 개발자들과 소통해보는 것도 좋은 방법이야. 함께 배우고 성장하는 즐거움을 느껴보자!
이 글이 C#의 상속과 다형성을 이해하는 데 도움이 되었길 바라! 다음에 또 다른 흥미로운 프로그래밍 주제로 만나자! 👋
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.