🦈 자바 인터페이스 정리 🦈

interface

다른 클래스를 작성할 때 기본이 되는 틀을 제공
클래스 사이의 중간 매개 역할까지 담당하는 일종의 추상 클래스
자바에서 추상 클래스는 추상 메소드뿐만 아니라 생성자, 필드, 일반 메서드를 포함할 수 있다.

interface <interface_name> {
	
    public static final <value_type> <value_name> = <value>; // public abstract final 생략 가능
    
    public abstract <method_type> <method_name> (); // public abstract 생략 가능
    <method_type> <method_name> ();
}

interface 키워드 사용해 선언하며, 메서드의 정의만 명시한다.
모든 메서드는 public abstract이어야 하며, public static final과 public static 제어자는 생략하더라도 컴파일러가 컴파일할 때 자동으로 추가한다.
인터페이스 내에서 변수를 선언할 때에는 상수(final)만 정의할 수 있다.

---

그 자체로는 인스턴스를 생성할 수 없으며, 구현부를 만들어주는 클래스에 구현되어야 한다.

interface 붕어빵틀 {
	void make붕어빵();
}

public class 슈크림붕어빵 implements 붕어빵틀 {
	
    @Override
    public void make붕어빵() {
    	...code
    }
}

클래스는 implements 키워드를 통해 인터페이스를 구현할 수 있으며, 인터페이스 내에 명시된 메서드의 정의를 @Override로 상속받아 구현할 수 있다.

@Override 사용 이유
1. 컴파일러 체크 기능 : 컴파일러가 해당 어노테이션을 통해 부모 클래스/인터페이스의 메서드를 정확하게 재정의했는지 검사해 오류 발생 가능성을 줄임
2. 가독성 향상 : 부모의 메서드 재정의한 것이라는 정보를 명확히 전달
3. 리팩토링 안정성 : 부모 클래스의 메서드 정의가 변경된 경우 컴파일러가 문제 감시 및 수정하도록 지원해 오류 발생 가능성을 줄임

이때 해당 클래스는 인터페이스 내에 명시된 모든 추상 메서드를 구현해야 한다.
만약 모든 추상 메서드를 구현하지 않는다면 abstract 키워드를 사용해 추상 클래스로 선언해야 한다.

---

interface 붕어빵틀 {
	void make붕어빵();
}

public class 슈크림붕어빵 implements 붕어빵틀 {
	
    @Override
    public void make붕어빵() {
    	...code
    }
}

public class 팥붕어빵 implements 붕어빵틀 {
	
    @Override
    public void make붕어빵() {
    	...code
    }
}

또, 하나의 인터페이스를 여러 개의 클래스가 구현할 수 있다. (= 다중 구현)

---

interface 붕어빵틀 {
	void make붕어빵();
}

public class 붕어빵 {
	
    ...code
}

public class 슈크림붕어빵 extends implements 붕어빵틀 {
	
    @Override
    public void make붕어빵() {
    	...code
    }
}

클래스 상속과 인터페이스 구현은 동시에 가능하다.

---

다중 구현을 통해 여러 개의 공통적인 기능을 하는 인터페이스를 기반으로 다양한 클래스를 만들 수 있다.

예를 들면, 게임 내 캐릭터의 무기(weapon)는 여러 종류가 존재한다.
여기서 무기의 종류는 칼(knife), 총(gun), 주먹(fist)를 사용할 수 있다고 가정한다.

캐릭터는 유저가 원할 때 무기를 바꿀 수 있어야 한다.
또, 무기로 공격(attack)과 막기(defend)를 할 수 있다.

만약 인터페이스를 사용하지 않고 구현할 경우, 캐릭터는 모든 무기의 동작을 알고 있어야 한다.
또, 모든 무기의 종류를 변수나 enum으로 저장하고 있어야 하며, 무기에 따라 다른 동작을 하도록 구현해야 한다.

public class 캐릭터 {

	private String 무기모드;
    
    public void change무기(String 새로운무기) {
    	
        if (새로운무기.equals("주먹") {
        	무기모드 = "fist";	
            return;
        }
        if (새로운무기.equals("칼") {
        	무기모드 = "knife";
            return;
        }
        무기모드 = "gun";
        return;
	}

	public Integer attack() {
    	
        int damage = 1;
        
        if (무기모드.equals("gun")) {
        	damage = 10;
        }
        if (무기모드.equals("knife") {
        	damage = 5;
        }
        return damage;
    }
    
    public Integer defend() {
    	
        int damage = 1;
        
        if (무기모드.equals("gun")) {
        	damage = -10;
        }
        if (무기모드.equals("knife") {
        	damage = -5;
        }
        return damage;
    }
}   

이 경우 중복된 코드가 많아지고, 코드의 길이가 길어져 가독성이 떨어진다.
또, 새로운 무기를 추가할 경우 거의 모든 메서드를 수정해야 함으로 유지보수가 좋지 않다.

---

하지만 인터페이스를 사용해 구현할 경우, 공통된 기능(attack, defend 등)을 무기 인터페이스에 정의해두고, 각 무기 클래스에서 이를 자신만의 방식으로 구현함으로써 다형성(Polymorphism) 을 실현할 수 있다.

즉, 캐릭터 클래스는 무기가 총, 칼, 주먹 중 무기 인터페이스만을 바라보고 attack()이나 defend()를 호출할 수 있으며, 이러한 설계는 확장성과 유지보수 측면에서 매우 좋다.

interface 무기 {

	Integer attack();
    Integer defend();
}

무기 인터페이스는 attack과 defend 메서드의 정의를 명시할 수 있다.
인터페이스를 사용함으로써 공통된 기능을 중복해서 작성하지 않을 수 있다.

---

public class 총 implements 무기 {
    @Override
    public Integer attack() {
        return 10;
    }

    @Override
    public Integer defend() {
        return -10;
    }
}

public class 칼 implements 무기 {
    @Override
    public Integer attack() {
        return 5;
    }

    @Override
    public Integer defend() {
        return -5;
    }
}

public class 주먹 implements 무기 {
    @Override
    public Integer attack() {
        return 1;
    }

    @Override
    public Integer defend() {
        return -1;
    }
}

또, 칼, 총, 주먹를 클래스로 구현해 무기 인터페이스를 구현해 무기 마다 서로 다른 데미지를 주는 동작을 정의할 수 있다.

---

public class 냄비 implements 무기 {

	@Override
    public Integer attack() {
    	return 2;
    }

	@Override
    public Integer defend() {
    	return -2;
    }
}

새로운 무기를 추가하게 될 경우 클래스를 정의해 무기 인터페이스를 구현하면 된다.
따라서 기존 로직을 수정하지 않고 새로운 무기를 추가할 수 있게 됨으로써 유지보수가 좋아진다.

---

그 결과, 캐릭터는 하나의 인터페이스를 기반으로 다양한 무기를 가질 수 있게 된다.

public class 캐릭터 {
    private 무기 무기;

    public 캐릭터(무기 초기무기) {
        this.무기 = 초기무기;
    }

    public void change무기(무기 새로운무기) {
        this.무기 = 새로운무기; // 무기 변경
    }

    public void 공격() {
        System.out.println("공격력: " + 무기.attack());
    }

    public void 방어() {
        System.out.println("방어력: " + 무기.defend());
    }
}

public class Main {
    public static void main(String[] args) {
        캐릭터 나 = new 캐릭터(new 주먹());

        나.공격(); // 주먹 공격
        나.방어();

        나.change무기(new 칼());
        나.공격(); // 칼 공격
        나.방어();

        나.change무기(new 총());
        나.공격(); // 총 공격
        나.방어();
    }
}

캐릭터 클래스는 내부에 무기 인터페이스 타입의 변수 하나를 가지고 있으며, 생성자나 change무기() 메서드를 통해 무기를 교체할 수 있다.

'나'라는 캐릭터를 생성하면서 주먹 클래스를 무기로 설정한다. 이때 캐릭터의 무기는 주먹이며, 공격과 방어를 할 경우 각각 1과 -1의 데미지를 갖는다. 이후 새로운 무기로 칼이나 총을 선택할 경우, 해당 무기 클래스 내 메서드로 동작하게 되면서 서로 다른 데미지를 갖게 된다.

즉, 무기의 실제 구현체가 무엇이냐에 따라 attack()과 defend() 메서드의 출력 결과가 달라진다.

이는 자바의 다형성 개념을 활용한 것으로, 무기 타입으로 선언된 변수는 실제로 어떤 무기 객체가 사용되던지 유연하게 동작할 수 있다.

자바의 다형성
같은 자료형에 여러가지 타입의 데이터를 대입해 다양한 결과를 얻어낼 수 있는 성질
즉, 클래스가 상속 관계에 있을 때 나타나는 다채로운 성질이다.
대표적으로 오버로딩, 오버라이딩, 업캐스팅, 다운캐스팅, 인터페이스, 추상메서드, 추상클래스가 있다.

또, 해당 구조는 디자인 패턴 중 전략 패턴을 사용했다고 볼 수 있다.

전략 패턴
실행(런타임) 중 알고리즘 전략을 선택해 객체 동작이 실시간으로 바뀌도록 할 수 있게 하는 행위 디자인 패턴

---

장점

• 대규모 프로젝트 개발 시 일관되고 정형화된 개발을 위한 표준화 가능
• 클래스 작성과 인터페이스 구현을 동시에 진행함으로써 개발 시간 단축
• 클래스와 클래스 간 관계를 인터페이스로 연결함으로써 클래스마다 독립적인 프로그래밍 가능

참고-인터페이스
참고-인터페이스 의미
참고-다형성
참고-전략 패턴