인터페이스

// 안좋은 예시
Player player = new Player("용사", 42);
Settings settings = new Settings(0.8, true);
Inventory inventory = new Inventory(17);

player.Save();
settings.Save();
inventory.Save();

class Player
{
    public string Name;
    public int Level;

    public Player(string name, int level)
    {
        Name = name;
        Level = level;
    }

    public void Save()
    {
        Console.WriteLine($"플레이어 저장 — {Name} Lv.{Level}");
    }
}

class Settings
{
    public double Volume;
    public bool FullScreen;

    public Settings(double volume, bool fullScreen)
    {
        Volume = volume;
        FullScreen = fullScreen;
    }

    public void Save()
    {
        Console.WriteLine($"설정 저장 — 음량 {Volume}, 전체화면 {FullScreen}");
    }
}

class Inventory
{
    public int ItemCount;

    public Inventory(int itemCount)
    {
        ItemCount = itemCount;
    }

    public void Save()
    {
        Console.WriteLine($"인벤토리 저장 — 아이템 {ItemCount}개");
    }
}

interface ISavable
{
    void Save();
}

// 기존에 여러줄 늘어놓아야 했던 것과 다르게 인터페이스로 foreach문 하나로 줄인 예시
ISavable[] targets = { new Player("용사", 42), new Settings(0.8, true) };

foreach (ISavable target in targets)
{
    target.Save();
}

interface ISavable
{
    void Save();
}

class Player : ISavable
{
    public string Name;
    public int Level;

    public Player(string name, int level)
    {
        Name = name;
        Level = level;
    }

    public void Save()
    {
        Console.WriteLine($"플레이어 저장 — {Name} Lv.{Level}");
    }
}

class Settings : ISavable
{
    public double Volume;
    public bool FullScreen;

    public Settings(double volume, bool fullScreen)
    {
        Volume = volume;
        FullScreen = fullScreen;
    }

    public void Save()
    {
        Console.WriteLine($"설정 저장 — 음량 {Volume}, 전체화면 {FullScreen}");
    }
}

// 다중 인터페이스 예시
Hero hero = new Hero();
hero.Move(3);
hero.Attack();

Turret turret = new Turret();
turret.Attack();

Crate crate = new Crate();
crate.Move(1);

interface IMovable
{
    void Move(int distance);
}

interface IAttacker
{
    void Attack();
}

// 이동도 공격도 함
class Hero : IMovable, IAttacker
{
    public void Move(int distance)
    {
        Console.WriteLine($"영웅이 {distance}칸 이동");
    }

    public void Attack()
    {
        Console.WriteLine("영웅이 검을 휘두름");
    }
}

// 공격만 함
class Turret : IAttacker
{
    public void Attack()
    {
        Console.WriteLine("포탑이 발사");
    }
}

// 이동만 함
class Crate : IMovable
{
    public void Move(int distance)
    {
        Console.WriteLine($"상자가 {distance}칸 밀림");
    }
}

// 상속과 인터페이스를 함께 쓰는 예시
class Animal
{
    public string Name;

    public Animal(string name)
    {
        Name = name;
    }

    public void Breathe()
    {
        Console.WriteLine($"{Name}이(가) 숨을 쉼");
    }
}

interface IFlyable
{
    void Fly();
}

// 부모 클래스가 먼저, 인터페이스가 뒤
class Bird : Animal, IFlyable
{
    public Bird(string name) : base(name) { }

    public void Fly()
    {
        Console.WriteLine($"{Name}이(가) 날아감");
    }
}

// 메서드 하나로 두개의 인터페이스를 모두 만족시키는 예시
interface IEngine
{
    void Run();
}

interface IProgram
{
    void Run();
}

class Robot : IEngine, IProgram
{
    // 하나의 Run() 이 두 인터페이스를 모두 만족시킴
    public void Run()
    {
        Console.WriteLine("작동");
    }
}

// 이름이 같지만 동작이 서로 다른 인터페이스를 구현하는 예시
Robot robot = new Robot();

IEngine engine = robot;
engine.Run();

IProgram program = robot;
program.Run();

// 캐스팅해서 바로 부르는 것도 됨
((IEngine)robot).Run();

interface IEngine
{
    void Run();
}

interface IProgram
{
    void Run();
}

class Robot : IEngine, IProgram
{
    // 인터페이스 이름을 앞에 붙임 — public 을 쓰지 않음
    void IEngine.Run()
    {
        Console.WriteLine("엔진이 돌아감");
    }

    void IProgram.Run()
    {
        Console.WriteLine("프로그램이 실행됨");
    }
}

//하나의 인터페이스를 받는 함수로 해당 인터페이스를 구현한 여러개의 클래스를 입력받는 예시
Report(new ConsoleLogger(), "게임 시작");
Report(new PrefixLogger("[경고] "), "체력 부족");
Report(new CountingLogger(), "저장");

void Report(ILogger logger, string message)
{
    logger.Write(message);
}

interface ILogger
{
    void Write(string message);
}

class ConsoleLogger : ILogger
{
    public void Write(string message)
    {
        Console.WriteLine(message);
    }
}

class PrefixLogger : ILogger
{
    private string prefix;

    public PrefixLogger(string prefix)
    {
        this.prefix = prefix;
    }

    public void Write(string message)
    {
        Console.WriteLine(prefix + message);
    }
}

class CountingLogger : ILogger
{
    private int count;

    public void Write(string message)
    {
        count++;
        Console.WriteLine($"{count}. {message}");
    }
}

// 생성자 매개변수를 인터페이스로 두고 생성할 때 결정하는 예시
Car sportsCar = new Car("스포츠카", new TurboEngine());
sportsCar.Start();

Car cityCar = new Car("경차", new EcoEngine());
cityCar.Start();

interface IEngine
{
    string Name { get; }
    int GetPower();
}

class TurboEngine : IEngine
{
    public string Name => "터보 엔진";

    public int GetPower()
    {
        return 350;
    }
}

class EcoEngine : IEngine
{
    public string Name => "절전 엔진";

    public int GetPower()
    {
        return 90;
    }
}

class Car
{
    private string model;
    private IEngine engine;

    // 어떤 엔진을 쓸지 밖에서 넣어 줌
    public Car(string model, IEngine engine)
    {
        this.model = model;
        this.engine = engine;
    }

    public void Start()
    {
        Console.WriteLine($"{model} — {engine.Name} {engine.GetPower()}마력으로 출발");
    }
}

// 추상클래스와 인터페이스를 함께 사용하는 예시
// 능력별 인터페이스
interface IAttackable
{
    void Attack();
}

interface IReloadable
{
    void Reload();
}

// 공통 데이터와 구현은 추상 클래스가 맡음
abstract class Weapon
{
    protected int durability = 100;

    public abstract void Attack();

    public void ShowDurability()
    {
        Console.WriteLine($"  내구도 {durability}");
    }
}

// 추상 클래스 상속 + 인터페이스 구현
class Sword : Weapon, IAttackable
{
    public override void Attack()
    {
        durability -= 5;
        Console.WriteLine("검으로 베기");
    }
}

class Bow : Weapon, IAttackable, IReloadable
{
    private int arrows = 3;

    public override void Attack()
    {
        arrows--;
        durability -= 2;
        Console.WriteLine($"화살 발사 (남은 화살 {arrows})");
    }

    public void Reload()
    {
        arrows = 10;
        Console.WriteLine("화살을 채움");
    }
}

// 추상클래스에 인터페이스를 선언하고 자식이 될 클래스에 구현을 맡기는 예시
interface IShape
{
    double GetArea();
    void Describe();
}

abstract class ShapeBase : IShape
{
    // 인터페이스 멤버를 추상으로 남김 — 자식이 채움
    public abstract double GetArea();

    // 인터페이스 멤버를 여기서 구현 — 모든 자식이 공유함
    public void Describe()
    {
        Console.WriteLine($"{GetType().Name} 면적 {GetArea():F2}");
    }
}

class Square : ShapeBase
{
    private double side;

    public Square(double side)
    {
        this.side = side;
    }

    public override double GetArea()
    {
        return side * side;
    }
}

class Circle : ShapeBase
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public override double GetArea()
    {
        return Math.PI * radius * radius;
    }
}