C#의 객체지향 프로그래밍 개념 이해하기 🚀

안녕하세요, 여러분! 오늘은 C#의 객체지향 프로그래밍(OOP) 개념에 대해 알아볼 거예요. 어렵게 들릴 수 있지만, 걱정 마세요! 우리 함께 재미있게 배워볼게요. 😉

객체지향 프로그래밍이라고 하면 뭔가 어려워 보이죠? 하지만 실제로는 우리 일상생활과 꽤 비슷해요. 마치 레고 블록을 조립하는 것처럼 프로그램을 만드는 방식이라고 생각하면 돼요. 각각의 블록이 객체가 되는 거죠!

자, 그럼 이제부터 C#의 OOP 세계로 들어가볼까요? 준비되셨나요? 레츠고~! 🏃‍♂️💨

1. 클래스 (Class) - 객체의 설계도 📝

클래스는 뭘까요? 쉽게 말해서 객체를 만들기 위한 '설계도'예요. 마치 집을 지을 때 설계도가 필요한 것처럼, 객체를 만들 때도 설계도가 필요하죠. 그게 바로 클래스예요!

예를 들어볼까요? '자동차'라는 클래스를 만든다고 생각해봐요.


public class Car
{
    public string Brand;
    public string Model;
    public int Year;

    public void StartEngine()
    {
        Console.WriteLine("부릉부릉! 🚗💨");
    }
}

이렇게 클래스를 만들면, 이제 우리는 다양한 자동차 객체를 만들 수 있어요. 마치 하나의 설계도로 여러 대의 자동차를 만들 수 있는 것처럼요!

클래스 안에는 두 가지 주요 요소가 있어요:

필드(Fields): 객체의 특성을 나타내요. 위 예시에서 Brand, Model, Year가 필드예요.
메서드(Methods): 객체가 할 수 있는 행동을 나타내요. StartEngine() 메서드가 그 예시죠.

재능넷에서 프로그래밍 강의를 들어본 적 있나요? 거기서도 이런 개념들을 다루더라고요. 역시 실력자들이 많이 모이는 곳이에요! 😎

2. 객체 (Object) - 클래스의 실체화 🎭

자, 이제 클래스를 만들었으니 객체를 만들어볼까요? 객체는 클래스를 바탕으로 실제로 메모리에 할당된 실체를 말해요. 쉽게 말해서, 클래스라는 설계도를 가지고 실제로 만들어진 '물건'이에요.

우리가 만든 Car 클래스로 객체를 만들어볼게요:


Car myCar = new Car();
myCar.Brand = "현대";
myCar.Model = "아이오닉 5";
myCar.Year = 2023;

myCar.StartEngine(); // 출력: 부릉부릉! 🚗💨

짜잔~ 이렇게 우리는 'myCar'라는 객체를 만들었어요. 이 객체는 Car 클래스의 모든 특성과 기능을 가지고 있죠. 마치 설계도를 바탕으로 실제 자동차를 만든 것과 같아요!

객체를 만드는 과정을 '인스턴스화'라고 해요. new 키워드를 사용해서 객체를 만들 때마다, 우리는 클래스의 새로운 '인스턴스'를 만드는 거예요.

🚨 주의사항: 객체를 만들 때는 항상 new 키워드를 사용해야 해요. 그렇지 않으면 객체가 아니라 그냥 '참조'만 만들어지고, 실제로 사용할 수 없어요!

이렇게 객체를 만들면, 우리는 그 객체의 필드에 접근하거나 메서드를 호출할 수 있어요. 점(.) 연산자를 사용해서 말이죠:


Console.WriteLine($"내 차는 {myCar.Brand} {myCar.Model}이에요!");
myCar.StartEngine();

이런 식으로 객체를 사용하면, 실제 세계의 물건처럼 다룰 수 있어요. 멋지지 않나요? 😊

3. 캡슐화 (Encapsulation) - 정보 은닉의 마법 🎩✨

자, 이제 객체지향 프로그래밍의 첫 번째 핵심 개념인 '캡슐화'에 대해 알아볼게요. 캡슐화는 뭘까요? 쉽게 말해서, 관련된 데이터와 기능을 하나로 묶고, 외부에서 직접 접근하지 못하게 숨기는 것을 말해요.

왜 이렇게 할까요? 그 이유는 바로...

데이터의 보안을 강화하기 위해서
코드의 복잡성을 줄이기 위해서
유지보수를 쉽게 하기 위해서

C#에서는 접근 제한자(Access Modifier)를 사용해서 캡슐화를 구현해요. 주로 사용되는 접근 제한자는 다음과 같아요:

public: 누구나 접근 가능
private: 같은 클래스 내에서만 접근 가능
protected: 같은 클래스와 자식 클래스에서 접근 가능
internal: 같은 어셈블리 내에서만 접근 가능

우리의 Car 클래스를 캡슐화해볼까요?


public class Car
{
    private string brand;
    private string model;
    private int year;

    public string GetBrand()
    {
        return brand;
    }

    public void SetBrand(string value)
    {
        if (string.IsNullOrEmpty(value))
        {
            throw new ArgumentException("브랜드명은 비어있을 수 없어요!");
        }
        brand = value;
    }

    // model과 year에 대한 getter와 setter도 비슷하게 구현할 수 있어요.

    public void StartEngine()
    {
        Console.WriteLine("부릉부릉! 🚗💨");
    }
}

이렇게 하면 brand, model, year 필드는 private으로 선언되어 외부에서 직접 접근할 수 없어요. 대신 GetBrand()와 SetBrand() 메서드를 통해 간접적으로 접근할 수 있죠.

이런 방식으로 구현하면 어떤 장점이 있을까요?

데이터의 유효성을 검사할 수 있어요. (SetBrand 메서드에서 빈 문자열 체크)
내부 구현을 변경해도 외부 코드에 영향을 주지 않아요.
읽기 전용이나 쓰기 전용 속성을 만들 수 있어요.

C#에서는 이런 getter와 setter를 더 간단하게 구현할 수 있는 '프로퍼티(Property)'라는 기능도 제공해요. 한번 볼까요?


public class Car
{
    private string brand;
    public string Brand
    {
        get { return brand; }
        set 
        { 
            if (string.IsNullOrEmpty(value))
                throw new ArgumentException("브랜드명은 비어있을 수 없어요!");
            brand = value;
        }
    }

    // 자동 구현 프로퍼티
    public string Model { get; set; }
    public int Year { get; set; }

    public void StartEngine()
    {
        Console.WriteLine("부릉부릉! 🚗💨");
    }
}

이렇게 하면 외부에서는 마치 public 필드처럼 사용할 수 있지만, 내부적으로는 캡슐화된 상태를 유지할 수 있어요. 진짜 개발자 같아지는 느낌이죠? ㅋㅋㅋ 😎

캡슐화는 마치 우리가 자동차를 운전할 때와 비슷해요. 우리는 자동차의 내부 구조를 모르더라도 핸들, 브레이크, 액셀 등을 통해 자동차를 조작할 수 있죠. 이처럼 프로그래밍에서도 객체의 내부 구현은 숨기고, 필요한 인터페이스만 제공하는 거예요. cool하지 않나요? 😎

4. 상속 (Inheritance) - 유전자를 물려받는 클래스들 👨‍👩‍👧‍👦

이제 객체지향 프로그래밍의 두 번째 핵심 개념인 '상속'에 대해 알아볼게요. 상속이 뭘까요? 실제 세상에서 부모가 자식에게 특성을 물려주는 것처럼, 프로그래밍에서도 한 클래스가 다른 클래스의 특성을 물려받을 수 있어요. 이걸 '상속'이라고 해요.

상속을 사용하면 어떤 장점이 있을까요?

코드 재사용성이 높아져요.
관련된 클래스들을 체계적으로 구성할 수 있어요.
유지보수가 쉬워져요.

C#에서는 ':'를 사용해서 상속을 구현해요. 한번 예를 들어볼게요:


public class Vehicle
{
    public string Brand { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    public virtual void StartEngine()
    {
        Console.WriteLine("엔진 시동!");
    }
}

public class Car : Vehicle
{
    public int NumberOfDoors { get; set; }

    public override void StartEngine()
    {
        base.StartEngine();
        Console.WriteLine("부릉부릉! 🚗💨");
    }

    public void Honk()
    {
        Console.WriteLine("빵빵! 📢");
    }
}

public class Motorcycle : Vehicle
{
    public bool HasSidecar { get; set; }

    public override void StartEngine()
    {
        base.StartEngine();
        Console.WriteLine("부르르릉! 🏍️💨");
    }

    public void Wheelie()
    {
        Console.WriteLine("앞바퀴 들고 달리기! 🏍️");
    }
}

여기서 Vehicle은 '부모 클래스' 또는 '기본 클래스'라고 불러요. Car와 Motorcycle은 Vehicle을 상속받은 '자식 클래스' 또는 '파생 클래스'예요.

이렇게 상속을 사용하면, Car와 Motorcycle 클래스는 Vehicle 클래스의 모든 public 및 protected 멤버를 사용할 수 있어요. 게다가 자신만의 고유한 특성도 추가할 수 있죠.

💡 Tip: C#에서는 다중 상속을 지원하지 않아요. 즉, 한 클래스가 여러 클래스를 동시에 상속받을 수 없어요. 대신 인터페이스를 사용해서 비슷한 효과를 낼 수 있답니다!

상속에서 중요한 개념 몇 가지를 더 알아볼까요?

virtual 키워드: 부모 클래스에서 이 키워드를 사용하면, 자식 클래스에서 해당 메서드를 재정의(override)할 수 있어요.
override 키워드: 자식 클래스에서 부모 클래스의 virtual 메서드를 재정의할 때 사용해요.
base 키워드: 자식 클래스에서 부모 클래스의 멤버에 접근할 때 사용해요.

이제 이 클래스들을 사용해볼까요?


Car myCar = new Car();
myCar.Brand = "현대";
myCar.Model = "아이오닉 5";
myCar.Year = 2023;
myCar.NumberOfDoors = 4;

myCar.StartEngine();  // 출력: 엔진 시동! 부릉부릉! 🚗💨
myCar.Honk();  // 출력: 빵빵! 📢

Motorcycle myBike = new Motorcycle();
myBike.Brand = "할리데이비슨";
myBike.Model = "스트리트 750";
myBike.Year = 2022;
myBike.HasSidecar = false;

myBike.StartEngine();  // 출력: 엔진 시동! 부르르릉! 🏍️💨
myBike.Wheelie();  // 출력: 앞바퀴 들고 달리기! 🏍️

이렇게 상속을 사용하면 코드 중복을 줄이고, 관련된 클래스들을 체계적으로 관리할 수 있어요. 마치 가족 관계도를 그리는 것 같죠? ㅋㅋㅋ 😄

상속은 재능넷에서 프로그래밍 강의를 들을 때도 자주 나오는 개념이에요. 실제 프로젝트에서도 많이 사용되는 중요한 개념이니 꼭 기억해두세요! 💪

5. 다형성 (Polymorphism) - 여러 가지 모습을 가진 메서드들 🎭

자, 이제 객체지향 프로그래밍의 세 번째 핵심 개념인 '다형성'에 대해 알아볼 차례예요. 다형성이라... 뭔가 어려워 보이죠? 하지만 걱정 마세요. 생각보다 쉬워요!

다형성이란 뭘까요? 간단히 말하면, '여러 가지 형태를 가질 수 있는 능력'이에요. 프로그래밍에서는 같은 이름의 메서드가 다른 기능을 할 수 있다는 뜻이죠.

다형성은 크게 두 가지로 나눌 수 있어요:

컴파일 타임 다형성 (오버로딩)
런타임 다형성 (오버라이딩)

5.1 컴파일 타임 다형성 (오버로딩)

오버로딩은 같은 이름의 메서드를 여러 개 만들 수 있게 해줘요. 단, 매개변수의 타입이나 개수가 달라야 해요. 예를 들어볼게요:


public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }

    public string Add(string a, string b)
    {
        return a + b;
    }
}

이렇게 하면 Add 메서드를 다양한 타입에 대해 사용할 수 있어요:


Calculator calc = new Calculator();
Console.WriteLine(calc.Add(5, 3));         // 출력: 8
Console.WriteLine(calc.Add(3.14, 2.86));   // 출력: 6
Console.WriteLine(calc.Add("Hello, ", "World!")); // 출력: Hello, World!

이게 바로 오버로딩이에요! 같은 이름의 메서드지만, 매개변수에 따라 다른 동작을 하죠. 꽤 편리하죠? 😉

5.2 런타임 다형성 (오버라이딩)

오버라이딩은 상속과 관련이 있어요. 부모 클래스의 메서드를 자식 클래스에서 재정의하는 거예요. 아까 봤던 Vehicle, Car, Motorcycle 예제를 다시 볼까요?


public class Vehicle
{
    public virtual void StartEngine()
    {
        Console.WriteLine("엔진 시동!");
    }
}

public class Car : Vehicle
{
    public override void StartEngine()
    {
        base.StartEngine();
        Console.WriteLine("부릉부릉! 🚗💨");
    }
}

public class Motorcycle : Vehicle
{
    public override void StartEngine()
    {
        base.StartEngine();
        Console.WriteLine("부르르릉! 🏍️💨");
    }
}

이제 이 클래스들을 사용해볼게요:


Vehicle myVehicle = new Vehicle();
Vehicle myCar = new Car();
Vehicle myMotorcycle = new Motorcycle();

myVehicle.StartEngine();     // 출력: 엔진   시동!
myCar.StartEngine();         // 출력: 엔진 시동! 부릉부릉! 🚗💨
myMotorcycle.StartEngine();  // 출력: 엔진 시동! 부르르릉! 🏍️💨

보세요! 같은 StartEngine() 메서드를 호출했지만, 각 객체의 실제 타입에 따라 다른 동작을 하고 있어요. 이게 바로 다형성의 힘이에요! 😎

🌟 Fun Fact: 다형성은 마치 변신 로봇 같아요. 겉으로 보기에는 같은 모습이지만, 상황에 따라 다른 능력을 발휘하죠. 프로그래밍에서의 다형성도 이와 비슷해요!

다형성의 장점은 뭘까요?

코드의 재사용성이 높아져요.
프로그램의 확장성이 좋아져요.
유지보수가 쉬워져요.

예를 들어, 우리가 새로운 종류의 차량(예: 비행기)을 추가하고 싶다면, Vehicle 클래스를 상속받아 새로운 클래스를 만들기만 하면 돼요. 기존의 코드는 전혀 건드리지 않아도 되죠!


public class Airplane : Vehicle
{
    public override void StartEngine()
    {
        base.StartEngine();
        Console.WriteLine("윙윙~ ✈️💨");
    }
}

// 사용 예
Vehicle myAirplane = new Airplane();
myAirplane.StartEngine();  // 출력: 엔진 시동! 윙윙~ ✈️💨

이렇게 다형성을 활용하면, 코드를 더 유연하고 확장 가능하게 만들 수 있어요. 마치 레고 블록처럼 새로운 기능을 쉽게 추가할 수 있는 거죠!

다형성은 객체지향 프로그래밍의 강력한 도구예요. 재능넷에서 프로그래밍을 배울 때도 이 개념이 자주 나오죠. 실제 프로젝트에서도 많이 사용되니, 꼭 잘 이해해두세요! 💪

6. 추상화 (Abstraction) - 복잡함을 단순하게! 🧩

마지막으로 알아볼 객체지향 프로그래밍의 핵심 개념은 '추상화'예요. 추상화란 뭘까요? 간단히 말하면, 복잡한 현실 세계의 개념을 단순화하여 프로그램으로 표현하는 것을 말해요.

추상화를 통해 우리는:

복잡한 시스템을 간단하게 표현할 수 있어요.
필요한 정보만 노출하고 불필요한 세부사항은 숨길 수 있어요.
코드의 재사용성과 유지보수성을 높일 수 있어요.

C#에서는 추상 클래스(abstract class)와 인터페이스(interface)를 통해 추상화를 구현할 수 있어요.

6.1 추상 클래스 (Abstract Class)

추상 클래스는 하나 이상의 추상 메서드를 포함하는 클래스예요. 추상 메서드는 선언만 있고 구현은 없는 메서드를 말해요. 추상 클래스는 직접 인스턴스화할 수 없고, 반드시 다른 클래스가 상속받아 구현해야 해요.


public abstract class Shape
{
    public abstract double CalculateArea();
    public abstract double CalculatePerimeter();

    public void DisplayInfo()
    {
        Console.WriteLine($"Area: {CalculateArea()}, Perimeter: {CalculatePerimeter()}");
    }
}

public class Circle : Shape
{
    public double Radius { get; set; }

    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 override double CalculateArea()
    {
        return Width * Height;
    }

    public override double CalculatePerimeter()
    {
        return 2 * (Width + Height);
    }
}

이렇게 하면 Shape라는 추상적인 개념을 만들고, 이를 구체화한 Circle과 Rectangle 클래스를 만들 수 있어요. 모든 도형은 넓이와 둘레를 계산할 수 있지만, 그 방법은 각 도형마다 다르죠?

6.2 인터페이스 (Interface)

인터페이스는 추상 클래스보다 더 추상화된 형태예요. 인터페이스는 모든 메서드가 추상 메서드이고, 필드를 가질 수 없어요. 클래스는 여러 인터페이스를 구현할 수 있어요.


public interface IDrawable
{
    void Draw();
}

public interface IResizable
{
    void Resize(double factor);
}

public class Circle : Shape, IDrawable, IResizable
{
    public double Radius { get; set; }

    // Shape의 추상 메서드 구현
    public override double CalculateArea() { ... }
    public override double CalculatePerimeter() { ... }

    // IDrawable 인터페이스 구현
    public void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }

    // IResizable 인터페이스 구현
    public void Resize(double factor)
    {
        Radius *= factor;
    }
}

이렇게 하면 Circle 클래스는 Shape를 상속받으면서 동시에 IDrawable과 IResizable 인터페이스를 구현하게 돼요. 다중 상속의 효과를 낼 수 있죠!

💡 Tip: 추상 클래스와 인터페이스 중 어떤 것을 사용할지 고민된다면, "is-a" 관계는 추상 클래스로, "can-do" 관계는 인터페이스로 구현하는 것이 좋아요.

추상화를 사용하면 어떤 장점이 있을까요?