Kotlin 進階之路 目錄

1.接口

/**
 * 接口 interface : 方法、屬性或一段功能的"藍本"
 * 僅僅是規定實現的標準(抽象的)
 *
 * 通常用于對類進行附加功能，可以用類保持簡潔的定義
 * 通過實現1個或N個接口的組合，來實現非繼承式的功能增強
 */

//接口定義: interface 接口名 {//各種屬性或方法定義 }

interface Livable {
    val hasSkill: Boolean
}

interface ChinaLivable {
    //接口中的屬性只有類型定義,不可初始化
    val hasJobOffer: Boolean

    //接口中的屬性可以有get,通常用于單純地增加一個常量屬性
    val visaCategory: String
        get() = "工作簽證"

    //接口中的變量屬性
    var city: String

    //接口中的方法
    fun speakChinese()

    //接口中的方法可以有默認實現,通常指該方法是固定不變的
    fun handleGuanxi() {
        println("在中國要學會處理人際關系")
    }

}

open class Person {
    var name =""
}

//繼承父類，并實現多個接口
class ForigenChinese : Person(),Livable,ChinaLivable{
    override val hasJobOffer: Boolean
        get() = true
    override var city =""

    override fun speakChinese() {
        println("我叫${this.city},漢語水平一級")
    }

    override val hasSkill: Boolean
        get() = true

}

fun main(args: Array<String>) {

    val tom = ForigenChinese()
    tom.name = "Green"
    tom.city = "Beijing"
    tom.speakChinese()
    tom.handleGuanxi()
    println(tom.visaCategory)
    println("tom有技能：${tom.hasSkill}")
}

我叫Beijing,漢語水平一級
在中國要學會處理人際關系
工作簽證
tom有技能：true

2.泛型

/**
 * 泛型 Generics
 * 讓一個類型被廣泛使用,即,通用化,稱之為"泛型"
 * 一般用于函數的參數類型定義
 */

fun main(args: Array<String>) {
    //最常用的例子:print和println函數，幾乎可以放任何參數類型
    println(2)
    println("泛型")


    //Array，參數也可以是任意類型
    val a = arrayOf(1, 2, 3)

    //自定義一個泛型函數:<T> Type的首字母縮寫,T 代表一個占位符,用尖括號包含
    fun <T> showText(para: T) {

        println(para)
    }

    showText("自定義泛型")
    showText(2)

    //有時候系統提供的泛型函數很好
    //求和
    val sum = arrayOf(1, 2, 3, 4, 5).sum()
    println(sum)

    //整數、小數在一起sum()無法求和
    //val sum = arrayOf(1,2,3,4,5.5).sum()
    //println(sum)

    //泛型約束:<泛型占位符:類型>
    fun <T : Number> sum(vararg numbers: T): Double {

        return numbers.sumByDouble { it.toDouble() }
    }

    println(sum(1, 2, 3, -0.5, 5))

    //多重約束 :where,哥哥約束用逗號分割,寫在函數體之前
    //例子：把數組中大于某個(閾值)的部分取出并升序排列
    //(1,2,-398,88,1024,8888)

    fun <T> biggerPart(list: Array<T>, threhold: T): List<T>
            where T : Number, T : Comparable<T> {

        return list.filter { it >= threhold }.sorted()
    }

    val b = arrayOf(1, 0, 123, -12, 11, 666)
    println(biggerPart(b,11))

}

2
泛型
自定義泛型
2
15
10.5
[11, 123, 666]

3.擴展

/**
 * 擴展:對既有類增加新功能而無需繼承該類，及時獲取源代碼
 * 主要作用是"立即"為相關類 整體上添加工具類(Utils)方法或屬性,高效優雅。
 * Kotlin:擴贊函數,擴展屬性
 *
 * 與接受者中參數、名稱都一樣的擴展是無效的。
 * 盡量避免與已有的名字重名，如果一定要重名，參數名和類型也要不一樣。
 */

//擴展函數: fun 函數接受者類型，新擴贊函數名(參數類別) {//函數實現}
//1.普通函數擴展:整數的平方
fun Int.square(): Int {

    return this * this
}
//2.泛型擴展函數:取數字型數組中最大的元素


fun <T> Array<T>.biggest(): T
        where T : Number, T : Comparable<T> {
    var biggest = this[0]
    for (i in 1..lastIndex) {
        val element = this[i]
        if (element > biggest) {
            biggest = element;
        }
    }
    return biggest
}

fun <T> Array<T>.smallest(): T where T : Number, T : Comparable<T> {
    var smalllest = this[0]
    for (i in 1..lastIndex) {
        val element = this[i]
        if (element < smalllest) {
            smalllest = element
        }
    }
    return smalllest
}

//泛型屬性擴展
//1.普通屬性擴展 。例子：整數的下一個數字
val Int.next: Int
    get() = this + 1
//2.泛型屬性擴展：數字類型的半徑對應的類型
val <T : Number> T.area: Double
    get() = 3.1415926 * this.toDouble() * this.toDouble()

fun main(args: Array<String>) {
    println(5.square())

    println(2.area)

    val a = arrayOf(1, 2, 3, -88)
//    println(a.max())
//    println(a.min())
    println(a.biggest())
    println(a.smallest())

    println(3.next)
}

25
12.5663704
3
-88
4