Kotlin 基本语法（一）

最新推荐文章于 2025-10-15 01:16:42 发布

原创最新推荐文章于 2025-10-15 01:16:42 发布 · 693 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#kotlin #android #java

第一行代码专栏收录该内容

4 篇文章

订阅专栏

本文详细讲解了Android中Log日志工具，变量与函数，包括Kotlin的语法特性；深入剖析了程序逻辑控制（if、when、循环），面向对象编程（类、继承、接口、单例）、Lambda编程技巧；还有空指针检查和实用编程小技巧，如字符串内嵌表达式和函数默认值。

一、Android 中的日志工具类 Log

Log.v()：对于级别 verbose，是 Android 日志里面级别最低的一种。用于打印那些最为琐碎的、意义最小的日志信息。
Log.d()：对应级别 debug，比 verbose 高一级。用于打印一些调试信息，这些信息对你调试程序和分析问题应该是有帮助的。
Log.i()：对应级别 info，比 debug 高一级。用于打印一些比较重要的数据，这些数据应该是你非常想看到的、可以帮你分析用户行为的数据。
Log.w()：对应级别 warn，比 info 高一级。用于打印一些警告信息，提示程序在这个地方可能会有潜在的风险，最好去修复一下这些出现警告的地方。
Log.e()：对应级别 error，比 warn 高一级。用于打印程序中的错误信息，比如程序进入了 catch 语句中。当有错误信息打印出来的时候，一般代表你的程序出现严重问题了，必须尽快修复。

二、变量和函数

2.1、变量

一、只有两种关键字

val（value）：用来声明一个不可变的变量，这种变量在初始赋值之后就再也不能重新赋值，对应 Java 中的 final 变量。
var（variable）：用来声明一个可变的变量，这种变量在初始赋值之后仍然可以再被重新赋值，对应 Java 中的非 final 变量。

定义一个变量时，应该先使用 val，如果有需要给变量重新赋值的情况，再使用 var。

二、类型推导机制

如果不显式声明变量类型，a 的类型会根据 10 自动推导成 Int。

        val a = 10

也可以显式声明变量类型。

        val a: Int = 10

三、数据类型

Kotlin 完全抛弃了 Java 中的基本数据类型，全部使用了对象数据类型。

Java 基本数据类型	Kotlin 基本数据类型	数据类型说明
int	Int	整型
long	Long	长整型
short	Short	短整型
float	Float	单精度浮点型
double	Double	双精度浮点型
boolean	Boolean	布尔型
char	Char	字符型
byte	Byte	字节型

2.2、函数（方法）

在这里插入图片描述

2.3、语法糖

    fun methodName(params1: Int, params2: String): Int {
        return 0
    }

函数中只有一行代码时，可以不写函数体，return 也可以被省略。

    fun methodName(params1: Int, params2: String): Int = 0

根据类型推导机制，省略返回值类型。

    fun methodName(params1: Int, params2: String) = 0

三、程序的逻辑控制

3.1、if 条件语句

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

Kotlin 中的语句可以有返回值，返回值就是 if 语句每一个条件中最后一行代码的返回值。所以上述代码可以简化。在这里 value 使用的是 if 的返回值直接赋值，修饰符可以由 var 变为 val。

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

前面说过当一个函数只有一行代码时，可以省略方法体。

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

因为 if 语句中最后一行代码是一个返回值，所以上述代码还可以去掉 if 语句的大括号，精简成一行代码。

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

3.2、when 条件语句

这里用一个示例来说明，写一个成绩查询的功能，输入学生姓名，返回考试分数，先用 if 来实现。

    fun getScore(name: String) = if (name == "张三")
        86
    else if (name == "李四")
        77
    else if (name == "王五")
        96
    else if (name == "赵六")
        100
    else
        0

使用 when 条件语句来实现。

    fun getScore(name: String) = when (name) {
        "张三" -> 86
        "李四" -> 77
        "王五" -> 96
        "赵六" -> 100
        else -> 0
    }

when 语句还可以进行类型匹配。Number 类型是 Kotlin 内置的一个抽象类，Int、Long、Double 等等数据类型都是其子类。

    fun getScore(num: Number) = when (num) {
        is Int -> println("num is Int")
        is Double -> println("num is Double")
        else -> println("number not support")
    }

最后 when 语句还有一种不带参数的写法。看起来代码变冗余了，不过有些场景却只有用这种才能实现，比如再下面还写一个所有姓张的人返回的分数都是 86.

    fun getScore(name: String) = when {
        name == "张三" -> 86
        name == "李四" -> 77
        name == "王五" -> 96
        name == "赵六" -> 100
        else -> 0
    }

    fun getScore(name: String) = when {
        name.startsWith("张") -> 86
        name == "李四" -> 77
        name == "王五" -> 96
        name == "赵六" -> 100
        else -> 0
    }

3.3、循环语句

循环语句有 while 语句和 for 语句。其中 while 语句和 Java 中的 while 没有任何区别，这里只说 for 语句的用法。

两端都是闭区间（ 0 和 10 也包含在其中）。

        val range = 0..10

左闭右开（包含 0 不包含 10）。

        val range = 0 until 10

跳过某个元素（跳过 2）。

        val range = 0..10 step 2

两端都是闭区间的降序。

        val range = 10 downTo 1

使用 for 循环。

        for (i in range) {
            println(i)
        }

四、面向对象编程

4.1、类与对象

创建一个类。

class Person {
    var name = ""
    var age = 0
    fun eat() {
        println(name + "正在吃饭,他" + age + "岁了。")
    }
}

创建一个对象。Kotlin 中不在使用 new 关键字。

        val p = Person()

4.2、继承与构造函数

一、继承

创建一个 Student 类继承 Person 类。Kotlin 中非抽象类默认不可被继承。一个非抽象类需要能被继承，需要加 open 关键字。

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

抽象类和加 open 关键字。

// 抽象类
abstract class Person

// 非抽象类可继承
open class Person

二、主构造函数

默认无参构造函数。

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

有参构造函数。

class Student(val sno: String, val grade: Int) : Person() {
}

Kotlin 提供了一个 init 用来写构造函数的逻辑。

class Student(val sno: String, val grade: Int) : Person() {
    init {
        // 构造函数逻辑
    }
}

可以在 init 结构体中调用父类的构造函数，但是并不推荐这种方式。这就是继承 Person 需要加 () 的原因，上面的继承 Person 的方式表示默认调用了父类的无参构造函数。首先改造父类构造函数，变为有参。

open class Person(val name: String, val age: Int) {
    fun eat() {
        println(name + "正在吃饭,他" + age + "岁了。")
    }
}

再继承 Person 就表示调用父类的有参构造函数了。同时要注意，这时在 Student 的构造函数中增加的 name 和 age 两个字段并没有加 val 和 var。

class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
    init {
        // 构造函数逻辑
    }
}

三、次构造函数

当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数（包括间接调用）。次构造函数通过 constructor 关键字来定义，也可以用于实例化一个类，跟主函数不同的是，它是有函数体的。

class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
    init {
        // 构造函数逻辑
    }

    // 这里的 this 表示下面的次构造函数，可间接调用主构造函数
    constructor() : this("", 0) {}

    // this 表示直接调用主构造函数
    constructor(name: String, age: Int) : this("", 0, "", 0) {}
}

还有一种特殊的情况，类中只有次构造函数，没有主构造函数。当一个类中没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。

当 Student 类中没有主构造函数时，继承 Person 类时也不需要再加上括号了。由于 Student 没有了主构造函数，次构造函数就只能调用父类的构造函数，this 关键字也因此变成了 super。

class Student : Person {
    constructor(name: String, age: Int) : super(name, age) {}
}

4.3、接口

创建一个接口 Study。Kotlin 也允许对接口中定义的函数进行默认实现，当某个函数有默认实现时，实现这个接口就不用强制要求实现这个函数。

interface Study {
    fun readBooks()
    fun doHomework() {
        println("默认实现做作业")
    }
}

Kotlin 中不管是继承父类，还是实现接口，都统一使用冒号，中间用逗号隔开。另外接口的后面不用加上括号，因为它没有构造函数可以去调用。

class Student(name: String, age: Int) : Person(name, age), Study {
    override fun readBooks() {
        TODO("Not yet implemented")
    }

    override fun doHomework() {
        TODO("Not yet implemented")
    }
}

面向接口调用，又叫多态。

    //调用
    val student = Student("张三", 29)
    doStudy(student)

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

函数修饰符。

修饰符	Java	Kotlin
public	所有类可见	所有类可见（默认）
private	当前类可见	当前类可见
protected	当前类、子类、同一包路径下的类可见	当前类、子类可见
default	同一包路径下的类可见（默认）	无
internal	无	同一模块中的类可见

4.4、数据类与单例类

一、数据类

数据类通常需要重写 equals()、hashCode()、toString() 这几个方法。其中，equals() 方法用于判断两个数据类是否相等。hashCode() 方法作为 equals() 的配套方法，也需要一起重写，否则会导致 HashMap、HashSet 等 hash 相关的系统类无法正常工作。toString() 方法用于提供更清晰的输入日志，否则一个数据类默认打印出来就是一行内存地址。

在 Kotlin 中，如果你希望一个类是数据类，只需要在 class 前面加上 data 关键字就可以了。Kotlin 会根据主构造函数中的参数帮你将 equals()、hashCode()、toString() 等固定且无实际逻辑意义的方法自动生成。当一个类中没有任何代码时，还可以省略大括号。

data class Person(val name: String, val age: Int)

二、单例类

Java 单例类可参考设计模式。

Kotlin 中实现单例模式非常简单，只需要将 class 关键字改成 object 关键字。

//调用
Singleton.singletonTest()

object Singleton {
    fun singletonTest() {
        println("调用了单例类")
    }
}

五、Lambda 编程

5.1、集合的创建与遍历

传统意义上的集合主要就是 List 和 Set，再广泛一点的话，像 Map 这样的键值对数据结构也可以包含进来。List、Set 和 Map 在 Java 中都是接口，List 的主要实现类是 ArrayList 和 LinkedList，Set 的主要实现类是 HashSet，Map 的主要实现类是 HashMap。

一、List、Set

常规实现 List、Set。

        val list = ArrayList<String>()
        list.add("Apple")
        list.add("Banana")
        list.add("Orange")

        val set = HashSet<String>()
        set.add("Apple")
        set.add("Banana")
        set.add("Orange")

不可变集合 List、Set。

        val list = listOf("Apple", "Banana", "Orange")
        val set = setOf("Apple", "Banana", "Orange")

可变集合 List、Set。

        val list = mutableListOf("Apple", "Banana", "Orange")
        val set = mutableSetOf("Apple", "Banana", "Orange")

二、Map

传统的 Map，Kotlin 中并建议再使用 put、set 方法。

        val map = HashMap<String, Int>()
        map.put("Apple", 1)
        map.put("Banana", 2)
        map.put("Orange", 3)

Kotlin 推荐写法。

        val map = HashMap<String, Int>()
        map["Apple"] = 1
        map["Banana"] = 2
        map["Orange"] = 3

        // 取数据
        val num = map["Apple"]

不可变集合 Map，在这里 to 并不是一个关键字，而是一个 infix 函数。

        val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3)

可变集合 Map。

        val map = mutableMapOf("Apple" to 1, "Banana" to 2, "Orange" to 3)

5.2、集合的函数式 API

一、语法结构

首先看一下函数式 API 的语法结构，也就是 Lambda 表达式的语法结构。

{ 参数1，参数2 -> 函数体}

下面看一个例子，打印单词最长的水果名。

        val list = listOf("Apple", "Banana", "Orange")
        val lambda = { fruit: String -> fruit.length }
        val maxFruit = list.maxBy(lambda)

        val maxFruit = list.maxBy({ fruit: String -> fruit.length })

当 Lambda 参数是函数的最后一个参数时，可将 Lambda 表达式移到括号外。

        val maxFruit = list.maxBy(){ fruit: String -> fruit.length }

当 Lambda 参数时函数的唯一参数时，可将函数的括号省略。

        val maxFruit = list.maxBy{ fruit: String -> fruit.length }

类型推导机制，大多情况都不需要参数类型。

        val maxFruit = list.maxBy{ fruit -> fruit.length }

当 Lambda 表达式中只有一个参数时，可不声明参数，直接用 it 代替。

        val maxFruit = list.maxBy { it.length }

二、常用集合的函数式 API

map 函数，映射每个元素为另外的值，生成一个新的集合。比如将所有元素转为大写。

        val list = listOf("Apple", "Banana", "Orange")
        val newList = list.map { it.toUpperCase() }

filter 函数，用于过滤集合中的数据，并生成一个新的集合。比如只保留单词长度小于等于 5 的元素。

        val list = listOf("Apple", "Banana", "Orange")
        val newList = list.filter { it.length <= 5 }

map 函数和 filter 也可以配合使用。不过要注意的是，调用顺序会影响执行效率，如果先映射每一个元素再过滤，执行效率会比先过滤再映射每一个元素要慢。所以这里选择先过滤再转换。

        val list = listOf("Apple", "Banana", "Orange")
        val newList = list.filter { it.length <= 5 }.map { it.toUpperCase() }

any 函数和 all 函数，其中 any 函数用于判断集合中是否至少存在一个元素满足指定条件， all 函数用于判断集合中是否所有元素都满足指定条件。它们都返回布尔类型。

        val list = listOf("Apple", "Banana", "Orange")
        val any = list.any { it.length <= 5 }
        val all = list.all { it.length <= 5 }

在集合中还有很多其他函数式 API，它们的基本语法规则都类似。

5.3、Java 函数式 API

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

Java 原生 API 中有个最为常见的单抽象方法接口——Runnable 接口。只有一个待实现的 run() 方法。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

使用 Java 开启一个线程。

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开启了线程");
            }
        }).start();

使用 Kotlin 开启一个线程。

        Thread(object : Runnable {
            override fun run() {
                println("开启了线程")
            }
        })

Runnable 类中只有一个待实现方法，可不显示的重写 run 方法。

        Thread(Runnable {
            println("开启了线程")
        })

如果一个 Java 方法的参数列表中不存在多余一个的单抽象方法接口参数，还可以将接口名省略。

        Thread({
            println("开启了线程")
        })

跟前面 Kotlin 中函数式 API 的用类似，当 Lambda 表达式是方法的最后一个参数时，可以将 Lambda 表达式移动到括号外。只有一个参数时，去掉括号。

        Thread {
            println("开启了线程")
        }

Java 函数式 API 的写法也常用到，例如点击事件。

        button.setOnClickListener {
        }

六、空指针检查

6.1、可空类型系统

回到 doStudy| 函数，在 Kotlin 实现的情况下，这里是不允许传入 null 作为参数的。

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

如果需要 null 可以作为参数传入，需要在类名后加一个问号，但是这时内部也需要做判空处理，不然会编译报错。

    fun doStudy(study: Study?) {
        if (study != null) {
            study.readBooks()
            study.doHomework()
        }
    }

6.2、判空辅助工具

如果像上面每次都用 if 做判空处理，代码又会变得比较啰嗦，而且 if 判断语句还处理不了全局量的判空问题。为此 Kotlin 提供了一系列的辅助工具。首先是 ?. 操作符，当对象不为空时调用相应方法，为空时什么都不做，比如上面的代码可改为。

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

接下来是 ?: 操作符。比如下面简化前和简化后的代码。

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

        val c = a?:b

?. 和 ?:

?. 和 ?: 操作符的结合使用。比如编写一个函数来获得一段文本的长度，简化前和简化后代码如下。

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

    fun getTextLength(text: String?): Int {
        return text?.length ?: 0
    }

在有时候我们已经在逻辑上对空指针进行了处理，但是因为 Kotlin 的空指针检查机制还是会导致代码编译不过。

比如定义一个可为空的全局变量 content，然后在 onCreate 中调用时先进行判空操作，当 content 不为空时才会调用 printUpperCase() 函数，在 printUpperCase() 函数中，我们将 content 转换为大写模式，最后打印出来。这段代码在逻辑上是没有问题的，但是因为空指针检查机制，printUpperCase() 函数并不知道外部已经对 content 变量进行了非空检查，导致编译失败。

在这里插入图片描述
在这种情况下，如果我们要强行通过编译，可以使用非空断言工具，在对象的后面加上 !!，不过这也是一种有风险的实现方式，代码如下。

let

let 即不是操作符，也不是什么关键字，而是一个函数，属于 Kotlin 中的标准函数。

下面的 doStudy() 函数的写法如果翻译成 if 判断语句的写法，可以看出每次调用 study 对象的任何方法，都会进行一次判空。

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

    fun doStudy(study: Study?) {
        if (study != null) {
            study.readBooks()
        }
        if (study != null) {
            study.doHomework()
        }
    }

这时我们就可以结合使用 ?. 操作符和 let 函数对代码进行优化。下面的代码中，?. 操作符表示对象为空时什么都不做，对象不为空时就调用 let 函数，let 函数会将 study 对象本身作为参数传递到 Lambda 表达式中，此时的 study 对象就不会再为空了。

    fun doStudy(study: Study?) {
        study?.let { stu ->
            stu.readBooks()
            stu.doHomework()
        }
    }

当 Lambda 表达式的参数列表中只有一个参数时，可以不用参数名，使用 it 关键字代替。

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

除此之外，let 函数还可以处理全局变量的判空问题，而使用 if 语句无法做到这一点，因为全局变量的值可能被其他线程所修改，比如以下代码是会报错的。

在这里插入图片描述

七、有用的小知识点

7.1、字符串内嵌表达式

拼接字符串可以告别加号，使用字符串内嵌表达式。

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

当表达式中只有一个变量时，还可以省略大括号。

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

7.2、函数的参数默认值

下面的函数中，给第二个参数设定了一个默认值，这样在调用 printParams() 函数时，可以选择是否给第二个参数传值，不传就会使用默认值。

        // 调用
    printParams(123)

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

上面的情况中，我们设置的是第二个参数的默认值，如果只给第一个参数设置默认值，这样的方式就行不通了，因为调用时编译器会认为我们想把字符串赋值给第一个 num 参数，从而报类型不匹配的错误。

        // 调用
    printParams("str")
        
    fun printParams(num: Int = 100, str: String) {
        println("num is $num, str is $str")
    }

要解决上面的问题，Kotlin 中可以通过键值对的方式传参，不需要关心传参的顺序，这时就可以省略有默认值的 num 参数了。

        printParams(str = "world", num = 123)

        printParams(str = "world")

在前面讲过的构造函数中，看下面的代码，有一个主构造函数和两个次构造函数。在学习了给函数的参数设置默认值后，这个功能可以很大程度上替代次构造函数的作用。

class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
    constructor() : this("", 0) {}
    constructor(name: String, age: Int) : this("", 0, "", 0) {}
}

class Student(val sno: String = "", val grade: Int = 0, name: String = "", age: Int = 0) :
    Person(name, age) {
}