Kotlin in action(3)

인터페이스 확장

코틀린은 기본적으로 public이고 final이다. 인터페이스를 정의할 때는 interface 키워드를 사용한다. 추상메서드, 구현이 있는 메서드를 모두 사용할 수 있고 클래스 상속과 인터페이스 구현 모두 :를 사용해 받는다. 인터페이스를 구현하는 건 여러개가 가능하지만, 클래스 상속은 한개만 가능하다. 이점은 자바와 같다.

인터페이스에 있는 프로퍼티나 메서드를 구현할 때는 override를 사용하는데, 아래 코드를 보자.

class Button : Clickable, Focusable {
    override fun showOff() {
        super<Clickable>.showOff()
        super<Focusable>.showOff()
    }
}

 

Clickable과 Focausable 모두 showOff라는 함수를 갖고있고, 구현쪽에서는 super<interface>를 통해 어느 쪽의 함수를 구현할 지 결정할 수 있다.

코틀린에서는 인터페이스에도 프로퍼티를 선언할 수 있다. 이 경우 추상 프로퍼티이므로 override로 구현해줘야한다. 상태 저장이 필요하면 커스텀 게터를 만들어서 설정한다. 추상 프로퍼티는 상태를 저장할 수 없기 때문에 backing field가 없어서 getter, setter에 참조할 수 없다.

interface User {
    val email: String
    val nickname: String
        get() = email.substringBefore('@')
}

 

추상 프로퍼티에 커스텀 게터를 설정한 모습이다. 이때 email에는 무조건 오버라이드해야하고 nickname은 그냥 상속 가능하다.

backing field를 살펴보는 김에 커스텀 세터도 같이 보자.

class User(val name: String) {
    var address: String = "unspecified"
        set(value: String) {
            println("""
                Address was changed for $name:
                "$field" -> "$value".""".trimIndent())
            field = value
        }
}

 

setter에서는 backing field값에 field라는 키워드로 접근할 수있다. 게터도 마찬가지다.

getter, setter의 가시성은 프로퍼티를 따라가지만, 따로 가시성을 제한할 수 있다.

var counter: Int = 0
        private set

 

이렇게 하면 이 프로퍼티를 사용하는 곳에서는 setter에 접근할 수 없게된다.

open, final, abstract

위 키워드는 상속관계가 필요할 때 사용한다. 상위 클래스를 상속받는 하위클래스가 상위 클래스의 변경으로 인해 예기치 못한 동작을 발생하는 문제인 취약한 기반 클래스라는 것이 있는데, 코틀린에서는 상속이 필요한 경우에 따로 변경자를 지정하게하고 기본은 final로 해두어서 상속을 위한 클래스가 아니라면 상속이 불가능하다. 상속을 허용하려면 open 키워드를 사용해 클래스를 정의하면 된다.

open class RichButton : Clickable {
    fun disable() {}
    open fun animate() {}
    override fun click() {}
}

class test: RichButton() {
    override fun animate() {
        super.animate()
    }
    override fun click() {
        super.click()
    }
}

 

보면 open 클래스의 open, override로 지정된 메서드는 override해서 사용할 수 있지만, 그게 아닌 함수는 override할 수 없다. 이때 RichButton의 click은 Clickable의 click이다. override는 기본적으로 open이기에 위와 같은 코드를 적을 수 있다. override하는 함수의 상속을 막으려면 final override로 선언하면된다. final 키워드는 스마트 캐스트와도 연관이 있는데, final로 지정된 프로퍼티는 타입검사 뒤에 값이 변할 일이 없기 때문에 스마트 캐스트의 조건을 깨지않는다는 장점이 있다.

abstract로 클래스를 정의하는 건 자바에도 있었기 때문에 익숙 할 것이다. abstract로 선언한 클래스는 인스턴스화 할 수 없고, 추상 멤버가 항상 open이기 때문에 open으로 선언한 클래스와 달리 각 멤버에 open을 적어줄 필요가 없다. 추상멤버는 구현이 없기 때문에 반드시 오버라이드가 필요하다는 점도 있다.그러나 추상 클래스 안의 비추상 메서드는 여전히 파이널이기 때문에 오버라이드를 원한다면 open을 적어줘야한다.

public, internal, protected, private

가시성 변경자들인데, 나머지 세개는 익숙할 테니 internal만 보겠다. 그 전에 코틀린의 기본 가시성은 public이고 자바는 package-private다. 코틀린에서 internal이 같은 모듈안에서만 접근할 수 있도록하는 변경자기 때문에 package-private 와 비슷하다고 할 수 있겠다.

가시성 규칙은 기본적으로 높은 가시성에서 낮은 가시성(더 개인적인)을 참조하지 못하게 한다. 가시성 레벨이 갖거나 낮은 게 높은 것을 참조할 수 있는 일종의 No-Read-Down 규칙이라고 할 수 있겠다. 확장함수로 접근할 때 protected 프로퍼티/메서드에 접근할 수 없다는 점도 기억하자.

internal은 컴파일시 바이트 코드상에서 public이 된다.

클래스 중첩, inner class

단순 클래스 중첩은 코틀린에서 약간 다르다. 중첩 된 클래스가 외부 클래스 인스턴스에 대한 접근 권한이 없다는 점이 그것이다. 코틀린에서 그냥 중첩한 클래스는 자바에서 static class로 인식되어 바깥쪽 클래스에 대한 참조를 포함하지않는다. inner class로 선언한 중첩 클래스는 원하던 참조가 가능하다.

class Outer {
    inner class Inner {
        fun getOuterReference(): Outer = this@Outer
    }
}

 

바깥 클래스를 참조 할 때는 this@로 사용해야한다. 중첩 클래스를 사용하면 좋을 때가 언제 일까? 클래스 계층을 만들때 계층에 속한 클래스의 수를 제한하고 싶으면, 내부 중첩과 일반 중첩을 잘 사용하면 되겠다.

sealed

코틀린에 등장하는 중요한 것들 중 하나라고 생각한다. sealed클래스는 상위 클래스를 상속한 하위클래스를 정의 할 때, sealed class 안에 중첩시켜서 하위 클래스를 정의한다.

sealed class Expr {
    class Num(val value: Int) : Expr()
    class Sum(val left: Expr, val right: Expr) : Expr()
}

fun eval(e: Expr): Int =
    when (e) {
        is Expr.Num -> e.value
        is Expr.Sum -> eval(e.right) + eval(e.left)
    }

 

sealed class로 정의된 클래스는 모든 하위 클래스가 정의 되어 있기 때문에 else 분기로 디폴트 검사를 할 필요가 없어진다. sealed 클래스는 자동으로 open이기 때문에 상속시에 별도로 open을 붙일 필요가 없다.

생성자: 주생성자, 부생성자

자바에서는 파라미터를 다르게 해서 여러 생성자를 갖게 할 수있는데, 코틀린에서는 주 생성성자 - 부생성자로 구분할 수 있다.

주 생성자는 클래스 본문이 아니라 클래스 선언시 괄호 사이에 넣는다. 생성자 파라미터를 지정하고, 그것에 의해 초기화되는 프로퍼티를 정의하는 목적으로 쓰인다. 초기화 블록인 init에서 그 작업을 하면 된다. 초기화 블록은 클래스가 인스턴스화 될 때 실행된다. 초기화 블록이 필요한 이유는 주 생성자 안에서는 별도의 코드를 포함할 수 없기 때문이다. 주 생성자의 파라미터는 프로퍼티 초기화/ 초기화 블록 에서만 접근 가능한 점을 기억하자.

class User constructor(_nickname: String){
    val nickname: String
    init{
        nickname = _nickname   
    }
}

 

constructor 키워드는 주생성자, 부생성자에 모두 사용할 수 있다. 변수명에 _를 붙이면 생성자 파라미터임을 알려줄 수 있다. 이건 정해진 건 아니고 일종의 컨벤션이다. this.val1 = val1 과 같은 느낌이라고 보면 된다. 주 생성자에 아예 val nickname 이라고 해버리면 파라미터이자 프로퍼티로 사용할 수 있다. 이 경우 디폴트 값을 제공 할 수도 있고, 이름을 지정해 초기화 할 수도 있다. 모든 파라미터에 디폴트 값을 지정하면 컴파일러가 파라미터가 없는 생성자를 만들어주는데, 이 기능은 DI(의존 관계 주입)과정에서 파라미터가 없는 생성자가 필요할 때 통합이 쉽도록 해준다.

상속하는 클래스(기반 클래스)가 있다면 생성자를 호출해야하는데 해당 클래스의 인자가 있다면 주 생성자 인자를 넘겨서 기반 클래스를 초기화 할 수 있다. 클래스를 인스턴스화 하지 못하게 하고싶으면 생성자를 private하게 만들면된다.

class User private constructor(){}

 

이렇게 만들어진 비공개 생성자는 companion object에서 호출하게 된다.

부생성자는 파라미터가 다른 생성자가 여러 개 필요할 때 사용할 수 있는데, 클래스 확장시 인스턴스 초기화 방법이 여러개 필요할 때가 그 때다. 위에서 사용한 constructor를 사용하면 되고, 주생성자가 없이 부생성자만 있다면 상위클래스를 초기화하거나 다른 생성자에게 생성을 위임해야한다.

class A : View{
    constructor(ctx: Context): super(ctx){
    
    }
    constructor(ctx: Context, arr: Attribute): this(ctx, attr){}
}

 

 

"댓글, 공감 버튼 한 번씩 누르고 가주시면 큰 힘이 됩니다"