C# - 인터페이스 (Interface)

인터페이스 (Interface)

클래스나 구조체가 반드시 구현해야하는 메서드와 프로퍼티의 규약을 정의하는 요소다.

즉 특정 기능 구현을 강제하는 역할이다.

얼핏 추상 클래스와 비슷한 역할처럼 보이지만 일반 필드는 가질 수 없고 메서드 시그니쳐와 자동 구현 프로퍼티만 선언할 수 있다는 차이점이 있다.

 

interface IInteractable // 인터페이스 인터페이스명
{
    void Interact(); // 반드시 구현되어야 할 메서드로 구성
    // 필드는 가질 수 없음
    int MyNum { get; set; } // 프로퍼티는 됨. 프로퍼티는 메서드 취급
}

 

이렇게 간단하게 구현할 수 있다.

이렇게 인터페이스를 구현한 클래스는 Interact() 메서드와 MyNum 프로퍼티를 반드시 정의해야 한다.

또 하나의 특징으로는 인터페이스란 것을 명시하기 위해 앞에 대문자 I를 붙이는 것이 관례다.

 

 

예시 코드를 통해 조금 더 알아보자.

using System;

namespace Generic
{
    // “운전 가능한 것”이라는 규약
    interface IDrivable
    {
        void Drive();
        int DriveSpeed { get; set; }
    }

    // 기본 Vehicle 클래스
    class Vehicle
    {
        protected int x;
    }

    // Plane 클래스는 Vehicle을 상속 + IDrivable 인터페이스 구현
    class Plane : Vehicle, IDrivable
    {
        float x;
        float y;

        public int DriveSpeed { get; set; }

        public void Drive()
        {
            Console.WriteLine("활주로를 달립니다.");
        }

        public void Fly()
        {
            Console.WriteLine("비행기 발사!");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IDrivable myPlane = new Plane();
            myPlane.Drive();
            Console.WriteLine($"속도: {myPlane.DriveSpeed}");
        }
    }
}

 

여기서 몇가지 핵심 포인트가 있다.

 

• 클래스 상속은 1개만 가능하지만, 인터페이스는 여러 개 동시에 구현 가능하다.
• 따라서 Plane은 Vehicle을 상속받으면서, 동시에 IDrivable 규약을 만족시킬 수 있다.
• 실제 프로그램에서는 IDrivable 인터페이스를 구현하는 여러 타입(자동차, 비행기, 배 등)을 동일한 규약으로 다룰 수 있다.

 

또한 클래스와 달리 여러개의 인터페이스를 상속받는 것도 가능하다.

interface IFlyable
{
    void Fly();
}

interface IDrivable
{
    void Drive();
}

interface ITransformable : IFlyable, IDrivable
{
    void Transform();
}

 

 

 

---

 

인터페이스 vs 추상 클래스

인터페이스와 추상 클래스는 매우 유사해 보이기 때문에 실제 면접에서도 단골 질문이라 하니 핵심 차이점을 잘 알아두자.

	인터페이스 (Interface)	추상 클래스 (Abstract Class)
다중 구현	여러 개 구현 가능	단일 상속만 가능
멤버	메서드, 프로퍼티만 가능	필드, 생성자, 구현 메서드도 가능
접근 제한자	항상 public	public / protected 등 자유롭게 설정 가능
목적	“규약(약속)” 정의	“공통 뼈대 + 일부 구현” 제공

 

공통점 : 인스턴스화 불가, 반드시 상속/구현해야 사용 가능

차이점 : 인터페이스는 규약, 추상 클래스는 뼈대 + 기본 구현

 

 

프로퍼티는 멤버변수가 아니라 메소드와 비슷한 취급을 하기에 가능한 것.

 

using Delegate;
using System;

namespace Delegate
{
    interface GooglePlay
    {
        void SetId();
    }

    // 제네릭으로 바꾸면
    class GooglePhone<T> where T: IAndroid
    {
        T phone; // 여기에 안드로이드 폰들만 들어가게 하고싶음
    }

    interface IAndroid
    {
        string GoogleID { get; set; }
    }

    class Galaxy : IAndroid
    {
        public string GoogleID { get; set; }

        public void SetId()
        {
            Console.WriteLine("ㅎㅇ");
        }
    }

    class Iphone { }
    class Pixel : IAndroid
    {
        public string GoogleID { get; set; }
    }
    class Motorola : IAndroid
    {
        public string GoogleID { get; set; }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            // 이렇게 인터페이스로 IAndroid 돼있는 녀석들만 구글폰 제네릭에 넣도록 강제할 수 있음
            GooglePhone<Galaxy> phone = new GooglePhone<Galaxy>();
            //GooglePhone<Iphone> phone = new GooglePhone<Iphone>(); 
        }
    }
}