[C#] 인터페이스와 추상클래스

인터페이스를 상속받는 것과 클래스를 상속받는 것의 차이점

인터페이스를 상속받는 것 (Interface Inheritance)

인터페이스는 메서드 시그니처(이름, 매개변수, 반환 값)만 정의한다. 
클래스가 인터페이스를 상속받으면 해당 클래스는 인터페이스가 정의한 메서드들을 모두 구현해야 한다. (하나라도 구현되지 않으면 컴파일 에러가 난다.)
그리고 다중상속이 가능하다. (쉼표(,)로 이어쓰면 된다.)

interface IShape
{
    double CalculateArea();
}

class Circle : IShape
{
    double radius;

    public Circle(double r)
    {
        radius = r;
    }

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

class Square : IShape
{
    double side;

    public Square(double s)
    {
        side = s;
    }

    public double CalculateArea()
    {
        return side * side;
    }
}

class Program
{
    static void Main()
    {
        IShape circle = new Circle(5);
        IShape square = new Square(4);

        Console.WriteLine($"Circle Area: {circle.CalculateArea()}");
        Console.WriteLine($"Square Area: {square.CalculateArea()}");
    }
}

 

클래스를 상속받는 것 (Class Inheritance)

클래스 상속은 기존 클래스의 모든 멤버(필드, 메서드)와 동작을 상속받는 것이다.
상속된 클래스는 기존 클래스의 모든 기능과 동작을 그대로 사용할 수 있고, 오버라이딩을 통해 동작을 다르게 할 수도 있다.
인터페이스와 달리 클래스는 다중상속이 불가능하다. 기본적으로 하나의 클래스만 상속받을 수 있다.

using System;

class Vehicle
{
    public void StartEngine()
    {
        Console.WriteLine("Engine started");
    }

    public void StopEngine()
    {
        Console.WriteLine("Engine stopped");
    }
}

class Car : Vehicle
{
    public void Drive()
    {
        Console.WriteLine("Car is driving");
    }
}

class Program
{
    static void Main()
    {
        Car myCar = new Car();
        myCar.StartEngine();
        myCar.Drive();
        myCar.StopEngine();
    }
}

 

인터페이스를 상속하는 인터페이스를 만드는 이유

• 기존의 인터페이스를 재사용하면서 확장할 수 있다.
• 기존 소스 코드에 영향을 주지 않고 새로운 기능을 추가할 때, 인터페이스를 직접 수정하면 이 인터페이스를 상속하는 클래스들 전부에 컴파일 오류가 생긴다. 이 때 인터페이스를 상속하는 인터페이스를 사용하면 좋다.

using System;

interface IShape
{
    void Draw();
}

interface IResizableShape : IShape
{
    void Resize(int width, int height);
}

class Rectangle : IResizableShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a rectangle");
    }

    public void Resize(int width, int height)
    {
        Console.WriteLine($"Resizing rectangle to {width}x{height}");
    }
}

class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

class Program
{
    static void Main()
    {
        IResizableShape rectangle = new Rectangle();
        rectangle.Draw();
        rectangle.Resize(10, 5);

        IShape circle = new Circle();
        circle.Draw();
    }
}

위 코드를 설명하자면

• IShape 인터페이스: Draw 메서드 정의
• IResizableShape 인터페이스: IShape 인터페이스를 상속(Draw 메서드) + Resize 메서드 정의
• Rectangle 클래스: IResizableShape 인터페이스의 Draw 메서드, Resize 메서드 구현
• Circle 클래스: IShape 인터페이스의 Draw 메서드 구현

 

인터페이스의 기본 구현 메서드

인터페이스는 본래 메서드를 정의하기만 했지, 구현하지는 않았다. 그리고 인터페이스를 상속받은 클래스에서는 정의된 메서드를 모두 구현해야했다.
하지만 인터페이스에서 구현을 하게 되면, 클래서에서는 이 메서드들이 이미 구현이 되어있기 때문에 반드시 구현을 해야하는 문제가 없어진다. 그렇기 때문에 선택적 구현이 가능해진다.

using System;

public interface ICalculator
{
    int Add(int a, int b);

    // 기본 구현 메서드
    // 이 메서드를 오버라이드하지 않는 클래스는 이 기본 구현을 사용하게 됨
    int Subtract(int a, int b)
    {
        return a - b;
    }
}

public class BasicCalculator : ICalculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
    
    // Subtract 메서드를 오버라이드하지 않아도 됨
}

public class AdvancedCalculator : ICalculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    // 기본 구현 메서드를 오버라이드하여 고유한 동작을 정의함
    public int Subtract(int a, int b)
    {
        return Math.Abs(a - b);
    }
}

class Program
{
    static void Main()
    {
        ICalculator basicCalc = new BasicCalculator();
        ICalculator advancedCalc = new AdvancedCalculator();

        Console.WriteLine("Basic Calculator:");
        Console.WriteLine("Add: " + basicCalc.Add(5, 3));
        Console.WriteLine("Subtract: " + basicCalc.Subtract(10, 4));

        Console.WriteLine("\nAdvanced Calculator:");
        Console.WriteLine("Add: " + advancedCalc.Add(8, 2));
        Console.WriteLine("Subtract: " + advancedCalc.Subtract(4, 10));
    }
}

 

추상 클래스

추상 클래스도 인터페이스처럼 구현부가 없는 메서드를 가지고 있다. 이렇게 구현부가 없는 메서드를 추상메서드라고 한다. 추상클래스도 마찬가지로 상속받으면 이 추상 메서드들을 전부 구현을 해야한다.
인터페이스와의 차이점이라면, 추상 클래스는 구현부가 있는 일반 메서드도 포함할 수 있다. 즉, 추상 클래스는 하나 이상의 추상 메서드를 포함하기만 하면 된다. 그리고 클래스이기 때문에 다중상속이 안 된다.

*추상 메서드가 아닌 추상 프로퍼티를 하나만 포함하고 있어도 된다.

using System;

abstract class Shape
{
    public abstract double CalculateArea(); // 추상 메서드
}

class Circle : Shape
{
    private double radius;

    public Circle(double r)
    {
        radius = r;
    }

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

class Rectangle : Shape
{
    private double width;
    private double height;

    public Rectangle(double w, double h)
    {
        width = w;
        height = h;
    }

    public override double CalculateArea()
    {
        return width * height;
    }
}

class Program
{
    static void Main()
    {
        Circle circle = new Circle(5);
        Rectangle rectangle = new Rectangle(4, 6);

        Console.WriteLine("Circle Area: " + circle.CalculateArea());
        Console.WriteLine("Rectangle Area: " + rectangle.CalculateArea());
    }
}