ProgrammingLanguage

[Kotlin] 새차원의 코틀린 강좌(7)

kotlin

새차원의 코틀린 강좌 - Inheritance


상속
  • 코틀린의 최상위 클래스는 Any
  • 클래스에 상위타입을 선언하지 않으면 Any가 상속됨
1
2
class Example1         // 암시적인 Any 상속
class Example2 : Any() // 명시적인 Any 상속


  • Any는 java.lang.Object와는 다른 클래스

    • equals(), hashCode(), toString() 만 있음
1
2
3
4
5
6
package kotlin
public open class Any {
    public open operator fun equals(other: Any?): Boolean
    public open fun hashCode(): Int
    public open fun toString(): String
}


  • 명시적으로 상위 타입을 선언하려면, 클래스 헤더의 콜론(:) 뒤에 상위타입을 선언하면 됨
1
2
open class Base(p: Int)
class Derived(p: Int) : Base(p)


  • 파생클래스에 기본생성자가 있으면, 파생클래스의 기본생성자에서 상위타입의 생성자를 호출하여 초기화할 수 있음
  • 파생클래스에 기본생성자가 없으면, 각각의 보조생성자에서 상위타입을 super 키워드를 이용해 초기화해주어야 함.
  • 또는 다른 생성자에게 상위타입을 초기화할 수 있도록 위임해주어야 함.
1
2
3
4
5
6
7
class MyView : View {
    constructor() : super(1) // View 클래스의 생성자 호출

    constructor(ctx: Int) : this() // 첫번째 보조생성자 호출 (위임)

    constructor(ctx: Int, attrs: Int) : super(ctx, attrs)
}


  • open 어노테이션은 Java의 final과 반대임
  • open class는 다른 클래스가 상속할 수 있음
  • 기본적으로 코틀린의 모든 class는 final (상속 불가)
  • 이유는 : Effecive Java, Item 17 - Design and document for inheritance or else prohibit it.
1
2
open class Base(p: Int)
class Derived(p: Int) : Base(p)



메서드 오버라이딩
  • 오버라이딩 될 메서드 : open 어노테이션이 요구됨
  • 오버라이딩 된 메서드 : override 어노테이션이 요구됨
1
2
3
4
5
6
7
8
9
10
open class Base {
    open fun v() {}
    fun nv() {}
}

class Derived : Base() {
    fun v() { }             // 불가. override 키워드 필요
    override fun v() { }
    override fun nv() { }   // 불가
}



프로퍼티 오버라이딩
  • 메서드 오버라이딩과 유사한 방식으로 오버라이딩 가능
1
2
3
4
5
6
7
8
9
10
11
12
13
open class Foo {
    open val x: Int
        get() {
            return 1
        }
}

class Bar1 : Foo() {
    override val x: Int
        get() {
            return 2
        }
}



오버라이딩 규칙
  • 같은 멤버에 대한 중복된 구현을 상속받은 경우, 상속받은 클래스는 해당 멤버를 오버라이딩하고 자체 구현을 제공해야 함
  • super<클래스명>.함수 를 통해서 상위 클래스를 호출 할 수 있음 (모호성 해결)
  • 클래스 1개 상속, 인터페이스 1개 구현 (다중상속 X)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") }
    fun b() { print("b") }
}

class C : A(), B {
    override fun f() {
        super<A>.f()
        super<B>.f()
    }
}

fun main(args: Array<String>) {
    val obj = C()
    obj.f() // 출력 : AB
}



추상 클래스
  • abstract 멤버는 구현이 없음
  • abstract 클래스나 멤버는 open이 필요 없음 (디폴트)
  • abstract 클래스는 객체를 생성할 수 없음.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
abstract class AbsClass {
    abstract fun f()
}

class MyClass : AbsClass() {
    override fun f() {
        print("my class")
    }
}

fun main(args: Array<String>) {
    val obj = MyClass()
    obj.f() // 출력 : my class
}


출처 : 새차원의 코틀린 강좌 https://www.inflearn.com/course/%EC%BD%94%ED%8B%80%EB%A6%B0-%EA%B0%95%EC%A2%8C-%EC%83%88%EC%B0%A8%EC%9B%90/

Share