Kotlin學習筆記-類和介面

一. class

• 宣告

class Person {
}

• 修飾符
  1. classModifier

abstract //抽象類標示
final //標示類不可繼承，預設屬性
enum //標示類為列舉
open //類可繼承，類預設是final的
annotation //註解類

2. accessModifier

private //僅在同一個檔案中可見
protected //同一個檔案中或子類可見
public //所有呼叫的地方都可見
internal //同一個模組中可見

• 屬性

class Person {
    var name: String = "tom"
        set(value) {
            field = value
        }
        get() = field.toUpperCase()
    var age: Int = 0
}

• 構造方法
  Kotlin 中類可以有一個主構造方法以及多個二級構造方法。主構造方法是類頭的一部分

1. 主構造方法

class Person constructor (name: String) {
       init {
       }
}

和上面的區別在於 上面的name只是作為引數傳遞，而下面的方式中name直接成為類的成員屬性

class Person constructor(val name: String) {
       init {
       }
} 

主構造方法的初始化程式碼可以放到init程式碼塊中，如果沒有註解或修飾符則 constructor 可以省略

2. 二級構造方法

class Person {
        constructor(name: String) {
        }
}

3. 如果類有主構造方法, 那麼每個二級構造方法都必須委託給主構造方法, 要麼直接委託, 要麼通過其他二級構造方法間接委託. 委託到同一個類的另一個構造方法時, 使用 this 關鍵字實現

 class Person(val name: String) {
        constructor(name: String, age: Int) : this(name) {
       }
}

4. 例項化
   Kotlin中沒有new關鍵字

val p = Person("tom")

• 抽象類

abstract class Parent {
    abstract fun foo()
}
class Children : Parent() {
    override fun foo() {
    }
}

• 內部類

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() {
            println(bar)
        }
    }
}
內部類使用inner修飾，持有外部類的引用，可以訪問外部類的屬性和方法

• 巢狀類

class Outer {
    val bar: Int = 1
    class Nested {
    }
}

巢狀類和內部類的區別在於巢狀類沒有外部類的引用

• 封閉類
  封閉類是列舉類(enum class)的一種擴充套件: 列舉類的值也是有限的, 但每一個列舉值常數都只存在唯一的一個例項, 封閉類則不同, 它允許的子類型別是有限的, 但子類可以有多個例項, 每個例項都可以包含它自己的狀態資料

sealed class Expr {
    class Const(val number: Double) : Expr() 
    class Sum(val e1: Expr, val e2: Expr) : Expr() 
    object NotANumber : Expr()
}

• 資料類
  只儲存資料的類，使用data 修飾，類似java中的javabean

data class Person(var name: String, var age: Int, var gender: Int)

• 單例

object Singleton {
    fun foo() {
    }
}
fun main(args: Array<String>) {
    Singleton.foo()
}

二.interface

• 定義

interface MyInterface {
    fun foo()
    //預設實現
    fun bar() {
        println("hi")
    }
}

• 實現

class MyClass :MyInterface{
    override fun foo() {
    }
    override fun bar() {
        super.bar()
    }
}

• 介面的屬性

interface MyInterface {
    var name: String
}
//實現方式一
class MyClass(override var name: String) : MyInterface {
}
//實現方式二
class MyClass : MyInterface {
    override var name: String
        get() = name
        set(value) {}
}

• 重寫
  實現多個介面時，可能會遇到同一方法繼承多個實現的問題

interface A {
    fun foo() {
        println("A foo")
    }
    fun bar() {
        println("A bar")
    }
}
interface B {
    fun foo() {
        println("B foo")
    }
    fun bar() {
        println("B bar")
    }
}
class C : A, B {
    override fun foo() {
        super<A>.foo()   //必須指定呼叫哪個介面的方法
    }
    override fun bar() {
        super<B>.bar()
    }
}