2019/3/18

Kotlin 類別、物件、介面


以下說明這些功能：類別、介面，關鍵字 object，data classes 及 class delegation。


不同於 java，kotlin 宣告預設為 public final，nested class 不是 inner class，沒有外層 class 的 implicit reference。將 class 宣告為 data class時，compiler 會自動產生幾個 methods。


定義 class 時使用關鍵字 keyword，同時會產生一個 instance，這可用在 singleton object, companion objects 以及 oject expressions (類似 Java anonymous classes)


class hierarchy


interface

用 interface 定義介面，用 : 表示實作 interface


override 類似 java 的 @Override annotation，Button 裡面的 override 是一定要寫的，否則程式將無法編譯


interface Clickable {
    // 只定義了 function，沒有實作
    fun click()
}
class Button : Clickable {
    override fun click() = println("I was clicked")
}

fun main(args: Array<String>) {
    Button().click()
}

有兩個以上的 interface 的範例


class Button : Clickable, Focusable {
    override fun click() = println("I was clicked")

    // 因 Clickable, Focusable 都有實作 showOff，必須要用 super<Clickable> 指定是用哪一個上層實作
    // 如果只要使用一種上層實作，可寫成這樣
    // override fun showOff() = super<Clickable>.showOff()
    override fun showOff() {
        super<Clickable>.showOff()
        super<Focusable>.showOff()
    }
}

interface Clickable {
    fun click()
    // 定義 function，並提供預設的實作
    fun showOff() = println("I'm clickable!")
}

interface Focusable {
    fun setFocus(b: Boolean) =
        println("I ${if (b) "got" else "lost"} focus.")

    fun showOff() = println("I'm focusable!")
}

fun main(args: Array<String>) {
    val button = Button()
    button.showOff()
    // Focusable 有提供 setFocus，故 Button 可使用這個 function
    button.setFocus(true)
    button.click()
}

執行結果


I'm clickable!
I'm focusable!
I got focus.
I was clicked

final by default

為了避免發生 fragile base class 問題，kotlin 預設將 class, method 都加上 final 的特性，如果要讓其他類別繼承的
class 或覆寫的 method，都必須要加上 open 這個 modifier。


interface Clickable {
    fun click()
    fun showOff() = println("I'm clickable!")
}

// 可被繼承
open class RichButton : Clickable {

    // 不可被覆寫
    fun disable() {}

    // 可被覆寫
    open fun animate() {}

    // 覆寫 click，且可被覆寫
    override fun click() {}
    
    // 如果要限制 click 不能被覆寫，要加上 final
    // final override fun click() {}
}

class modifier corresponding member comments
final can't be overridden default for class members
open can be overridden 要特別指定
abstract must be overridden 只能用在 abstract classes, abstract members 不能有實作內容
override overrides a member in a superclass 預設為 open，如要限制不能被覆寫，要加上 final


visibility modifiers 有 public, protected, private, internal 四種，預設為 public，其中 internal 表示為 "visible inside a module"


visibility modifiers class member top-level declaration
public(default) visible everywhere visible everywhere
internal visible in a module visible in a module
protected visible in subclasses --
private visible in a clsss visible in a file

protected member 只能被 class 及 subclass 使用，跟 java 的 protected，可在同一個 package 使用的定義不同


class 的 extension function 無法使用 private or protected members


interface Focusable {
    fun setFocus(b: Boolean) =
        println("I ${if (b) "got" else "lost"} focus.")

    fun showOff() = println("I'm focusable!")
}

internal open class TalkativeButton : Focusable {
    private fun yell() = println("Hey!")
    protected fun whisper() = println("Let's talk!")
}

// error: 'public' member exposes its 'internal' receiver type TalkativeButton
fun TalkativeButton.giveSpeech() {
    // error: cannot access 'yell': it is private in 'TalkativeButton'
    yell()
    // error: cannot access 'whisper': it is protected in 'TalkativeButton'
    whisper()
}

nested class, inner class

kotlin 也可在 class 裡面定義另一個 class，跟 java 的差異是 kotlin nested class 不能使用 outer class instance


首先製作兩個 interface，注意 State 為 Serializable


interface State: Serializable

interface View {
    fun getCurrentState(): State
    fun restoreState(state: State) {}
}

如果以 java 實作 ButtonState 這個 inner class，會遇到 java.io.NotSerializableException: Button，這是因為 ButtonState 裡面儲存了 outer class: Button 的 implicit reference，無法被序列化，如要解決，要將 ButtonState 宣告為 static，去掉 implicit reference to Button。


/* Java */
public class Button implements View {
    @Override
    public State getCurrentState() {
        return new ButtonState();
    }

    @Override
    public void restoreState(State state) { /*...*/ }
    
    public class ButtonState implements State { /*...*/ }
}

以 kotlin 實作 ButtonState，就像是 java 的 static nested class 一樣。


class Button : View {
    override fun getCurrentState(): State = ButtonState()

    override fun restoreState(state: State) { /*...*/ }

    class ButtonState : State { /*...*/ }
}

kotlin 的 nested class 不會參考到 outer class 的 reference，但 inner class 可以


Class A declared within another Class B in Java in Kotlin
nested class (不會儲存 outer class 的 reference) static class A class A
inner class (會儲存 outer class 的 reference) class A inner class A

可用 this@Outer 參考到 Outer class 的 reference


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

sealed class

Expr 介面有兩個實作的 class: Num, Sum，在 eval 中，要注意 else 的部分，compiler 會檢查有沒有預設的條件，在這邊預設不能回傳任何數值，故直接 throw exception


interface Expr
class Num(val value: Int) : Expr
class Sum(val left: Expr, val right: Expr) : Expr

fun eval(e: Expr): Int =
    when (e) {
        is Num -> e.value
        is Sum -> eval(e.right) + eval(e.left)
        else ->
            throw IllegalArgumentException("Unknown expression")
    }

fun main(args: Array<String>) {
    println(eval(Sum(Sum(Num(1), Num(2)), Num(4))))
}

kotlin 提供 sealed class 處理這種問題


因 Expr 限制為 sealed class，故無法被任意產生 subclass，所有 subclass 只能寫成 nested class，而在 eval 裡面，就不需要寫 else 的條件，因為系統內不可能會有其他 Expr 的 subclasses (compiler 的檢查及限制)


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)
    }

fun main(args: Array<String>) {
    println(eval(Expr.Sum(Expr.Sum(Expr.Num(1), Expr.Num(2)), Expr.Num(4))))
}

使用 nontrivial constructor 及 properties


kotlin 也可以實作多個 constructor，可在 initializer blocks 增加 initilization logic


primary constructor 及 initializer blocks

constructor, init 這兩個關鍵字，用 _nickname 取代 java 習慣的 this.nickname = nickname 這樣的寫法


// 單一參數的 primary constructor
class User constructor(_nickname: String) {
    val nickname: String
    
    // initializer block
    init {
        nickname = _nickname
    }
}

可省略 contructor, init 的語法


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

再進一步省略 {} 的部分


class User(val nickname: String)

在 contructor 的參數，可給予預設值，使用時，就可彈性使用一或兩個參數的 constructor


class User(val nickname: String,
           val isSubscribed: Boolean = true)

fun main(args: Array<String>) {
    val alice = User("Alice")
    println(alice.isSubscribed)
    val bob = User("Bob", false)
    println(bob.isSubscribed)
    val carol = User("Carol", isSubscribed = false)
    println(carol.isSubscribed)
}

如果 super class 的 constructor 需要參數，要在 subclass 定義裡面提供該參數初始化 super class


open class User(val nickname: String) { ... }
class TwitterUser(nickname: String) : User(nickname) { ... }

預設會產生一個沒有參數的 contructor


open class Button

class RadioButton: Button()

可讓 contructor 變成 private method


class Secretive private constructor() {}

class Secretive {
    private constructor()
}

secondary constructor

open class View {
    constructor(ctx: Context) {
        // some code
    }

    // secondary constructor
    constructor(ctx: Context, attr: AttributeSet) {
        // some code
    }
}

// subclass 必須同時提供兩個 constructor
class MyButton : View {
    constructor(ctx:Context) : super(ctx) {
        // ...
    }
    constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) {
        // ...
    }
}

可以用 this() 呼叫其他 constructor


class MyButton : View {
    constructor(ctx: Context): this(ctx, MY_STYLE) {
        // ...
    }
    constructor(ctx: Context, attr: AttributeSet):super(ctx, attr) {
        // ...
    }
}

實作 interfaces 中宣告的 properties

interface User 中定義需要有 nickname 這個 property，PrivateUser、SubscribingUser、FacebookUser 分別用三種方式，提供 nickname


interface User {
    val nickname: String
}

// primary constructor property
class PrivateUser(override val nickname: String) : User

// custom getter
class SubscribingUser(val email: String) : User {
    override val nickname: String
        get() = email.substringBefore('@')
}

// property initializer
fun getFacebookName(accountId: Int) = "fb:$accountId"
class FacebookUser(val accountId: Int) : User {
    override val nickname = getFacebookName(accountId)
}

fun main(args: Array<String>) {
    println(PrivateUser("test@kotlinlang.org").nickname)
    println(SubscribingUser("test@kotlinlang.org").nickname)
}

interface 可讓 property 有 getter setter 實作


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

由 getter/setter 使用 backing field

field 可在 getter/setter 中取得該 backing field property 的 value，在 setter 裡面，可修改 field 的 value


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

fun main(args: Array<String>) {
    val user = User("Alice")
    user.address = "Elsenheimerstrasse 47, 80687 Muenchen"
}

修改 accessor visibility

counter 的 set 改成 private method，因此，不能在 class 以外的地方，修改 counter 的數值


class LengthCounter {
    var counter: Int = 0
        private set

    fun addWord(word: String) {
        counter += word.length
    }
}

fun main(args: Array<String>) {
    val lengthCounter = LengthCounter()
    lengthCounter.addWord("Hi!")
    println(lengthCounter.counter)
}

compiler 產生的 methods: data classes 及 class delegation


java 在每一個 class 都有 equals(), hashCode(), toString() 這些 method，kotlin 在 compiler 中自己產生這些 method


universal object methods

  • toString()

override toString() method


class Client(val name: String, val postalCode: Int) {
    override fun toString() = "Client(name=$name, postalCode=$postalCode)"
}

fun main(args: Array<String>) {
    val client1 = Client("Alice", 342562)
    println(client1)
}

  • equals()

沒有調整 equals() 時，兩個物件的比較結果是相異的


class Client(val name: String, val postalCode: Int)

fun main(args: Array<String>) {
    val client1 = Client("Alice", 342562)
    val client2 = Client("Alice", 342562)
    println(client1 == client2)
}

覆寫 equals()，Any? 其中 Any 代表 java.lang.Object ，這也是 Kotlin 所有 classes 的 super class，? 代表 other 可以是 null


hashCode 必須要跟著 equals 一同被覆寫，因為當兩個 object 相等時，hashCode 必須要一樣


class Client(val name: String, val postalCode: Int) {
    override fun equals(other: Any?): Boolean {
        // 先檢查 other 是不是 null, 是不是 Client
        if (other == null || other !is Client)
            return false
        // 檢查兩個欄位的數值是否相等
        return name == other.name &&
               postalCode == other.postalCode
    }
    override fun toString() = "Client(name=$name, postalCode=$postalCode)"
    
    override fun hashCode(): Int = name.hashCode() * 31 + postalCode
}

fun main(args: Array<String>) {
    val processed = hashSetOf(Client("Alice", 342562))
    println(processed.contains(Client("Alice", 342562)))
}

data classes: 自動產生 universal methods 的實作

在 class 前面加上 data 關鍵字，compiler 將會自動產生 universal methods: equals(), hashCode(), toString()


data class 並沒有限制只能使用 val property，也可以用 var，但建議還是盡量使用 val，讓 data class 成為 immutable object，所以 kotlin 在提供了一個 copy() 這個 universal method


如果自己實作 copy，會類似以下這樣的 code


class Client(val name: String, val postalCode: Int) {
    ...
    fun copy(name: String = this.name, postalCode: Int = this.postalCode) = Client(name, postalCode)
}

object instance 使用 copy，並修改其中一個欄位的值


>>> val bob = Client("Bob", 973293)
>>> println(bob.copy(postalCode = 382555))
Client(name=Bob, postalCode=382555)

class delegation: 使用 "by"

在物件導向程式中，會因為繼承 class，覆寫 method，讓某些程式跟父類別產生連動關係，當 base class 有異動時，就造成整個系統不穩定的狀況。


kotlin 預設讓 class 都是 final，無法被繼承的，這可確保經過設計，可以被繼承的 class 才有被繼承的功能，


相較於繼承，更常見的方式，是利用 Decorator Pattern，建立一個新的 class，實作跟舊的 class 一樣的所有 methods，再根據自己的需求，修改對應的 methods，就像是以下的範例。


class DelegatingCollection<T> : Collection<T> {
    private val innerList = arrayListOf<T>()
    
    override val size: Int get() = innerList.size
    override fun isEmpty(): Boolean = innerList.isEmpty()
    override fun contains(element: T): Boolean = innerList.contains(element)
    override fun iterator(): Iterator<T> = innerList.iterator()
    override fun containsAll(elements: Collection<T>): Boolean = innerList.containsAll(elements)
}

kotlin 提供另一種更有效的方式: class delegation 使用 "by"，以下這樣的 code，compiler 會自動產生所有 delegation codes，只需要寫有需要修改覆寫的 method。


class DelegatingCollection<T>(
    innerList: Collection<T> = ArrayList<T>()
) : Collection<T> by innerList {
}

import java.util.HashSet

class CountingSet<T>(
        val innerSet: MutableCollection<T> = HashSet<T>()
) : MutableCollection<T> by innerSet {

    var objectsAdded = 0

    // 不使用預設的 delegation method，改寫 add
    override fun add(element: T): Boolean {
        objectsAdded++
        return innerSet.add(element)
    }

    override fun addAll(c: Collection<T>): Boolean {
        objectsAdded += c.size
        return innerSet.addAll(c)
    }
}

fun main(args: Array<String>) {
    val cset = CountingSet<Int>()
    cset.addAll(listOf(1, 1, 2))
    println("${cset.objectsAdded} objects were added, ${cset.size} remain")
}

關鍵字 object 的用途


  • Object declaration: 定義 singleton
  • Companion objects: 包含 factory method 以及所有不需要 instance 的 methods，透過 class name 使用這些 methods
  • Object expression: 取代 Java 的 anonymous inner class

singleton

object 可讓該 class 只會產生一個 instance，使用時必須要用 class name


object Payroll {
    val allEmployees = arrayListOf<Person>()
    fun calculateSalary() {
        for (person in allEmployees) {
            ...
        }
    }
}

Payroll.allEmployees.add(Person(...))
Payroll.calculateSalary()

以下是 CaseInsensitiveFileComparator 範例


import java.util.Comparator
import java.io.File

object CaseInsensitiveFileComparator : Comparator<File> {
    override fun compare(file1: File, file2: File): Int {
        return file1.path.compareTo(file2.path,
                ignoreCase = true)
    }
}

fun main(args: Array<String>) {
    println(CaseInsensitiveFileComparator.compare(
        File("/User"), File("/user")))
    
    val files = listOf(File("/Z"), File("/a"))
    println(files.sortedWith(CaseInsensitiveFileComparator))
}

也可以將 object 放在 class 裡面，以 Person.NameComparator 的方式使用


import java.util.Comparator

data class Person(val name: String) {
    object NameComparator : Comparator<Person> {
        override fun compare(p1: Person, p2: Person): Int =
            p1.name.compareTo(p2.name)
    }
}

fun main(args: Array<String>) {
    val persons = listOf(Person("Bob"), Person("Alice"))
    println(persons.sortedWith(Person.NameComparator))
}

如果要從 Java 使用 kotlin object，要透過 INSTANCE 這個 singleton object reference


/* Java */
CaseInsensitiveFileComparator.INSTANCE.compare(file1, file2);

companion objects: factory method and static members

java 的 keyword static，在 kotlin 沒有。


kotlin 提供 companion object，使用起來就像是java 的 static method 一樣


class A {
    companion object {
        fun bar() {
            println("Companion object called")
        }
    }
}

fun main(args: Array<String>) {
    A.bar()
}


通常會針對 FacebookUser, SubscribingUser 兩種 User，實作不同的 constructor


class User {
    val nickname: String
    constructor(email: String) {
        nickname = email.substringBefore('@')
    }

    constructor(facebookAccountId: Int) {
        nickname = getFacebookName(facebookAccountId)
    }
}

如果用 companion object 的做法，可在裡面實作 factory method，FacebookUser, SubscribingUser 兩種不同的 User 就用不同的 factory method 產生物件


fun getFacebookName(accountId: Int) = "fb:$accountId"

class User private constructor(val nickname: String) {
    companion object {
        fun newSubscribingUser(email: String) =
            User(email.substringBefore('@'))

        fun newFacebookUser(accountId: Int) =
            User(getFacebookName(accountId))
    }
}

fun main(args: Array<String>) {
    val subscribingUser = User.newSubscribingUser("bob@gmail.com")
    val facebookUser = User.newFacebookUser(4)
    println(subscribingUser.nickname)
}

把 companion object 當作 regular objects

companion object 就像是在 class 中宣告的一般類別，可命名，可實作 interface，可以有 extension function 或 properties


  • json serialization

class Person(val name: String) {
    companion object Loader {
        fun fromJSON(jsonText: String): Person = ...
    }
}

fun main(args: Array<String>) {
    val person = Person.Loader.fromJSON("{name: 'Dmitry'}")
    println(person.name)
    val person2 = Person.fromJSON("{name: 'Brent'}")
    println(person2.name)
}

  • implement interface

interface JSONFactory<T> {
    fun fromJSON(jsonText: String): T
}

class Person(val name: String) {
    companion object : JSONFactory<Person> {
        override fun fromJSON(jsonText: String): Person = ...
    }
}

在 java 如果要使用 companion object


/* Java */
Person.Companion.fromJSON("...");

  • companion object extensions

// business logic module
class Person(val firstName: String, val lastName: String) {
    // 產生空白的 companion object
    companion object {
    }
}
// client/server communication module
// 產生 extension function
fun Person.Companion.fromJSON(json: String): Person {
    ...
}

val p = Person.fromJSON(json)

  • anonymous inner class

在 java 使用 event listener，會用到 anonymous inner class


window.addMouseListener(
    object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            // ...
        }
        override fun mouseEntered(e: MouseEvent) {
            // ...
        }
    }
)

在 java 的 anonymous class 中，只能使用外部的 final variables。


在 kotlin 可以建立 local 變數，並在 object 裡面使用該變數


fun countClicks(window: Window) {
    // 宣告 local 變數
    var clickCount = 0
    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            // 更新變數的數值
            clickCount++
        }
    })
    // ...
}

References


Kotlin in Action

張貼者： 於
標籤：

沒有留言:

張貼留言

訂閱： 張貼留言 (Atom)