[코틀린] Abstract class와 Interface 차이점

 

🤔추상이란?

관념적이고 개념적이며 구체적의 반대말로 볼 수 있습니다.

예시로 사랑, 평화, 자유등이 있으며 

공통적인 특성을 묶는 것을 의미합니다.

📝추상클래스 (Abstract class)

추상 클래스란? 아예 없거나 하나 이상의 추상 메서드를 갖고 있는 클래스입니다.

추상 메서드란? 구현되지 않은, 재정의가 필요한 미완성 메서드입니다.

 

추상 클래스는 흔히 미완성 설계도라는 표현을 많이 사용하며

추상 클래스를 상속받은 자식 클래스에서 구체화가 됩니다.

 

상속받은 자식 클래스들은 모든 추상 메서드들을 오버라이딩 해주어야 하며

당연하게도 하위 클래스를 재정의 해야 하므로 private 키워드를 사용할 수 없습니다.

( Kotlin에서는 기본적으로 public 키워드를 갖습니다. )

 

추상 클래스와 추상 메소드는 abstract 키워드를 통해 선언을 합니다.

 

일반적인 클래스와 추상 클래스를 게임을 예시로 보여드리겠습니다.

 

class

class Warrior { // 워리어
    fun swing(){
        println("휘두르기")

    }
}

class Archer { // 아쳐
    fun push(){
        println("밀치기")

    }
}

class Wizard{ // 위자드
    fun magic(){
        println("약한 마법공격")

    }
}

 

위 예시 코드와 같이 워리어, 아쳐, 위자드는 각각 공격을 할 때 휘두르기, 밀치기, 약한 마법공격을 하게 된다고 가정해 봅시다..

 

그렇다면

Warrior, Archer, Wizard는 공통점이 있습니다. 바로 "직업"이라는 점입니다.

그리고 swing, push, magic 역시 공통점이 있습니다. 바로 "공격"이라는 공통점입니다.

 

 

이것을 추상 클래스로 묶게 된다면

 

Abstract class

abstract class Job{ // 추상 클래스, 직업
    abstract fun attack() // 추상 메소드, 일반공격
}

class Warrior: Job() { // Job을 상속
    override fun attack() { // attack()을 오버라이딩
        println("휘두르기")

    }
}

class Archer: Job(){ // Job을 상속
    override fun attack() { // attack()을 오버라이딩
        println("밀치기")

    }
}

class Wizard: Job(){ // Job을 상속
    override fun attack() { // attack()을 오버라이딩
        println("약한 마법공격")

    }
}

 

위 예시 코드처럼 각각의 전사, 아쳐, 위자드는 직업이라는 하나의 공통되는 특성이 있습니다.

 

각 클래스들의 공통되는 특성을 Job(직업)이라는 추상 클래스(abstract class)에 상속을 시키고

 

휘두르기, 밀치기, 약한 마법공격은 attack으로 하나로 묶으면서 오버라이딩을 시켜주었습니다.

 

 

📝인터페이스 (Interface)

인터페이스란? 추상 메서드로 이루어진 집합입니다.

 

인터페이스는 abstract 키워드를 사용하지 않습니다

 Q&A: 잠시만요 추상 메서드는 재정의가 필요한 메서드라면서요..?
- 맞습니다. 
다만, Java 8.0부터 인터페이스 안에 일반 메서드를 구현할 수 있게 되었습니다.
인터페이스에서 abstract 키워드를 사용하지 않는 이유기도 합니다.

 

인터페이스는 하나만 상속이 가능하던 추상클래스와 달리 다중 상속이 가능합니다.

또한 상속을 할 때 클래스는 소괄호()가 붙지만 인터페이스는 붙지 않아서 클래스와 구분이 가능합니다.

 

아래 예시 코드로 설명을 드리겠습니다.

 

Interface

abstract class Job{
    abstract fun attack()
}

interface Skill { // 인터페이스
    fun skill(){ // 추상 메소드

    }
}


class Warrior: Job() {
    override fun attack() {
        println("휘두르기")

    }
}

class Archer: Job(), Skill { // 추상 클래스와 인터페이스 상속
    override fun attack() {
        println("밀치기")

    }
    override fun skill() { // 추가된 스킬
    	println("에로우샷!")
    
	}
}

class Wizard: Job(), Skill { // 추상 클래스와 인터페이스 상속
    override fun attack() {
        println("약한 마법공격")

    }
    override fun skill() { // 추가된 스킬
        println("파이어볼!") 

    }
}

 

위 예시 코드를 보면서 가정을 해봅시다. 만약 워리어만 스킬이 없고 아쳐와 위자드만 스킬이 있다고 가정한다면?

 

위와 같이 쉼표 ( , )로 구분을 하여 Interface를 상속하고 skill을 오버라이딩 해주어

아쳐와 위자드에게만 스킬을 부여한 코드입니다.

 

만약 다중 상속까지 예시를 들게 된다면

abstract class Job{ 
    abstract fun attack()
}

interface Skill {
    fun skill(){

    }
}

interface Action { // 새로 추가된 인터페이스
    fun jump(){ // 점프

    }
    fun run(){ // 뛰기
        
    }
}

			// , (쉼표)로 다중상속
class Warrior: Job(), Skill, Action { // 추상 클래스에 Skill과 Action 인터페이스 추가 상속
    override fun attack() {
        println("휘두르기")

    }

    override fun skill() { // 추가 된 스킬
        println("파워 스크라이크!")
    }

    override fun run() { // 추가된 Action 인터페이스의 run 오버라이딩
        println("뛰기 시작합니다")
    }

    override fun jump() { // 추가된 Action 인터페이스의 jump 오버라이딩
        println("점프!")
    }
}

 

위 예시 코드처럼 워리어에 Skill(스킬)과 할 수 있는 Action(행동)이 추가하고 싶다면

쉼표로 구분을 하며 여러 개 다중 상속을 시킬 수 있습니다.