C# 인터페이스와 열거형

using System;

// C# 인터페이스와 열거형

// 다중상속을 사용하지 않는 이유
// 1. 다중상속을 허용하면 어떤 부모클래스의 메서드를 호출해야할지 모호해진다.
// 2. 다중상속을 허용하면 클래스의 크기가 커지고 복잡해진다.
// 3. 다중상속을 허용하면 부모클래스의 변경이 자식클래스에 영향을 미치게 된다.

// 다이아몬드 문제
// 다중상속을 허용하면 다이아몬드 문제가 발생한다.
// 다이아몬드 문제는 다중상속을 허용하는 언어에서 발생하는 문제로, 다중상속을 허용하는 언어에서는
// 같은 부모클래스를 상속받는 두 개 이상의 클래스가 있을 때, 공통 부모클래스의 멤버를 중복으로 상속받는 문제를 말한다.

// 설계의 복잡성 증가
// 다중상속을 허용하면 클래스의 설계가 복잡해지고, 클래스 간의 관계가 복잡해진다.
// 다중상속을 허용하면 클래스 간의 관계가 복잡해지고, 클래스 간의 결합도가 높아지기 때문에 유지보수가 어려워진다.

// C#에서는 다중상속을 허용하지 않는 대신 인터페이스를 제공한다.
// 인터페이스는 클래스가 구현해야할 멤버를 정의하는 역할을 한다.
// 인터페이스는 클래스와 클래스 사이의 계약을 정의하는 것으로, 클래스가 인터페이스를 구현하면 인터페이스에서 정의한 멤버를 반드시 구현해야 한다.

// 인터페이스를 사용하는 이유
// 1. 다중상속을 허용하지 않는 C#에서 클래스가 여러 개의 인터페이스를 구현할 수 있도록 한다.
// 2. 인터페이스를 사용하면 클래스 간의 결합도를 낮출 수 있다.
// 3. 인터페이스를 사용하면 클래스 간의 관계를 명확하게 정의할 수 있다.
// 4. 인터페이스를 사용하면 클래스의 재사용성을 높일 수 있다.

// 인터페이스의 특징
// 1. 인터페이스는 클래스가 구현해야할 멤버를 정의하는 역할을 한다.
// 2. 인터페이스는 클래스와 클래스 사이의 계약을 정의하는 것으로, 클래스가 인터페이스를 구현하면 인터페이스에서 정의한 멤버를 반드시 구현해야 한다.
// 3. 인터페이스는 다중속성을 지원한다.

// 인터페이스 선언
// 인터페이스는 interface 키워드를 사용하여 선언한다.
// 인터페이스는 클래스와 마찬가지로 접근 제한자를 사용하여 접근 범위를 지정할 수 있다.
// 인터페이스는 클래스와 달리 멤버에 접근 제한자를 사용할 수 없다.
// 인터페이스는 멤버에 접근 제한자를 사용할 수 없기 때문에 인터페이스의 멤버는 자동적으로 public으로 선언된다.

// 인터페이스 구현
// 인터페이스를 구현하려면 클래스나 구조체에서 인터페이스를 상속받아야 한다.
// 클래스나 구조체에서 인터페이스를 상속받을 때는 콜론(:)을 사용하여 상속받을 인터페이스를 나열한다.
// 클래스나 구조체에서 인터페이스를 상속받으면 인터페이스에서 정의한 멤버를 반드시 구현해야 한다.

// 인터페이스의 멤버
// 인터페이스는 메서드, 속성, 인덱서, 이벤트를 정의할 수 있다.
// 인터페이스는 멤버에 접근 제한자를 사용할 수 없기 때문에 인터페이스의 멤버는 자동적으로 public으로 선언된다.

// 인터페이스의 멤버 정의하기
interface IMyInterface
{
    void Method1();
    int Method2(string str);
}

// 인터페이스 구현하기
class MyClass : IMyInterface
{
    public void Method1()
    {
        Console.WriteLine("Method1"); // 구현
    }

    public int Method2(string str)
    {
        Console.WriteLine("Method2 : " + str); // 구현
        return 0;
    }
}

// 사용 예제

// 1. 인터페이스 정의하기
interface IMovable
{
    void Move(int x, int y); // 이동 메서드 선언
}

// 2. 인터페이스 구현하는 클래스 생성하기
class Animal : IMovable
{
    public void Move(int x, int y) // 인터페이스의 메서드 구현
    {
        Console.WriteLine($"Animal : Move to ({x}, {y})"); // 동물 이동 구현
        // 출력 결과 : Animal : Move to (10, 20)
    }
}

class Person : IMovable
{
    public void Move(int x, int y) // 인터페이스의 메서드 구현
    {
        Console.WriteLine($"Person : Move to ({x}, {y})"); // 사람 이동 구현
        // 출력 결과 : Person : Move to (30, 40)
    }
}

// 3. 인터페이스를 사용하여 객체 이동하기
class InterfaceAndEnums
{
    static void MoveObject(IMovable movable, int x, int y)
    {
        movable.Move(x, y);
    }

    static void Main()
    {
        Animal animal = new Animal();
        Person person = new Person();

        MoveObject(animal, 10, 20); // 동물 이동
        MoveObject(person, 30, 40); // 사람 이동
    }
}

// 아이템 사용 구현 예제

// 1. 아이템 사용 인터페이스 정의하기
interface IUsable
{
    void Use();
}

// 2. 아이템 사용 인터페이스를 구현하는 클래스 생성하기
class Sword : IUsable
{
    public void Use() // 인터페이스의 메서드 구현
    {
        Console.WriteLine("Sword : Use"); // 검 사용 구현
    }
}

class Gun : IUsable
{
    public void Use() // 인터페이스의 메서드 구현
    {
        Console.WriteLine("Gun : Use"); // 총 사용 구현
    }
}

// 3. 플레이어 클래스 생성하기
class Player
{
    public void UseItem(IUsable usable)
    {
        usable.Use();
        // 출력 결과 : Sword : Use
        // 출력 결과 : Gun : Use
    }
}

// 4. 게임 실행하기

    // static void Main()
    // {
    //     Player player = new Player();
    //     Sword sword = new Sword();
    //     Gun gun = new Gun();

    //     player.UseItem(sword); // 검 사용
    //     player.UseItem(gun); // 총 사용
    // }

// 다중인터페이스 구현 예제

// 1. 다중인터페이스 정의하기
interface IRunnable
{
    void Run();
}

interface IFlyable
{
    void Fly(); 
}

// 2. 다중인터페이스를 구현하는 클래스 생성하기
class FlyingCar : IRunnable, IFlyable
{
    public void Run() // IRunnable 인터페이스의 메서드 구현
    {
        Console.WriteLine("FlyingCar : Run"); // 차량 이동 구현
        // 출력 결과 : FlyingCar : Run
    }

    public void Fly() // IFlyable 인터페이스의 메서드 구현
    {
        Console.WriteLine("FlyingCar : Fly"); // 차량 비행 구현
        // 출력 결과 : FlyingCar : Run
        // 출력 결과 : FlyingCar : Fly
    }
}

// 3. 게임 실행하기

    // static void Main()
    // {
    //     FlyingCar flyingCar = new FlyingCar();
    //     flyingCar.Run(); // 차량 이동
    //     flyingCar.Fly(); // 차량 비행
    // }


// 열거형(Enum)
// 열거형은 상수를 정의할 때 사용하는 데이터 형식으로, 상수를 정의할 때 사용하면 코드를 읽고 이해하기 쉽게 만들어준다. (가독성 향상)
// 열거형은 열거형을 정의할 때 사용하는 enum 키워드를 사용하여 정의한다.
// 자기문서화(Self-Documenting) : 코드를 읽고 이해하기 쉽게 만드는 것
// 스위치문(Switch Statement) : 열거형을 사용하면 스위치문을 사용할 때 코드를 읽고 이해하기 쉽게 만들어준다.

// 열거형 구현

// 1. 열거형 정의하기
enum Day
{
    Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
}

// 2. 열거형 사용하기
class EnumExample
{
    static void Main()
    {
        Day today = Day.Sunday; // 열거형 변수 선언
        Console.WriteLine(today); // 열거형 값 출력
        // 출력 결과 : Sunday
    }
}

// 3. 열거형 상수 값 지정
enum Day2
{
    Sunday = 0, Monday = 1, Tuesday = 2, Wednesday = 3, Thursday = 4, Friday = 5, Saturday = 6
}

// 4. 열거형 형 변환
class EnumExample2
{
    static void Main()
    {
        Day2 today = Day2.Sunday; // 열거형 변수 선언
        int day = (int)today; // 열거형을 정수로 변환
        Console.WriteLine(day); // 정수 값 출력
        // 출력 결과 : 0
    }
}

// 5. 스위치문과의 사용
    // switch(enumDays)
    // {
    //     case Day.Sunday:
    //         Console.WriteLine("Sunday");
    //         break;
    //     case Day.Monday:
    //         Console.WriteLine("Monday");
    //         break;
    //     case Day.Tuesday:
    //         Console.WriteLine("Tuesday");
    //         break;
    //     case Day.Wednesday:
    //         Console.WriteLine("Wednesday");
    //         break;
    //     case Day.Thursday:
    //         Console.WriteLine("Thursday");
    //         break;
    //     case Day.Friday:
    //         Console.WriteLine("Friday");
    //         break;
    //     case Day.Saturday:
    //         Console.WriteLine("Saturday");
    //         break;
    // }