인터페이스

클래스들을 효율적으로 사용하고 동일한 목적으로 사용하게끔 하는 기능이다. 즉, 다형성을 위해 사용한다고 생각하면 된다.

다형성이란? 누가 구현하나에 따라 결과가 달라지는 것

public interface Comparable {

}

와 같이 인터페이스를 선언하고

public class MyStrcmp implements Comparable {

}

implements 된 곳에서 만든 인터페이스를 사용 할 수 있다.
개념만 들었을 땐 어떤 느낌인지 잘 이해가 되지 않았는데
예제를 풀어보면 이해하기 쉽다.

인터페이스를 이용하여 게임 구현하기

시작 ---> 1차 전직 ---> 2차 전직
모험가 ---> 전사 ------> 워 로드
---> 도적 ------> 어쌔신
---> 마법사 ------> 위자드
각각의 캐릭터들은 공격 스킬을 두 개씩 가지고 있다.
전직을 할 때마다 추가적인 전직 스킬 두 개를 얻게 된다.
스킬을 사용할 때 모두가 일관되게
skill1(), skill2() 형식으로
데미지가 계산되도록 만들어보자

인터페이스

가장 먼저 공통으로 사용할 스킬을 인터페이스로 만든다.

public interface Skill {

    public void Skill1();
    public void Skill2();

}

각 캐릭터별로 클래스를 만들어 준다.

모험가

캐릭터들 마다 개별적인 스킬이 있기 때문에
Skill 인터페이스를 사용한다.

public class Adventurer implements Skill {

    int attack;
    int defense;
    int experience;

    public Adventurer(int attack, int defense, int experience) {
        this.attack = attack;
        this.defense = defense;
        this.experience = experience;
    }

    @Override
    public void Skill1() {
        System.out.println("때리기: " + attack);
    }

    @Override
    public void Skill2() {
        System.out.println("막기: " + defense);
    }
}

전사

시작 > 1차전직 > 2차 전직을
상속으로 연결하면 자식이 부모의 속성을 가지게 된다.

public class Warrior extends Adventurer {

    int hammer;

    public Warrior(int attack, int defense, int experience, int hammer) {
        super(attack, defense, experience);
        this.hammer = hammer;
    }

    @Override
    public void Skill1() {
        System.out.println("망치공격: " + hammer + (attack * 10));
    }

    @Override
    public void Skill2() {
        System.out.println("망치 던지기: " + hammer * 2);
    }
    
    public subSkill1(){
    	super.skill1();
    }
    
    public subSkill2(){
    	super.skill2();
    }
    
}

워로드

public class WarLoad extends Warrior {

    int fire;

    public WarLoad(int attack, int defense, int experience, int hammer, int fire) {
        super(attack, defense, experience, hammer);
        this.fire = fire;
    }

    @Override
    public void Skill1() {
        System.out.println("파이어불릿: " + fire + (attack * 50));
    }

    @Override
    public void Skill2() {
        System.out.println("차지 스팅거: " + experience + 30);
    }

}

도적

public class Thief extends Adventurer {

    int ax;

    public Thief(int attack, int defense, int experience, int ax) {
        super(attack, defense, experience);
        this.ax = ax;
    }

    @Override
    public void Skill1() {
        System.out.println("도끼공격: " + ax + (attack * 15));
    }

    @Override
    public void Skill2() {
        System.out.println("훔치기: " + defense * 10);
        System.out.println("상대방을 한 턴 쉬게 할 수 있습니다.");
    }
}

어쌔신

public class Assassin extends Thief {
    int kick;

    public Assassin(int attack, int defense, int experience, int ax, int kick) {

        super(attack, defense, experience, ax);
        this.kick = kick;
    }

    @Override
    public void Skill1() {
        System.out.println("발차기: " + kick + (attack * 40));
    }

    @Override
    public void Skill2() {
        System.out.println("할퀴기: " + defense * 50);
    }

}

마법사

public class Mage extends Adventurer {
    int magic;

    public Mage(int attack, int defense, int experience, int magic) {
        super(attack, defense, experience);
        this.magic = magic;
    }

    @Override
    public void Skill1() {
        System.out.println("기초 마법: " + (magic * 2) + (attack * 10));
    }

    @Override
    public void Skill2() {
        System.out.println("시공간 정지: " + defense + 70);
    }
}

위자드

public class Wizard extends Mage {

    int fantasrtic;

    public Wizard(int attack, int defense, int experience, int magic, int fantasrtic) {
        super(attack, defense, experience, magic);
        this.fantasrtic = fantasrtic;
    }

    @Override
    public void Skill1() {
        System.out.println("고급 마법: " + fantasrtic + (attack * 30));
    }

    @Override
    public void Skill2() {
        System.out.println("날기: " + magic * 30);
    }

}

게임시작

무한반복을 통해 그래픽이 없는 오토 게임이 완성된다.

public class Game {
    public static void main(String[] args) {
        Adventurer adventurer = new Adventurer(10, 10, 10);
        Warrior warrior = new Warrior(30, 15, 30, 30);
        WarLoad warLoad = new WarLoad(40, 40, 30, 35, 20);
        Thief thief = new Thief(20, 40, 40, 30);
        Assassin assassin = new Assassin(50, 45, 40, 35, 25);
        Mage mage = new Mage(25, 20, 20, 10);
        Wizard wizard = new Wizard(30, 30, 40, 30, 15);

        for (;;) {
            adventurer.Skill1();
            adventurer.Skill2();

            warrior.Skill1();
            warrior.Skill2();

            warLoad.Skill1();
            warLoad.Skill2();

            thief.Skill1();
            thief.Skill2();

            assassin.Skill1();
            assassin.Skill2();

            mage.Skill1();
            mage.Skill2();

            wizard.Skill1();
            wizard.Skill2();
        }

    }
}

결과
날기: 900
때리기: 10
막기: 10
망치공격: 30300
망치 던지기: 60
파이어불릿: 202000
(무한반복)

각 클래스마다 새로운 skill을 만들었다면 해당 스킬이 무엇인지 기억을 하고 사용해야 했겠지만, 인터페이스를 활용하였기 때문에 간단하게 skill을 사용할 수 있다. 이것이 바로 다형성을 가지는 인터페이스의 장점이다.