三篇文章带你快速入门Kotlin（上）

Cache技术分享
VIP.5 如鱼得水
374 阅读16分钟

三篇文章带你快速入门Kotlin（上）

Kotlin的发展历程

2011年，JetBrains发布了Kotlin的第一个版本，并在2012年将其开源。

2016年Kotlin发布了1.0正式版，代表着Kotlin语言已经足够成熟和稳定了，并且JetBrains也在自家的旗舰IDE开发工具IntelliJ IDEA中加入了Kotlin的支持。

2017年Google宣布Kotlin正式成为Android开发一级语言，并且Android Studio也加入了对Kotlin的支持。

2019年Google正式宣布了Kotlin First，未来提供的官方API也将会以Kotlin版本为主。

Kotlin相比于Java的优势

语法更加简洁，对于同样的功能，使用Kotlin开发的代码量可能会比使用Java开发的减少50%甚至更多。

语法更加高级，相比于Java比较老旧的语法，Kotlin增加了很多现代高级语言的语法特性，使得开发效率大大提升。

语言更加安全，Kotlin几乎杜绝了空指针这个全球崩溃率最高的异常。

和Java是100%兼容的，Kotlin可以直接调用使用Java编写的代码，也可以无缝使用Java第三方的开源库。这使得Kotlin在加入了诸多新特性的同时，还继承了Java的全部财富。

Kotlin的工作原理

Kotlin可以做到和Java 100%兼容，这主要是得益于Java虚拟机的工作机制。

其实Java虚拟机并不会直接和你编写的Java代码打交道，而是和编译之后生成的class文件打交道。

而Kotlin也有一个自己的编译器，它可以将Kotlin代码也编译成同样规格的class文件。

Java虚拟机不会关心class文件是从Java编译来的，还是从Kotlin编译来的，只要是符合规格的class文件，它都能识别。

也正是这个原因，JetBrains才能以一个第三方公司的身份设计出一门用来开发Android应用程序的编程语言。

函数和变量

变量

Kotlin中定义一个变量，只允许在变量前声明两种关键字：val和var。

  • val（value的简写的简写）用来声明一个不可变的变量，这种变量在初始赋值之后就再也不能重新赋值，对应Java中的final变量。

  • var（variable的简写的简写）用来声明一个可变的变量，这种变量在初始赋值之后仍然可以再被重新赋值复制，对应Java中的非final变量。

    fun main() {
    val a = 10
    var b = 5
    b = b + 3
    println("a = " + a)
    println("b = " + b)
}

内嵌表达式

在Kotlin中，我们可以直接将表达式写在字符串里面，即使是构建非常复杂的字符串，也会变得轻而易举。

Kotlin中字符串内嵌表达式的语法规则如下：

"hello, ${obj.name}. nice to meet you!"

当表达式中仅有一个变量的时候，还可以将两边的大括号省略：

"hello, $name. nice to meet you!"

函数

定义一个函数的语法规则如下：

fun methodName(param1: Int, param2: Int): Int {
      return 0
}

当一个函数的函数体中只有一行代码时，可以使用单行代码函数的语法糖：

fun methodName(param1: Int, param2: Int) = 0

使用这种写法，可以直接将唯一的一行代码写在函数定义的尾部，中间用等号连接即可

return关键字也可以省略，等号足以表达返回值的意思。

Kotlin还拥有出色的类型推导机制，可以自动推导出返回值的类型。

逻辑控制

if条件语句

fun largerNumber4(num1: Int, num2: Int): Int {
    val value = if (num1 > num2) {
        num1
    } else {
        num2
    }
    return value
}

Kotlin中的if语句相比于Java有一个额外的功能：它是可以有返回值的，返回值就是if语句每一个条件中最后一行代码的返回值。

fun largerNumber(num1: Int, num2: Int): Int {
    val value = if (num1 > num2) {
        num1
    } else {
        num2
    }
    return value
}

仔细观察上述代码，你会发现value其实是一个多余的变量，我们可以直接将if语句返回，这样代码将会变得更加精简，如下所示：

fun largerNumber(num1: Int, num2: Int): Int {
    return if (num1 > num2) {
        num1
    } else {
        num2
    }
}

当一个函数只有一行代码时，可以省略函数体部分，直接将这一行代码使用等号串连在函数定义的尾部。虽然largerNumber()函数不止只有一行代码，但是它和只有一行代码的作用是相同的，只是return了一下if语句的返回值而已，符合该语法糖的使用条件。那么我们就可以将代码进一步精简：

fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) {
    num1
} else {
    num2
}

最后，还可以将上述代码再精简一下，直接压缩成一行代码：

fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) num1 else num2

when条件语句

当需要判断的条件非常多的时候，可以考虑使用when语句来替代if语句。

类似与switch语句又远比switch语句强大的多

分支可以时表达式，也可以时具体数值。

fun getScore1(name: String) = when (name) {
    "Tom" -> 86
    "Jack" -> 77
    "Jim" -> 33
    "Lily" -> 44
    else -> 0
}

高级用法:when不带参数写法，不常用，但是扩展性很强

fun getScore2(name: String) = when {
    name == "Tom" -> 86
    name.equals("Jack") -> 77
    name.endsWith("Jim") -> 33
    name.startsWith("Lily") -> 44
    else -> 0
}

when不带参数，多参数

fun getScore3(name: String, name1: String) = when {
    name == "Tom" -> 86
    name.equals("Jack") -> 77
    name1.endsWith("Jim") -> 33
    name1.startsWith("Lily") -> 44
    else -> 0
}

for-in循环语句

我们可以使用如下Kotlin代码来表示一个区间：

val range = 0..10

上述代码表示创建了一个0到10的区间，并且两端都是闭区间，这意味着0到10这两个端点都是包含在区间中的，用数学的方式表达出来就是[0, 10]。

也可以使用until关键字来创建一个左闭右开的区间：

val range = 0 until 10

如果你想跳过其中的一些元素，可以使用step关键字：

fun main() {
    for (i in 0 until 10 step 2) {
        println(i)
    }
}

如果你想创建一个降序的区间，可以使用downTo关键字：

fun main() {
    for (i in 10 downTo 1) {
        println(i)
    }
}

控制循环语句Break

退出当前循环

@ 标签可以指定退出外层循环

fun for(){
    out@ for (i in 0..5) {
        println("i$i")
        for (j in 0..3) {
            println("j$j")
            if (j == 1) {
                break@out
            }
        }
    }
}

控制循环语句Continue

退出本次循环

fun for(){
    out@ for (i in 0..5) {
        println("i$i")
        for (j in 0..3) {
            println("j$j")
            if (j == 1) {
                continue@out
            }
        }
    }
}

面向对象编程

类与对象

可以使用如下代码定义一个类，以及声明它所拥有的字段和函数：

class Person {
    var name = ""
    var age = 0
    fun eat() {
        println("name:" + name + " age:" + age)
    }
}

然后使用如下代码创建对象，并对对象进行操作：

fun main() {
    val p = Person()
    p.name = "yx"
    p.age = 66
    p.eat()
}

继承

Kotlin中一个类默认是不可以被继承的，如果想要让一个类可以被继承，需要主动声明open关键字：

open class Person {
    …
}

要让另一个类去继承Person类，则需要使用冒号关键字：

class Student : Person() {
    var sno = ""
    var grade = 0
}

现在Student类中就自动拥有了Person类中的字段和函数，还可以定义自己独有的字段和函数。

构造器

  • 主构造器

constructor 关键字如果没有任何注解或修饰可以省略

如果没有为非抽象类定义任何主次构造器，系统会提供一个无参数的主构造器。默认修饰为public

一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器

  • 次构造器

任何一个类只能有一个主构造函数，但可以有多个次构造函数

如果定义了主构造器，那么次构造器必须委托主构造器

如果没有定义柱构造器则不用委托主构造器

class Student(val sno: String, val grade: Int) : Person() {
    init {
        println("sno:$sno")
        println("grade:$grade")
    }
}

init 关键字为初始化时回调的逻辑块

接口

Kotlin中定义接口的关键字和Java中是相同的，都是使用的interface：

interface Study {
    fun readBooks()
    fun doHomework()
}

而Kotlin中实现接口的关键字变量了冒号，和继承使用的是同样的关键字：

class Artist(var name: String) : Study {
    override fun readBook() {
        println("name：$name readBook")
    }

    override fun doHomework() {
        println("name：$name doHomework")
    }
}

数据类

Kotlin中使用data关键字可以定义一个数据类：

data class Cellphone(val brand: String, val price: Double)

Kotlin会根据数据类的主构造函数中的参数将equals()、hashCode()、toString()等固定且无实际逻辑意义的方法自动生成，从而大大简少了开发的工作量。

data class CellPhone(val brand: String, val price: Double)

class Cellphone1(val brand: String, val price: Double)

fun main() {

    val str = "{'userCode':'demo','userName':'Demo Group'}"
    val a = EncryptUtils.decryptBase64AES(
        str.toByteArray(),
        "PHA".toByteArray(),
        "CBC",
        "".toByteArray()
    )
    println(a)


    val cellPhone1 = CellPhone("apple", 1000.0)
    val cellPhone2 = CellPhone("apple", 1000.0)
    println(cellPhone1)
    println(cellPhone1 == cellPhone2)

    val cellPhone3 = Cellphone1("apple", 1000.0)
    val cellPhone4 = Cellphone1("apple", 1000.0)
    println(cellPhone3)
    println(cellPhone3 == cellPhone4)
}

单例类

Kotlin中使用object关键字可以定义一个单例类：

object Singleton {
    fun singletonTest() {
        println("singletonTest is called.")
    }
}

而调用单例类中的函数比较类似于Java中静态方法的调用方式：

Singleton.singletonTest()

这种写法虽然看上去像是静态方法的调用，但其实Kotlin在背后自动帮我们创建了一个Singleton类的实例，并且保证全局只会存在一个Singleton实例。

集合

集合的创建

使用如下代码可以初始化一个List集合：

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")

使用如下代码可以初始化一个Set集合：

val set = setOf("Apple", "Banana", "Orange", "Pear", "Grape")

使用如下代码可以初始化一个Map集合

val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)

集合的取值

fun mutableList() {
    val list = mutableListOf("apple", "banana", "orange", "pear", "grape")
    list.add("other")
    for (fruit in list) {
        println(fruit)
    }
}

SetOf集合，去重的集合，底层是map 所以可以去重

fun setList() {
    val list = setOf("apple", "banana", "orange", "pear", "grape")

    for (fruit in list) {
        println(fruit)
    }
}

map 集合 java写法:键值对一对一

fun mapList() {
    val map = HashMap<String, Int>()
    map.put("apple", 1)
    map.put("banana", 2)
}

kotlin 可以用[]

fun mapListKotlin() {
    val map = HashMap<String, Int>()
    map["apple"] = 2
    map["banana"] = 1
    val number = map["apple"]
}

最简洁的写法 mapOf不可变,mutableMapOf可变

fun mapListKotlin1() {
    val map = mapOf("apple" to 1, "banana" to 2, "orange" to 3)

    val map1 = mutableMapOf("apple" to 1, "banana" to 2, "orange" to 3)
    map1["watermelon"] = 6
    for ((fruit, number) in map1) {
        println("mutable" + fruit + number)
    }
}

Lambda编程

Lambda就是一小段可以作为参数传递的代码。正常情况下，我们向某个函数传参时只能传入变量，而借助Lambda却允许传入一小段代码。

我们来看一下Lambda表达式的语法结构：

{参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}

首先最外层是一对大括号，如果有参数传入到Lambda表达式中的话，我们还需要声明参数列表，参数列表的结尾使用一个->符号，表示参数列表的结束以及函数体的开始，函数体中可以编写任意行代码，并且最后一行代码会自动作为Lambda表达式的返回值。

集合的函数式API

集合中的map函数是最常用的一种函数式API，它用于将集合中的每个元素都映射成一个另外的值，映射的规则在Lambda表达式中指定，最终生成一个新的集合。比如，这里我们希望让所有的水果名都变成大写模式，就可以这样写：

fun main() {
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
    val newList = list.map({ fruit: String -> fruit.toUpperCase() })
    for (fruit in newList) {
        println(fruit)
    }
}
  • 当Lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括号的外面。
  • 如果Lambda参数是函数的唯一一个参数的话，还可以将函数的括号省略。
  • 由于Kotlin拥有出色的类型推导机制，Lambda表达式中的参数列表其实在大多数情况下也不必声明参数类型。
  • 当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替。

因此，Lambda表达式的写法可以进一步简化成如下方式：

val newList = list.map { it.toUpperCase() }

推导过程

fun lambda1() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")
    val max = list.maxByOrNull { it.length }
    println(max)
}

maxByOrNul实际上它一个普通函数,只不过它接受的是一个Lambda类型参数,每次集合遍历时把遍历的值作为参数传递给lambda表达式,工作原理就是找到最长值并返回

fun lambda2() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")
    val lambda = { fruit: String -> fruit.length }
    val max = list.maxByOrNull(lambda)
    println(max)
}

可直接将lambda表达式传入maxByOrNull函数中

fun lambda3() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")

    val max = list.maxByOrNull({ fruit: String -> fruit.length })
    println(max)
}

Kotlin规定，当lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括号外边

fun lambda4() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")

    val max = list.maxByOrNull() { fruit: String -> fruit.length }
    println(max)
}

Kotlin规定，如果Lambda参数是函数的唯一一个参数的话，还可以讲函数的括号省略

fun lambda5() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")

    val max = list.maxByOrNull { fruit: String -> fruit.length }
    println(max)
}

Kotlin有出色的类推导机制，大多数的情况下不必声明参数的类型

fun lambda6() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")

    val max = list.maxByOrNull { fruit -> fruit.length }
    println(max)
}

Kotlin规定，当lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替

fun lambda7() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")

    val max = list.maxByOrNull { it.length }
    println(max)
}

其他集合函数API:

使用map函数转换为大写

fun lamdabMap() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")
    var newList = list.map { it.toUpperCase() }
}

filter函数过滤集合中的元素,这里注意调用顺序 先map 在filter 效率会低

fun lamdabMapFilter() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")
    var newList = list.filter { it.length <= 5 }.map { it.toUpperCase() }
}

any函数用于判断集合中至少存在一个元素满足条件

all函数判断集合中所有元素满足条件

这样是不是比每次循环方便多了

fun lamdabAnyAll() {
    val list = listOf("apple", "banana", "orange", "pear", "grape", "other")
    val any = list.any { it.length <= 5 }
    val all = list.all { it.length <= 5 }
}

Java函数式API

如果我们在Kotlin代码中调用了一个Java方法，并且该方法接收一个Java单抽象方法接口参数，就可以使用函数式API。Java单抽象方法接口指的是接口中只有一个待实现方法，如果接口中有多个待实现方法，则无法使用函数式API。

举个例子，Android中有一个极为常用的点击事件接口OnClickListener，其定义如下：

public interface OnClickListener {
     void onClick(View v);
}

可以看到，这是一个单抽象方法接口。假设现在我们拥有一个按钮button的实例，就可以使用函数式API的写法来注册这个按钮的点击事件：

button.setOnClickListener { v ->
}

推导过程

fun lmClass() {
    Thread(object : Runnable {
        override fun run() {
            println("Thead is run")
        }
    }).start()
}

Runnable只有一个待实现方法，这里没有显示地重写run方法kotlin自动明白runnable后面的lambda表达式就是在run中的实现内容

fun lmClass1() {
    Thread(Runnable {
        println("Thead is run")
    }).start()
}

java方法的参数列表不存在一个以上java单抽象方法接口参数，还可以将接口名省略

fun lmClass2() {
    Thread({
        println("Thead is run")
    }).start()
}

当lambda表达式是方法的最后一个参数时，可以将lambda表达式移到方法括号外面


fun lmClass3() {
    Thread() {
        println("Thead is run")
    }.start()
}

同时lambda表大会还是方法的唯一一个参数，还可以方法的括号省略


fun lmClass4() {
    Thread {
        println("Thead is run")
    }.start()
}

空指针检查

空指针是一种不受编程语言检查的运行时异常，只能由程序员主动通过逻辑判断来避免，但即使是最出色的程序员，也不可能将所有潜在的空指针异常全部考虑到。

public void doStudy(Study study) {
    study.readBooks();
    study.doHomework();
}

这段Java代码安全吗？不一定，因为这要取决于调用方传入的参数是什么，如果我们向doStudy()方法传入了一个null参数，那么毫无疑问这里就会发生空指针异常。因此，更加稳妥的做法是在调用参数的方法之前先进行一个判空处理，如下所示：

public void doStudy(Study study) {
    if (study != null) {
        study.readBooks();
        study.doHomework();
    }
}

可空类型系统

Kotlin中引入了一个可空类型系统的概念，它利用编译时判空检查的机制几乎杜绝了空指针异常。

fun doStudy(study: Study) {
    study.readBooks()
    study.doHomework()
}

这段代码看上去和刚才的Java版本并没有什么区别，但实际上它是没有空指针风险的，因为Kotlin默认所有的参数和变量都不可为空，所以这里传入的Study参数也一定不会为空，可以放心地调用它的任何函数。

Kotlin提供了另外一套可为空的类型系统，就是在类名的后面加上一个问号。比如，Int表示不可为空的整型，而Int?就表示可为空的整型；String表示不可为空的字符串，而String?就表示可为空的字符串。

使用可为空的类型系统时，需要在编译时期就把所有的空指针异常都处理掉才行。

判空辅助工具

Kotlin提供了一系列的辅助工具，使开发者能够更轻松地进行判空处理。

?. 操作符表示当对象不为空时正常调用相应的方法，当对象为空时则什么都不做。比如：

if (a != null) {
    a.doSomething()
}

这段代码使用?.操作符就可以简化成：

a?.doSomething()

?: 操作符表示如果左边表达式的结果不为空就返回左边表达式的结果，否则就返回右边表达式的结果。比如：

val c = if (a ! = null) {
    a
} else {
    b
}

这段代码的逻辑使用?:操作符就可以简化成：

val c = a ?: b

kotlin并非总是那么智能如下

我们发现一个可空的全局变量，在contextNull已经判断为空却报错kotlin识别不了

!!:我们使用强制判断不为空!!非空断言工具

var content: String? = "hello"
fun contextNull() {
    if (content != null) {
        upCase()
    }
}
fun upCase() {
    val upcase = content!!.toUpperCase()
    println(upcase)
}

结合使用?.操作符和let函数也可以对多次重复调用的某个变量统一进行判空处理

fun doStudy(study: Study?) {
    study?.let {
        it.readBooks()
        it.doHomework()
    }
}

取文本长度的函数

fun getTextLength(text: String?): Int {
    if (text != null) {
        return text.length
    }
    return 0
}

简写为:由于text可为空?.判断返回null借助?:返回0

fun getTextLength1(text: String?) = text?.length ?: 0

函数默认值

Kotlin允许在定义函数的时候给任意参数设定一个默认值，这样当调用此函数时就不会强制要求调用方为此参数传值，在没有传值的情况下会自动使用参数的默认值。语法格式如下：

fun printParams(num: Int, str: String = "hello") {
    println("num is $num , str is $str")
}

这里给printParams()函数的第二个参数设定了一个默认值，这样当调用printParams()函数时，可以选择给第二个参数传值，也可以选择不传，在不传的情况下就会自动使用默认值。

示例：

fun params(num: Int, str: String = "Hello") {
    println("num $num str $str")
}

fun params1(num: Int = 100, str: String) {
    println("num $num str $str")
}

fun params2(num: Int = 100, str: String = "Hello") {
    println("num $num str $str")
}

给构造函数传入默认入参,可以默认不传入参数


class Student(val sno: String = "", val grade: Int = 0, name: String = "", age: Int = 0) :
    Person3(name, age) {
    init {
        println("sno:$sno")
        println("grade:$grade")
    }

}

fun main() {
    params(123)
    //params1(123)
    params1(str = "wordla")
    params2(str = "11", num = 55)
    val s = Student()
}
avatar
文章
阅读
粉丝
相关推荐
一文快速入门 Kotlin 协程
58k阅读
 · 
465点赞
快速入门 Kotlin 编程
6.2k阅读
 · 
27点赞
Kotlin协程快速入门
5.9k阅读
 · 
24点赞
两万六千字带你 Kotlin 入门
20k阅读
 · 
292点赞
Kotlin 协程入门这一篇就够了
26k阅读
 · 
188点赞