상속과 다형성

상속

자식 클래스를 만들 때 상위 클래스의 속성과 기능을 물려받아 계승
상위 클래스의 프로퍼티와 메서드가 자식에 적용됨
하위 클래스에서 새로운 메서드를 추가하여 확장할 수 있다.

코틀린의 모든 클래스는 묵시적으로 Any로부터 상속

선언

open class 기반 클래스 명  //open으로 파생 가능 ( 다른 클래스가 상속 가능한 상태가 됨)
{
	...
}

class 파생 클래스명 : 기빈 클래스명() // 기반 클래스로부터 상속, 최종 클래스로 파생 불가 
{
	...
}

BirdChildClasses.kt

// 상속 가능한 클래스를 위해 open 사용
open class Bird(var name : String, var wing : Int, var beak : String)
{
	// 부모 클래스에 있는 메서드
    fun fly() = println("Fly wing : $wing")
    fun sing(vol : Int) = println("sing vol : $vol")
}

// 주 생성자를 사용한 상속
class Lark(name: String, wing: Int, beak: String, ) : Bird(name, wing, beak)
{
	// 새로 추가된 메서드
    fun singHitone() = println("Happy Song")
}

// 부 생성자를 사용하는 상속
class Parrot : Bird
{
    val language : String  //새로 추가한 프로퍼티
    constructor(name: String, wing: Int, beak: String, language : String) : super(name, wing, beak)
    {
        this.language = language  // 새로 추가한 프로퍼티를 초기화하기
    }
    fun speak() = println("Speak! $language")
}

---

다형성

같은 이름을 사용하지만 구현 내용이 다르거나 매개변수가 달라서 하난의 이름으로 다양한 기능을 수행할 수 있는 개념이다.

오버라이딩(overriding)

주로 상속 받은 부모 클래스의 정보(프로퍼티)나 행위(메소드)를 재설계한다.

open class Bird(var name : String, var wing : Int, var beak : String)
{
    fun fly() = println("Fly wing : $wing")
    //오버라이딩 가능한 메서드
    open fun sing(vol : Int) = println("sing vol : $vol")
}

class Parrot(name: String, wing: Int, beak: String, var language: String = "natural") : Bird(name, wing, beak)
{
	//Parrot에 추가된 메서드
    fun speak() = println("Speak! $language")
    //오버라이딩된 메서드
    override fun sing(vol: Int)
    {
        println("I'm a parrot! The volume level is $vol")
        speak()
    }
}

fun main()
{
    val parrot = Parrot("myparrot", 2, "multiple")
    parrot.language = "English"
    println("Parrot : ${parrot.name}, ${parrot.wing}, ${parrot.color}, ${parrot.language}")
    parrot.sing(5)
}

//결과 
Parrot : myparrot, 2, multiple, English
I'm a parrot! The volume level is 5
Speak! English

오버로딩(overloading)

매개변수의 갯수 혹은 자료형을 다르게하면서 동일한 이름으로 메소드를 만들고 싶을 때 사용한다.

fun main()
{
    val calc = Calc()
    println(calc.add(3, 2))
    println(calc.add(3.2, 2.3))
    println(calc.add(3, 2, 1))
    println(calc.add("Hello", "World"))

}

class Calc
{
    fun add(x : Int, y : Int) : Int = x + y
    fun add(x : Double, y : Double) : Double = x + y
    fun add(x : Int, y : Int, z : Int) : Int = x + y + z
    fun add(x : String, y : String) : String = x + y
}

//결과 
5
5.5
6
HelloWorld

final 키워드를 사용해서 상속을 금지하거나, 메서드나 프로퍼티를 오버라이드할 수 없도록 만들 수 있다.

open class Bird 
{
    open fun sing() 
    {
        println("Bird is singing")
    }
}

//open 키워드를 사용하여 Lark 클래스를 확장 가능하도록 만든다면 
//Lark 클래스는 다른 클래스들에 의해 상속될 수 있다. 
open class Lark() : Bird()
{
    final override fun sing() 
    {
        println("Lark is singing")
    }
}