Kotlin学习——kt入门合集博客 & kt里的委派模式Delegation & kt里的特性

本文介绍: 1.kt里的委派模式Del e g a ti on；2.kt里的特性，product i vi t y boost e rs生产力助推器；

在这里插入图片描述

Ko t lin 是一门现代但已成熟的编程语言，旨在让开发人员更幸福快乐。它简洁、安全、可与 Jav a 及其他语言互操作，并提供了多种方式在多个平台间复用代码，以实现高效编程。

https://play.kotlinlang.org/byExample/01_introduction/02_Functions

其他关于kt的博客文章如下：

引出

1.kt里的委派模式Del e g a ti on；
2.kt里的特性，productivi t y boost e rs生产力助推器；

kt里的委派模式

Dele g a ti on Pa t t e rn 委派模式 b y 关键字

Ko t lin支持在本地级别轻松实现委派模式，而无需任何样板代码。

将方法调用委托给负责的实现。委托对象是在关键字 b y之后定义的

package com.tianju.kt.scopeFunc

/**
 * 定义一个接口
 */
interface SoundBehavior {
    fun makeSound()
}

/**
 * 实现方法
 */
class ScreamBehavior(val n:String): SoundBehavior {
    override fun makeSound() = println("${n.uppercase()} !!!")
}

class RockAndRollBehavior(val n:String): SoundBehavior {
    override fun makeSound() = println("I'm The King of Rock 'N' Roll: $n")
}

// 将方法调用委托给负责的实现。委托对象是在关键字by之后定义的
// Tom Araya is the "singer" of Slayer
class TomAraya(n:String): SoundBehavior by ScreamBehavior(n)

// You should know ;)
class ElvisPresley(n:String): SoundBehavior by RockAndRollBehavior(n)

fun main() {
    val tomAraya = TomAraya("Thrash Metal")
    tomAraya.makeSound()
    val elvisPresley = ElvisPresley("Dancin' to the Jailhouse Rock.")
    elvisPresley.makeSound()
}

在这里插入图片描述

Delegated Pro per ti es 属性委派

Kotlin提供了一种委托属性机制，允许将属性集的调用和get方法委托给某个对象。在这种情况下，委托对象应该具有 getValue方法。对于可变属性，您还需要 setValue。

package com.tianju.kt.scopeFunc

import kotlin.reflect.KProperty

class Example{
    var p:String by Delegate()

    override fun toString(): String {
        return "Example Class"
    }
}


class Delegate() {
    operator fun getValue(thisRef: Any?, prop: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${prop.name}' to me!"
    }

    operator fun setValue(thisRef: Any?, prop: KProperty<*>, value: String) {
        println("$value has been assigned to ${prop.name} in $thisRef")
    }
}

fun main() {
    val e = Example()
    println(e.p)
    e.p = "WATT"
}s

在这里插入图片描述

lazy懒加载

Kotlin标准库包含一堆有用的委托，比如懒惰的lazy、可观察observ able的和其他的

package com.tianju.kt.scopeFunc

class LazySample {
    /**
     * 静态代码块
     */
    init {
        println("created!")
    }

    /**
     * by lazy 懒加载
     */
    val lazyStr: String by lazy {
        println("computed!")
        "my lazy"
    }
}

fun main() {
    // 创建对象时未初始化属性lazy
    val sample = LazySample()
    // 调用的时候才会初始化属性
    println("lazyStr = ${sample.lazyStr}")
    println(" = ${sample.lazyStr}")
}

map中存储 属性

属性委派可用于在映射中存储属性。这对于解析JSON或执行其他“动态”操作等任务非常方便。

package com.tianju.kt.ktLast

/**
 * 可以从map转换为对象
 */
class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int     by map
}

fun main() {

    val stringMap = mapOf(
        "name" to "John Doe",
        "age" to 25
    )
    println(stringMap)
    val user = User(stringMap)
    println("name = ${user.name}, age = ${user.age}")
}

在这里插入图片描述

productivity boosters生产力助推器

Named Arguments 命名 参数

与大多数其他编程语言（Java、C++等）一样，Kotlin支持根据方法和构造函数的定义顺序将参数传递给它们。Kotlin还支持命名参数，以允许更清晰的调用，并避免参数顺序错误。

package com.tianju.kt.ktLast

fun format(userName: String, domain: String) = "$userName@$domain"

fun main() {
    println(format("mario", "example.com"))
    println(format("domain.com", "username"))
    println(format(userName = "foo", domain = "bar.com"))
    println(format(domain = "frog.com", userName = "pepe"))
}

在这里插入图片描述

$占位符在String中

字符串模板允许您将变量引用和表达式包含到字符串中。当请求字符串的值时（例如，通过 pr intln），所有引用和表达式都会被实际值替换。

package com.tianju.kt.ktLast

fun main() {
    val greeting = "Kotliner"

    println("Hello $greeting")
    println("Hello ${greeting.uppercase()}")
}

在这里插入图片描述

Destruct uring Declarations 破坏声明 语法

破坏声明语法非常方便，尤其是当您只需要一个实例来访问其成员时。它允许您在没有特定名称的情况下定义实例，从而节省了几行代码。

package com.tianju.kt.ktLast

fun findMinMax(list: List<Int>): Pair<Int, Int> {
    // do the math
    return Pair(50, 100)
}

fun main() {
    val (x, y, z) = arrayOf(5, 10, 15)
    println(x)

    // 初始化一个map集合
    val map = mapOf("Alice" to 21, "Bob" to 25)
    for ((name, age) in map) {
        println("$name is $age years old")
    }

    val (min, max) = findMinMax(listOf(100, 90, 50, 98, 76, 83))

}

在这里插入图片描述

使用下划线，避免编译器提示指示未使用的变量

package com.tianju.kt.ktL

data class User(val username: String, val email: String)

fun getUser() = User("Mary", "mary@somewhere.com")

fun main() {
    val user = getUser()
    // 解构实例。声明的值映射到实例字段
    val (username, email) = user
    println(username == user.component1())

    val (_, emailAddress) = getUser()
    println(emailAddress)
}

在这里插入图片描述

package com.tianju.kt.ktL

class Pair<K, V>(val first: K, val second: V) {
    operator fun component1(): K {
        return first
    }

    operator fun component2(): V {
        return second
    }
}

fun main() {
    val (num, name) = Pair(1, "one")

    println("num = $num, name = $name")
}

Smart Casts 聪明的编译器

Kotlin编译器足够聪明，可以在大多数情况下自动执行类型转换，包括：

从可为null的类型转换为不可为null 类型。
从超类型转换为子类型。

package com.tianju.kt.ktL

import java.time.LocalDate
import java.time.chrono.ChronoLocalDate

fun main() {
    // 声明一个可为null的变量
    val date: ChronoLocalDate? = LocalDate.now()    

    if (date != null) {
        println(date.isLeapYear)                    
    }

    if (date != null &amp;&amp; date.isLeapYear) {          
        println("It's a leap year!")
    }

    if (date == null || !date.isLeapYear) {         
        println("There's no Feb 29 this year...")
    }

    if (date is LocalDate) {
        val month = date.monthValue                
        println(month)
    }
}