了解Android studio 初学者零基础推荐（3）

kotlin中的数据类及对象

使用泛型创建可重复使用的类

我们将常在线答题考试，有的考试题型包括判断，或者填空，以及数学题，此外试题内容还包括难易程度："easy”,"medium"，"hard",下面我们来定义三种不同类型的问题。

填空题：答案是由string表示的字词

class FillInTheBlankQuestion(
    val questionText: String,
    val answer: String,
    val difficulty: String
) {
    
}

判断题：答案有boolean表示

class TrueOrFalseQuestion(
    val questionText: String,
    val answer: Boolean,
    val difficulty: String
) {
    
}

数学题：答案是数值Int表示

class NumericQuestion(
    val questionText: String,
    val answer: Int,
    val difficulty: String
) {
    
}

以上的三个类基本都是重复代码，不一样的就是answer的类型，如果没想简化写法怎么办？

kotlin提供了一种称为“泛型类型”的元素，可以让单个属性根据特定用例具有不同的数据类型。

那么啥是泛型数据类型？

为属性创建占位符，在实例化类的时候才指定实际的数据类型。

为类定义通用类型的语法如下：

实例化的时候这样写：

注意：这里的泛型属性传入的值一定要和尖括号的数据类型一致哦

重新修改代码：

class Question<T>(
	val questionText: String,
	val answer: T,
	val difficulty: String
) {
    
}

fun main() {
    val q1 = Question<String>("look ___ my eyes","into","medium")
    val q2 = Question<Boolean>("Hu Ge looks very cute. True or False", true, "easy")
    val q3 = Question<Int>("1+1=_",2,"hard")
}

枚举类

枚举类定义：

枚举类常量访问：

enum class Difficulty {
    EASY, MEDIUM, HARD
}
class Question<T>(
	val questionText: String,
	val answer: T,
	val difficulty: Difficulty
) {
    
}

fun main() {
    val q1 = Question<String>("look ___ my eyes","into",Difficulty.MEDIUM)
    val q2 = Question<Boolean>("Hu Ge looks very cute. True or False", true, Difficulty.EASY)
    val q3 = Question<Int>("1+1=_", 2, Difficulty.HARD)
}

数据类

像Question 这样的类，只包含数据，没有用于操作的各种什么方法，像这种类就可以称作数据类，数据类的对象可以使用toString，如何将Question变成数据类呢？那就是在class前加上data关键字。

data class Question<T>(
    val questionText: String,
    val answer: T,
    val difficulty: Difficulty
)

fun main() {
    val question1 = Question<String>("Quoth the raven ___", "nevermore", Difficulty.MEDIUM)
    val question2 = Question<Boolean>("The sky is green. True or false", false, Difficulty.EASY)
    val question3 = Question<Int>("How many days are there between full moons?", 28, Difficulty.HARD)
    println(question1.toString()) //输出为:Question(questionText=Quoth the raven ___, answer=nevermore, difficulty=MEDIUM)
}

将某个类定义为数据类后，系统会实现以下方法。

equals()
hashCode()：在使用某些集合类型时，您会看到此方法。
toString()
componentN()：component1()、component2() 等
copy()

单例对象

给硬件设备做测试的时候，因为要修改配置，这种配置不能多人修改，硬件设备只能一个人使用的情况等。那么如何创建单例对象？

单例对象和创建class十分相似，就是把class 变成object，注意单例对象没有构造函数，因为我们没法直接创建实例，所有属性都要在大括号内定义并被赋予初始值。

object StudentProgress {
    var total: Int = 10
    var answered: Int = 3
}

访问单例对象：

fun main() {
    ...
    println("${StudentProgress.answered} of ${StudentProgress.total} answered.")
}

伴生对象

您可以使用“伴生对象”在另一个类中定义单例对象。伴生对象允许您从类内部访问其属性和方法（如果对象的属性和方法属于相应类的话），从而让语法变得更简洁。

如需声明伴生对象，只需在 object 关键字前面添加 companion 关键字即可。

class Quiz {
    val question1 = Question<String>("Quoth the raven ___", "nevermore", Difficulty.MEDIUM)
    val question2 = Question<Boolean>("The sky is green. True or false", false, Difficulty.EASY)
    val question3 = Question<Int>("How many days are there between full moons?", 28, Difficulty.HARD)

    companion object StudentProgress {
        var total: Int = 10
        var answered: Int = 3
    }
}

fun main() {
    println("${Quiz.answered} of ${Quiz.total} answered.")
}

扩展属性

如果现在要给Quiz添加一个显示完成情况的属性，我们应该怎么做呢？那就是使用扩展属性，语法如下：

val Quiz.StudentProgress.progressText: String
    get() = "${answered} of ${total} answered"

fun main() {
    println(Quiz.progressText)
}

扩展函数

fun Quiz.StudentProgress.printProgressBar() {
    repeat(Quiz.answered) { print("▓") }
    repeat(Quiz.total - Quiz.answered) { print("▒") }
    println()
    println(Quiz.progressText)
}
fun main() {
    Quiz.printProgressBar()
}

使用重写的扩展函数

如果您需要多个类具有相同的额外属性和方法（可能是行为方式不同），就可以使用接口定义这些属性和方法。

接口使用 interface 关键字定义，后跟大驼峰式命名法 (UpperCamelCase) 名称，再跟左大括号和右大括号。在大括号内，您可以定义任何符合接口标准的类必须实现的方法签名或 get-only 属性。

接口是一种协定。系统会声明符合接口规范的类以扩展接口。类可以声明它想用“冒号 (:) 后跟一个空格，再跟接口名称”的形式来扩展接口。

interface ProgressPrintable {
    val progressText: String
    fun printProgressBar()
}

在 Quiz 类中，使用 override 关键字添加 printProgressBar() 方法

class Quiz : ProgressPrintable {
    override val progressText: String
        get() = "${answered} of ${total} answered"



    override fun printProgressBar() {
        repeat(Quiz.answered) { print("▓") }
        repeat(Quiz.total - Quiz.answered) { print("▒") }
        println()
        println(progressText)
    }
}

作用域函数访问类的属性和方法

使用 `let()` 替换过长的对象名称

向 Quiz 类添加一个名为 printQuiz() 的函数。

fun printQuiz() {
    println(question1.questionText)
    println(question1.answer)
    println(question1.difficulty)
    println()
    println(question2.questionText)
    println(question2.answer)
    println(question2.difficulty)
    println()
    println(question3.questionText)
    println(question3.answer)
    println(question3.difficulty)
    println()
}

使用let以后可以简化为：

fun printQuiz() {
    println(question1.questionText)
    println(question1.answer)
    println(question1.difficulty)
    println()
    println(question2.questionText)
    println(question2.answer)
    println(question2.difficulty)
    println()
    println(question3.questionText)
    println(question3.answer)
    println(question3.difficulty)
    println()
}

使用 apply() 在没有变量的情况下调用对象方法

作用域函数有一项非常棒的功能，那就是即使尚未将某个对象分配到变量，您也可以对此对象调用作用域函数。例如，apply() 函数是一个扩展函数，可通过点表示法调用对象。apply() 函数还会返回对相应对象的引用，以便将其存储在变量中。

在创建 Quiz 类的实例时，请在右圆括号后面调用 apply()。您可以在调用 apply() 时省略圆括号，并使用尾随 lambda 语法。

val quiz = Quiz().apply {
}

将对 printQuiz() 的调用移至 lambda 表达式内。您无需再引用 quiz 变量或使用点表示法。

val quiz = Quiz().apply {
    printQuiz()
}

apply() 函数会返回 Quiz 类的实例，但由于您在任何位置都不再使用此实例了，因此请移除 quiz 变量。借助 apply() 函数，您甚至无需变量即可对 Quiz 实例调用方法。

Quiz().apply {
    printQuiz()
}

集合

集合可以创建Android的常见功能，例如滚动列表，以及解决任意数量数据的实际编程问题。

数组

同一数据类型的一系列值，有序，可以通过索引访问。什么是索引？索引是与数组中的某个元素对应的整数。索引可以指示某个项与数组起始元素之间的距离。这称为“零索引”。数组的第一个元素位于索引 0 处，第二个元素位于索引 1 处，因为它与第一个元素相距一个位置，以此类推。

在设备的内存中，数组中的元素彼此相邻地存储在一起。虽然底层细节不在本 Codelab 的讨论范围之内，但这有两个重要影响：

通过索引可以快速地访问数组元素。您可以通过索引访问数组的任何随机元素，并且访问任何其他随机元素预计需要大约相同的时间。因此，有人说数组具有随机访问特性。
数组具有固定的大小。这意味着您向数组添加元素时不能超过该数组的大小。如果尝试访问某个数组（包含 100 个元素）中位于索引 100 处的元素，则会引发异常，因为最高索引为 99（请注意，第一个索引为 0，而不是 1）。但是，您可以修改数组中位于相关索引处的值。
如果想增加数组的大小只能重新创建这个数组

如需在代码中声明数组，请使用 arrayOf() 函数。

fun main() {
    val rockPlanets = arrayOf<String>("Mercury", "Venus", "Earth", "Mars")
    val gasPlanets = arrayOf<String>("Jupiter","Saturn","Uranus","Neptune")
    val solarSystem = rockPlanets + gasPlanets
    println(solarSystem[0])
}

列表

列表是有序且可调整大小的集合，通常作为可调整大小的数组实现。当数组达到容量上限时，如果您尝试插入新元素，需要将该数组复制到一个新的较大数组。

使用列表，您还可以在特定索引处（介于其他元素之间）插入新元素。

上图显示了在列表中添加和移除元素的方式。在大多数情况下，无论列表中包含多少个元素，向列表中添加任何元素所需的时间都是相同的。每隔一段时间，如果添加新元素会使数组超出其定义的大小，那么数组元素可能必须移动，以便为新元素腾出空间。列表会为您执行所有这些操作，但在后台，它只是一个在需要时换成新数组的数组。

`List` 和 `MutableList`

您在 Kotlin 中遇到的集合类型会实现一个或多个接口。正如您在本单元前面的泛型、对象和扩展 Codelab 中所学到的，接口提供了一组供类实现的标准属性和方法。实现 List 接口的类可为 List 接口的所有属性和方法提供实现。MutableList 也是如此。

List 和 MutableList 有什么用？

List 是一个接口，用于定义与只读有序项集合相关的属性和方法。
MutableList 通过定义修改列表的方法（例如添加和移除元素）来扩展 List 接口。

这些接口仅指定 List 和/或 MutableList 的属性和方法。每个属性和方法的实现方式均由扩展这些接口的类决定。上述基于数组的实现将是您最常使用（如果不是始终使用）的实现，但 Kotlin 允许其他类扩展 List 和 MutableList。

`listOf()` 函数

与 arrayOf() 类似，listOf() 函数将相关项作为形参，但返回 List，而不是数组。

从 main() 中移除现有代码。
在 main() 中，通过调用 listOf() 创建名为 solarSystem 的行星 List。

fun main() {
    val solarSystem = listOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")
}

List 具有 size 属性，用于获取列表中的元素数量。输出 solarSystem 列表的 size。

println(solarSystem.size)

运行代码。列表的大小应为 8。

访问列表中的元素

与数组一样，您可以使用下标语法从 List 访问特定索引处的元素。您可以使用 get() 方法执行相同的操作。下标语法和 get() 方法接受 Int 作为参数，并在该索引处返回相应元素。与 Array 一样，ArrayList 也为零索引，因此第四个元素位于索引 3 处。

使用下标语法输出索引 2 处的行星。

println(solarSystem[2])

通过对 solarSystem 列表调用 get()，输出索引 3 处的元素。

println(solarSystem.get(3))

运行代码。索引 2 处的元素为 "Earth"，索引 3 处的元素为 "Mars"。

...
Earth
Mars

除了按索引获取元素之外，您还可以使用 indexOf() 方法搜索特定元素的索引。indexOf() 方法在列表中搜索指定元素（作为实参传入），并返回该元素在第一次出现时的索引。如果该元素未出现在列表中，则返回 -1。

输出对 solarSystem 列表调用 indexOf() 并传入 "Earth" 的结果。

println(solarSystem.indexOf("Earth"))

调用 indexOf()，传入 "Pluto"，并输出结果。

println(solarSystem.indexOf("Pluto"))

运行代码。某个元素与 "Earth" 匹配，因此输出索引 2。没有与 "Pluto" 匹配的元素，因此输出 -1。

...
2
-1

使用 `for` 循环遍历列表元素

在学习函数类型和 lambda 表达式时，您已经了解如何使用 repeat() 函数多次执行代码。

编程中的一项常见任务是对列表中的每个元素执行一次某个任务。Kotlin 包含一个名叫 for 循环的功能，可利用简洁易懂的语法来实现此目的。这通常称为“循环遍历”列表或“遍历”列表。

向列表中添加元素

只有实现 MutableList 接口的类具有在集合中添加、移除和更新元素的功能。如果您一直在跟踪新发现的行星，则可能需要能够经常向列表中添加元素。在创建要向其中添加元素和从中移除元素的列表时，您需要专门调用 mutableListOf() 函数，而不是 listOf()。

add() 函数有两个版本：

第一个 add() 函数具有一个属于列表中元素类型的参数，并将其添加到列表末尾。
add() 的另一个版本有两个参数。第一个参数对应于应该插入新元素的索引。第二个参数是要添加到列表中的元素。

我们来看看实际用例。

将 solarSystem 的初始化更改为调用 mutableListOf()，而不是 listOf()。您现在可以调用 MutableList 中定义的方法。

val solarSystem = mutableListOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")

同样，我们也可能需要将 Pluto 归类为行星。对 solarSystem 调用 add() 方法，传入 "Pluto" 作为单个参数。

solarSystem.add("Pluto")

有些科学家提出一种理论：过去曾有一颗名为 Theia 的行星，该行星后来与地球发生碰撞并形成月球。在索引 3（介于 "Earth" 和 "Mars" 之间）处插入 "Theia"。

solarSystem.add(3, "Theia")

更新特定索引处的元素

您可以使用下标语法更新现有元素：

将索引 3 处的值更新为 "Future Moon"。

solarSystem[3] = "Future Moon"

使用下标语法输出位于索引 3 和 9 处的值。

println(solarSystem[3])
println(solarSystem[9])

运行代码，验证输出。

Future Moon
Pluto

从列表中移除元素

使用 remove() 或 removeAt() 方法可移除元素。您可以通过两种方法移除元素：将该元素传递到 remove() 方法中，或者使用 removeAt() 按索引移除该元素。

我们来看下这两种元素移除方法的实际操作效果。

对 solarSystem 调用 removeAt()，并传入索引 9。这应该会从列表中移除 "Pluto"。

solarSystem.removeAt(9)

对 solarSystem 调用 remove()，并传入 "Future Moon" 作为要移除的元素。此操作应该会搜索此列表，如果找到匹配元素，则会将其移除。

solarSystem.remove("Future Moon")

List 可提供 contains() 方法，该方法可在列表中存在某个元素时返回 Boolean。输出为 "Pluto" 调用 contains() 的结果。

println(solarSystem.contains("Pluto"))

更简洁的语法是使用 in 运算符。您可以使用元素、in 运算符和集合来检查该元素是否在列表中。使用 in 运算符检查 solarSystem 是否包含 "Future Moon"。

println("Future Moon" in solarSystem)

运行代码。两个语句都应输出 false。

...
false
false

集

集是指没有特定顺序且不允许出现重复值的集合。

在 Kotlin 中使用 `MutableSet`

在本示例中，我们将使用 MutableSet 来演示如何添加和移除元素。

从 main() 中移除现有代码。
使用 mutableSetOf() 创建名为 solarSystem 的行星 Set。这将返回 MutableSet，其默认实现为 LinkedHashSet()。

val solarSystem = mutableSetOf("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune")

使用 size 属性输出该集的大小。

println(solarSystem.size)

与 MutableList 类似，MutableSet 具有 add() 方法。使用 add() 方法将 "Pluto" 添加到 solarSystem 集。它只需要为所添加的元素使用一个参数。集中的元素未必是有序的，因此没有索引！

solarSystem.add("Pluto")

添加相应元素后，输出该集的 size。

println(solarSystem.size)

contains() 函数接受一个参数，并检查该集中是否包含指定的元素。如果是，则返回 true。否则，它将返回 false。调用 contains() 以检查 "Pluto" 是否在 solarSystem 中。

println(solarSystem.contains("Pluto"))

运行代码。大小已增大，contains() 现在会返回 true。

8
9
true

注意：您也可以使用 in 运算符检查某个元素是否在集合中，例如："Pluto" in solarSystem 相当于 solarSystem.contains("Pluto")。

如前所述，集不能包含重复项。请尝试重新添加 "Pluto"。

solarSystem.add("Pluto")

再次输出集的大小。

println(solarSystem.size)

再次运行您的代码。未添加 "Pluto"，因为它已包含在集中。这次，大小应该不会增加。

...
9

remove() 函数接受一个参数，并从集中移除指定的元素。

使用 remove() 函数移除 "Pluto"。

solarSystem.remove("Pluto")

注意：请记住，集是无序的集合。您无法按索引从集中移除某个值，因为集没有索引。

输出集合的大小，并再次调用 contains() 以检查 "Pluto" 是否仍在集中。

println(solarSystem.size)
println(solarSystem.contains("Pluto"))

运行代码。"Pluto" 不在集中，大小现在为 8。

...
8
false

映射集合

Map 是由键和值组成的集合。之所以称之为映射，是因为唯一键会映射到其他值。键及其附带的值通常称为 key-value pair。

映射的键具有唯一性，但映射的值不具有唯一性。两个不同的键可以映射到同一个值。例如，"Mercury" 有 0 颗卫星，"Venus" 也有 0 颗卫星。

通过相应的键访问映射的值通常比在大型列表中（例如使用 indexOf()）搜索值更快。

您可以使用 mapOf() 或 mutableMapOf() 函数声明映射。映射需要两个泛型类型（以英文逗号隔开），一个用于键，另一个用于值。

如果映射具有初始值，则还可以使用类型推断。要使用初始值填充映射，每个键值对都由以下部分组成：首先是键，后跟 to 运算符，而后是值。每个键值对均以英文逗号隔开。

接下来，我们详细了解一下如何使用映射，以及一些有用的属性和方法。

从 main() 中移除现有代码。
使用 mutableMapOf() 和如下初始值创建一个名为 solarSystem 的映射。

val solarSystem = mutableMapOf(
    "Mercury" to 0,
    "Venus" to 0,
    "Earth" to 1,
    "Mars" to 2,
    "Jupiter" to 79,
    "Saturn" to 82,
    "Uranus" to 27,
    "Neptune" to 14
)

与列表和集一样，Map 提供包含键值对数量的 size 属性。输出 solarSystem 映射的大小。

println(solarSystem.size)

您可以使用下标语法设置其他键值对。将 "Pluto" 键的值设置为 5。

solarSystem["Pluto"] = 5

插入元素后，再次输出大小。

println(solarSystem.size)

您可以使用下标语法来获取值。输出键 "Pluto" 的卫星数量。

println(solarSystem["Pluto"])

您还可以使用 get() 方法访问值。无论您使用下标语法还是调用 get()，您传入的键都可能不存在于映射中。如果没有键值对，它将返回 null。输出 "Theia" 的卫星数量。

println(solarSystem.get("Theia"))

运行代码。系统应该会输出 Pluto 的卫星数量。不过，由于 Theia 不在映射中，因此调用 get() 会返回 null。

8
9
5
null

remove() 方法可移除具有指定键的键值对。它也会返回已移除的值，或者如果指定的键不在映射中，则返回 null。

输出调用 remove() 并传入 "Pluto" 的结果。

solarSystem.remove("Pluto")

若要验证相应项是否已移除，请再次输出大小。

println(solarSystem.size)

运行代码。移除该条目后，映射的大小将为 8。

...
8

下标语法或 put() 方法也可以修改已存在的键的值。使用下标语法将 Jupiter 的卫星数量更新为 78，并输出新值。

solarSystem["Jupiter"] = 78
println(solarSystem["Jupiter"])

运行代码。现有键 "Jupiter" 的值已更新。

...
78