> **Keywords**: 인터페이스, 추상 클래스, 자바, 다중 상속, 유연성, 확장성, 디자인 원칙

# 인터페이스 사용을 선호하는 이유

## 들어가기 전에 알아야 할 내용

자바 프로그래밍에서 '인터페이스'와 '추상 클래스'는 다형성을 구현하는 중요한 도구입니다. 각 도구는 사용 방법과 적용 시점에 차이가 있는데, 이 차이를 이해하면 효과적인 코드 설계로 이어질 수 있습니다.

### 인터페이스와 추상 클래스의 차이

| 특징       | 인터페이스                              | 추상 클래스                           |
|----------|------------------------------------|-----------------------------------|
| 목적       | 클래스가 구현해야 할 계약 정의                | 공통 기능의 부분적 구현 제공                  |
| 메서드     | 추상 메서드와 디폴트 메서드, 스태틱 메서드      | 구현된 메서드와 추상 메서드                   |
| 상속       | 다중 구현 가능                             | 단일 상속만 가능                             |
| 다형성     | 높음                                    | 중간 정도                                   |
| 유연성     | 높음                                    | 중간 정도                                   |

## 왜 그래야 하는가?

### 단일 상속의 제약

추상 클래스의 단일 상속 제약은 코드 재사용을 제한한다. 예를 들어, `Bird` 클래스가 `Animal` 클래스를 상속받고 있을 때, `Flying` 기능을 추가로 상속받을 수 없다.

```java
abstract class Animal {
    abstract void eat();
}

abstract class Flying {
    abstract void fly();
}

class Bird extends Animal {
    @Override
    void eat() {
        // 구현
    }
}
```


### 코드 재사용성 문제

추상 클래스의 특정 메서드가 필요하지 않아도 상속받아야 한다는 점은 코드의 복잡성을 높일 수 있다.

```java
public abstract class Animal {
    void breathe() {
        // 기본 구현
    }
}

public class Fish extends Animal {
    // Fish에는 불필요한 breathe 메서드가 상속된다.
}

```

### 확장성과 유연성의 제한

추상 클래스는 미리 정의된 구조를 변경하지 않고서는 확장하기 어렵다. 이는 새로운 기능을 추가하거나 변경하는 것을 어렵게 만들며, 유지보수와 테스트의 복잡성을 높인다.



## 이래서 그렇다.

### 예시 1: 다중 기능의 필요성

`Bird` 클래스가 이미 `Animal` 클래스를 상속받고 있다고 가정한다면, '날기'와 '수영하기' 기능을 제공하는 추상 클래스를 추가로 상속받는 것은 불가능하다.

### 예시 2: 불필요한 메서드의 상속

추상 클래스 `Flying`에는 `fly`와 `land` 메서드가 포함되어 있다고 가정한다면, 특정 새가 `land`를 다르게 처리해야 하는 경우, `land` 메서드의 기본 구현은 사용되지 않거나 재정의되어야 한다.

### 예시 3: 확장성의 제한

공유 자전거 시스템을 설계할 때, 모든 자전거는 기본적인 기능을 공유하지만 일부는 GPS 추적 기능을 필요로 할 수 있다. 추상 클래스를 활용하면 유연성이 제한될 수 있다.

## 그렇다면 어떻게?

### 인터페이스의 다중 구현

인터페이스는 다중 구현을 지원한다. 예를 들어, `Bird` 클래스는 `Animal`을 상속받으면서 `Flyable`과 `Swimmable`을 구현할 수 있다.

```java
interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

class Bird extends Animal implements Flyable, Swimmable {
    @Override
    public void fly() {
        // 구현
    }

    @Override
    public void swim() {
        // 구현
    }
}

```

### 코드의 유연성과 모듈성 향상

인터페이스를 사용하면 `Bird` 클래스는 필요에 따라 인터페이스를 구현하거나, 새로운 행동을 추가할 때 쉽게 인터페이스를 구현할 수 있다.

### 동적인 기능 추가

인터페이스를 사용하면 특정 조건에서만 `Flyable` 기능을 `Bird` 객체에 추가할 수 있다.

### 설계의 일관성 유지

인터페이스를 통한 구현은 설계의 일관성을 유지하는 데 도움을 준다. 개발자는 기존 클래스 구조를 변경하지 않고도 새로운 기능을 추가하거나 기존 기능을 수정할 수 있다.

## 그렇게 한다면 뭐가 좋은가?

### 1. 유연성과 확장성의 증대

인터페이스를 통해 새로운 기능이 필요할 때 기존 클래스 구조를 변경하지 않고도 기능을 확장할 수 있다.

### 2. 향상된 테스트 용이성

인터페이스는 모의 구현(Mock Implementation)을 사용하여 실제 구현을 대체할 수 있도록 해 테스트 용이성을 높인다.

### 3. 더 나은 코드 관리와 유지보수

인터페이스를 구현하는 클래스의 내부 구현이 변경되더라도, 인터페이스 자체는 변경되지 않아 기존 코드는 영향을 받지 않는다.

### 4. 소프트웨어 설계 원칙의 적용

인터페이스 사용은 개방/폐쇄 원칙(Open/Closed Principle)과 인터페이스 분리 원칙(Interface Segregation Principle)을 준수하는 데 기여한다.

  

## 자세한 예시 (해결책을 도입한 자세한 예시)

  

인터페이스를 사용하여 문제를 해결하고 유연하고 확장 가능한 코드를 작성하는 구체적인 예시를 살펴보자. 아래는 자바에서 인터페이스를 활용하여 다양한 동물의 행동을 모델링하는 예시이다.

  

### 시나리오
다양한 동물들이 있고, 각각 다른 행동을 수행할 수 있다고 가정해보자. 예를 들어, 일부 동물은 날 수 있고, 일부는 수영할 수 있으며, 다른 일부는 지상에서 달릴 수 있다. 이러한 행동을 효율적으로 모델링하려면 각 행동을 별도의 인터페이스로 정의하고, 각 동물 클래스가 필요한 인터페이스를 구현하게 할 수 있다.

  
### 인터페이스 정의
```java

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

interface Runnable {
    void run();
}
```

### 동물 클래스 구현
```java
class Duck implements Flyable, Swimmable, Runnable {

    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    @Override
    public void run() {
        System.out.println("Duck is running");
    }
}

class Fish implements Swimmable {

    @Override
    public void swim() {
        System.out.println("Fish is swimming");
    }
}

class Horse implements Runnable {

    @Override
    public void run() {
        System.out.println("Horse is running");
    }
}
```

  

### 행동의 동적 추가
인터페이스를 사용하면 시스템의 요구사항이 변화함에 따라 새로운 행동을 쉽게 추가하거나 기존 행동을 수정할 수 있다. 예를 들어, 미래에 '점프'하는 기능이 필요하다면, 다음과 같이 `Jumpable` 인터페이스를 추가하고 관련 동물에 구현할 수 있다.

```java

interface Jumpable {
    void jump();
}

class Rabbit implements Runnable, Jumpable {

    @Override
    public void run() {
        System.out.println("Rabbit is running");
    }

    @Override
    public void jump() {
        System.out.println("Rabbit is jumping");
    }

}

```

  

### 예시의 이점

이 예시에서 각 동물은 자신의 특성에 맞게 여러 인터페이스를 구현하며, 각 인터페이스는 독립적으로 관리될 수 있다. 이 구조는 개발자가 시스템을 유연하게 확장하고, 특정 기능의 변경이 다른 부분에 영향을 미치지 않도록 하는데 도움을 준다. 또한, 코드의 재사용성과 유지보수성이 증가하며, 테스트가 용이해진다.  

이처럼 인터페이스를 활용하면 소프트웨어의 확장성, 유연성 및 유지보수성을 크게 향상시킬 수 있으며, 다양한 기능과 행동의 조합을 효과적으로 관리할 수 있다고 한다.

 > **추가적으로 학습 해볼 내용**
 > - 디폴트 메서드와 자바 인터페이스의 진화
 > - SOLID 디자인 원칙 중 인터페이스 분리 원칙(ISP)과 개방-폐쇄 원칙(OCP)의 적용
 > - 인터페이스와 추상 클래스 선택에 대한 더 깊은 논의