Kotlin 코틀린의 추상클래스, 인터페이스 그리고 추상클래스 상속, 인터페이스 상속 예시 알아보기

기억해야 할 개념

• 추상클래스는 추상 메소드를 하나이상 포함하고 있는 클래스이다.
• 추상 클래스는 일반 메소드와 추상 메소드(최소 1개 이상) 모두 가질수 있다.
• 부모 추상 클래스 안에 있는 추상속성, 추상메소드는 반드시 자식 클래스에서 구현해야지 오류가 나지 않는다.
• 클래스는 다중 상속이 불가능하다.
• 인터페이스는 다중 상속이 가능하다.

---

fun main(args: Array<String>) {
    myPrinter.print() //출력값: myPrinter print}

abstract class Printer{ // 추상 클래스 : 추상 메소드를 하나이상 포함하고 있는 클래스
    abstract fun print() //추상 메소드
    fun method() = println("") //일반 메소드
}

val myPrinter = object : Printer(){ // 오브젝트를 하나만 만드는 것. 객체 생성
    override fun print() {
        println("myPrinter print")
    }

출력값

 

 

---

fun main(args: Array<String>) {

    val car = Car("SuperCar","yello",1100.0,300.0)
    val motor = MotorCycle("DreamBike","red",181.0,180.0)

    car.year ="2020"
    car.start()     //출력값 : >>자동차 출발<<
    car.stop()		//출력값 : >>자동차 정차<<

    motor.start()	//출력값 : >>바이크 출발<<
    motor.stop()	//출력값 : >>바이크 정차<<
    }

//추상 클래스는 일반 메소드와 추상 메소드(최소 1개 이상) 모두 가질수 있다.
abstract class Vehicle (val name:String, val color:String, val weight:Double){

    //abstract property 추상속성
    abstract var maxSpeed: Double

	//일반속성
    var year =  "2019"
	
    //추상메소드
    abstract fun start()
    abstract fun stop()

    //일반 메소드
    fun displaySpecs(){
        println("Name: $name, Color:$color, Weight:$weight, Year:$year, Max Speed:$maxSpeed")
    }
}

//maxSpeed는 추상속성이므로 반드시 재구현 혹은 override 해야한다.
class Car(name:String, color:String, weight:Double, override var maxSpeed: Double): 
Vehicle(name, color, weight){
    override fun start() {
        println(">>자동차 출발<<")
    }

    override fun stop() {
        println(">>자동차 정차<<")
    }
}


class MotorCycle(name:String, color:String, weight:Double, override var maxSpeed: Double) : 
Vehicle(name, color, weight){
    override fun start() {
        println(">>바이크 출발<<")
    }

    override fun stop() {
        println(">>바이크 정차<<")
    }

}

출력값

---

 

fun main(args: Array<String>) {

    var cf = createFoo(123)
    cf.bar = 234
    println(cf.method("hi")) //출력값: 234 hi
    
    }

 

인터페이스

interface Foo{
    val bar:Int //Interface가 아닌 Clasa면 에러나는 변수.
    fun method(qux:String) //함수
}

class createFoo(val _bar:Int) :Foo{ 
//인터페이스 Foo를 상속한 createFoo 클래스
//인터페이스는 추상 클래스와 달리 모든 속성과 메소드를 자식클래스가 상속해야 한다.
    override var bar: Int = _bar //bar의 값으로 매개변수로 들어온 정수 _bar를 오버라이드.


    override fun method(qux: String) {
        println("$bar $qux")

    }
}

출력값

---

fun main(args: Array<String>) {

    val pegasus = Pegasus()
    pegasus.fly() //출력값: i believe i can fly
    pegasus.run() // 출력값: and i can run
    pegasus.jump() /*출력값: Horse is jumping and max speed: 100
                            Pegasus is jumping*/


}

interface Bird{
    val wings:Int
    fun fly()
    fun jump(){
        println("Bird is jumping")
    }
}
interface Horse{
    val maxSpeed:Int
    fun run()
    fun jump(){
        println("Horse is jumping and max speed: $maxSpeed")
    }
}

class Pegasus: Bird, Horse{
    override val wings: Int =2
    override val maxSpeed: Int = 100

    override fun fly() {
     println("i believe i can fly")
    }

    override fun run() {
    println("and i can run")
    }

    override fun jump() {
      super<Horse>.jump()  
      println("Pegasus is jumping")
      //jump는 부모 인터페이스 Bird, Horse 둘 다에게 있는 메소드. 
      //부모 인터페이스를 구현하므로 super가 나온다.
      //제네릭<>으로 상위 타입을 정하지 않으면 에러가 뜬다.
	
    }

}

출력값