Kotlin 学习笔记（一）

fun main() {
    println("Happy Birthday!")
}

• fun 代表函数。函数是程序中用于执行特定任务的部分。
  ⚠️注意 函数名称几乎总是以小写的动词开头，并且名称应描述函数的功能。
  ⚠️ 另注意 名称内的第二个单词以大写字母开头。这种样式称为“驼峰式大小写”，能够使名称更清晰易读。
  ⚠️ 函数 右大括号}独占一行，这样更容易看清函数结束之处
• main 是函数名称。函数名称用来区分不同函数。main 是运行程序时调用的第一个函数（主函数）。每个 Kotlin 程序都有一个 main函数。
• （） 圆括号中可添加提供函数使用的信息。函数的该输入称为“参数” 或 简称 args。
• {} 大括号。函数内部用于完成任务的代码
• println() 指令用于输出文本，消息的每个部分独占一行
• print() 指令只会输出文本，不会在每个字符串的末尾添加换行符。

 val age = 5

• val 是 Kotlin 使用的一个特殊单词，称为关键字。用于表示紧随其后的是变量名称
• age 是变量的名称。
• = 使 age（在其左边）的值等于其右边的值。在数学中，单个等号用于表示等号两边的值相等。与数学中不同，在 Kotlin 中，单个等号用于将等号右边的值赋予等号左边的指定变量。

使用 val 关键字声明的变量只能设置一次。以后无法在程序中更改该变量的值。不过，您可以使用 var 关键字声明可更改的变量

输出语句中使用变量 ${variable}
循环repeat() 语句

fun printBorder(border: String, timesToRepeat: Int) {}

• ,逗号用于分隔两个参数。
• border、timesToRepeat 为参数名称
• 后跟冒号: 以及类型 String、Int

  if (condition-is-true) {
    execute-this-code
  } else if (condition-is-true) {
    execute-this-code
  } else {
    execute-this-code
  }

when (variable) {
    matches-value -> execute-this-code
    matches-value -> execute-this-code
    ...
}

Kotlin 中的类和继承

类层次结构：一种将类按父级和子级层次结构进行整理的排列方式。层次结构示意图通常会以父级在上、子级在下的方式绘制。
子级或子类：层次结构中位于其他类下方的任意类。
父级、父类或基类：具有一个或多个子类的任意类
根类或顶级类：位于类层次结构顶部（或根部）的类
继承：子类包含（或继承）其父类的所有属性和方法的情况

image.png

在 Kotlin 中，所有类都具有一个通用父类 Any

image.png

抽象类，是一种无法实例化的类。因为它没有完全实现。您可以将其视为一个草图。草图包含关于某些事的想法和计划，但其中的信息通常并不足以完成构建

abstract class Dwelling(private var residents: Int) {
    abstract val buildingMaterial: String
    abstract val capacity: Int

    fun hasRoom(): Boolean {
       return residents < capacity
   }
}

class SquareCabin(residents: Int) : Dwelling(residents) {
    override val buildingMaterial = "Wood"
    override val capacity = 6
}

• 在 SquareCabin 类名称后添加一个冒号 :，后跟用于初始化父级 Dwelling 类的调用，表明此继承关系。不要忘记在 Dwelling 类名称后添加圆括号。

• 使用 super 关键字，引用父类中的函数和属性。

• 使用 override 关键字，在子类中替换属性和函数。

当您使用某个类的特定实例，并需要访问该实例的多个属性和函数时，您可以使用 with 语句表明“对此实例对象执行以下所有操作”

默认情况下，在 Kotlin 中，类是最终层级，无法被子类化。您只能从 abstract 类或标记有 open 关键字的类继承。因此，您需要使用 open 关键字标记 RoundHut 类，使其能够被继承。

Kotlin 中的集合

集合就是指具有相同数据类型的多个对象。Kotlin 中有几种不同的基本集合类型：列表、集和映射

• 列表

只读列表：List一经创建便无法再修改。
可变列表：MutableList创建之后可以进行修改，这意味着您可以添加、移除或更新其元素。

在初始化没有元素的空列表时，Kotlin 无法推断元素类型，因此您必须明确指定类型。

只读列表 不可执行添加、删除等操作，listOf()创建列表

val numbers: List<Int> = listOf(1, 2, 3, 4, 5, 6)
// 简写
val numbers = listOf(1, 2, 3, 4, 5, 6)

使用 Kotlin 标准库函数 listOf() 创建一个新的 List，并将列表中的元素作为参数（用英文逗号分隔）传入。

numbers.first()返回列表的首个元素，而 numbers.last()返回列表的最后一个元素。contains()方法可以查明指定的元素是否在列表中。
返回列表：reversed() 函数会返回元素按照倒序排列的新列表；而 sorted() 函数则会返回元素按照升序排列的新列表。

可变列表 ，mutableListOf()创建列表，可以添加、移除或更改其中的项。同时还可以执行可对只读列表执行的所有操作

val entrees = mutableListOf<String>()
// 另一种写法
val entrees: MutableList<String> = mutableListOf()

add():向列表中添加元素
addAll():向列表中添加多个元素，可直接添加列表
remove():向列表中移除元素
removeAt()：指定要移除的元素的索引
clear()：清除整个列表
Kotlin 提供了 isEmpty()函数来检查列表是否为空

⚠️ 只能向列表中添加正确数据类型的元素，否则会出现编译错误。这是 Kotlin 通过类型安全确保代码更加安全的一种方法。

循环

While 循环

while (index < numberList.size ) {
    // While the expression is true, execute this code block
    total += numberList[index]
    index+=1
}

For 循环

for (number in numberList) {
   // For each element in the list, execute this code block
}

for (item in list) print(item) // Iterate over items in a list

for (item in 'b'..'g') print(item) // Range of characters in an alphabet

for (item in 1..5) print(item) // Range of numbers

for (item in 5 downTo 1) print(item) // Going backward

for (item in 3..6 step 2) print(item) // Prints: 35

• 集

集是一组相关项，但与列表不同，其中不能存在任何重复项，而且顺序也不重要。某个项可以在集中也可以不在集中，但如果在集中，那么集中只能包含该项一个的副本。

列表转集 toSet()

val numbers = listOf(0, 3, 8, 4, 0, 5, 5, 8, 9, 2)
// [0, 3, 8, 4, 0, 5, 5, 8, 9, 2]

val setOfNumbers = numbers.toSet()
// [0, 3, 8, 4, 5, 9, 2]

定义 一个可变集 和 一个不可变集

val set1 = setOf(1,2,3)

val set2 = mutableSetOf(3,2,1)

println("$set1 == $set2: ${set1 == set2}")
// [1, 2, 3] == [3, 2, 1]: true

//即使一个集可变一个集不可变，而且两个集中的项顺序不同，这两个集也被视为相等，因为它们包含完全相同的一组项。

[contains()(https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-set/#functions) 函数检查某个特定项是否包含在集中。 intersect() 或 union() 执行求两个集的交集 (∩) 或并集 (∪) 等运算。

• 映射

映射是一组键值对，用于在给定特定键的情况下轻松查找值。键具有唯一性，每个键只映射到一个值，但值可以重复。映射中的值可以是字符串、数字或对象，甚至可以是列表或集等其他集合。

fun main() {
    val peopleAges = mutableMapOf<String, Int>(
        "Fred" to 30,
        "Ann" to 23
    )
    peopleAges.put("Barbara", 42)
    peopleAges["Joe"] = 51
    println(peopleAges)
}

//{Fred=30, Ann=23, Barbara=42, Joe=51}

forEach使用特殊标识符it，而不是由您为当前项指定变量。
请注意，调用 forEach() 方法时不需要添加圆括号，只需将代码传入花括号 {} 即可

peopleAges.forEach {
 print("${it.key} is ${it.value}, ") 
  //  Fred is 31, Ann is 23, Barbara is 42, Joe is 51, 运行结果多了一个,
}

使用 map()函数，对集合中的每个项应用转换。

println(peopleAges.map { "${it.key} is ${it.value}" }.joinToString(", ") )
//  Fred is 31, Ann is 23, Barbara is 42, Joe is 51

使用 filter()函数，查找符合特定条件的项。filter() 函数根据表达式返回集合中的匹配项。

同样请注意，调用 filter 不需要圆括号，it 表示列表中的当前项。

val filteredNames = peopleAges.filter { it.key.length < 4 }
println(filteredNames)

// {Ann=23, Joe=51}

过滤出集合中以b开头的单词(忽略)，并且打乱顺序后，获取集合中的前2个，然后排序输出

fun main() {
    val words = listOf("about", "acute", "awesome", "balloon", "best", "brief", "class", "coffee", "creative")
    val filteredWords = words.filter { it.startsWith("b", ignoreCase = true) }
        .shuffled()
        .take(2)
        .sorted()
    println(filteredWords)
}

lambda

Kotlin 提供了函数类型，供您根据函数的输入参数和返回值定义特定类型的函数
函数类型示例：(Int) -> Int
具有上述函数类型的函数必须接受类型为 Int 的参数并返回类型为 Int 的值。在函数类型表示法中，参数列于圆括号中（如有多个参数，以英文逗号分隔）。接着是一个箭头 ->，后跟返回值类型。

{ (a: Int) -> a * 3 }


//lambda 存储在变量中
val triple: (Int) -> Int = { a: Int -> a * 3 }

//lambda 只有一个参数的情况很常见，因此 Kotlin 提供了一种简写形式。Kotlin 隐式使用特殊标识符 [`it`](https://kotlinlang.org/docs/reference/lambdas.html#it-implicit-name-of-a-single-parameter) 表示只有一个参数的 lambda 的参数。

val triple: (Int) -> Int = { it * 3 }

高阶函数

指将一个函数（在本例中为 lambda）传递给另一个函数，或从另一个函数返回一个函数。
因此，map、filter 和 forEach 函数都是高阶函数的例子，因为它们都接受函数作为参数

如果要对字符串列表排序，可以使用集合的内置 sorted() 方法。如果要按字符串的长度对列表排序,可以使用 Kotlin 提供的sortedWith()方法

函数类型示例：{str1: String, str2:String -> str1.length - str2.length }

请注意，lambda 中的最后一个表达式是返回值。在本例中，它将返回第一个字符串的长度与第二个字符串的长度之间的差（是一个 Int）。这与排序需要返回的值一致：如果 str1 比 str2 短，将返回一个小于 0 的值。如果 str1 和 str2 长度相同，将返回 0。如果 str1 的长度大于 str2，将返回一个大于 0 的值。通过一系列比较（一次比较两个 Strings），sortedWith() 函数会输出一个列表，其中的名称按长度递增的顺序排列。

val peopleNames = listOf("Fred", "Ann", "Barbara", "Joe")

println(peopleNames.sorted())
// [Ann, Barbara, Fred, Joe]

println(peopleNames.sortedWith { str1: String, str2: String -> str1.length - str2.length })
// [Ann, Joe, Fred, Barbara]