写在开头：本人打算开始写一个Kotlin系列的教程，一是使自己记忆和理解的更加深刻，二是可以分享给同样想学习Kotlin的同学。系列文章的知识点会以《Kotlin实战》这本书中顺序编写，在将书中知识点展示出来同时，我也会添加对应的Java代码用于对比学习和更好的理解。

Kotlin教程（一）基础
 Kotlin教程（二）函数
 Kotlin教程（三）类、对象和接口
 Kotlin教程（四）可空性
 Kotlin教程（五）类型
 Kotlin教程（六）Lambda编程
 Kotlin教程（七）运算符重载及其他约定
 Kotlin教程（八）高阶函数
 Kotlin教程（九）泛型

在Kotlin中创建集合

上一章我们已经使用setOf 函数创建一个set了。同样的，我们也可以用类似的方法创建一个list或者map：

val set = setOf(1, 2, 3)
val list = listOf(1, 2, 3)
val map = mapOf(1 to "one", 2 to "two")

to 并不是一个特殊的结构，而是一个普通函数，在后面会继续探讨它。有没有想过这里创建出来的set、list、map到底是什么类型的那？可以通过.javaClass 属性获取类型，相当于Java中的getClass() 方法：

println(set.javaClass)
println(list.javaClass)
println(map.javaClass)

//输出
class java.util.LinkedHashSet
class java.util.Arrays$ArrayList
class java.util.LinkedHashMap

可以看到都是标准的Java集合类，Kotlin没有自己专门的集合类，是为了更容易与Java代码交互，当从Kotlin中调用Java函数的时候，不用转换它的集合类来匹配Java的类，反之亦然。尽管Kotlin的集合类和Java的集合类完全一致，但Kotlin还不止于此。举个例子，可以通过以下方法来获取一个列表中最后一个元素，或者得到一个数字列表的最大值：

val strings = listOf("first", "second", "fourteenth")
println(strings.last())
val numbers = setOf(1, 14, 2)
println(numbers.max())

//输出
fourteenth
14

或许你应该知道last() 和max() 在Java的集合类中并不存在，这应该是Kotlin自己扩展的方法，可以你要知道上面我们打印出来的类型明确是Java中的集合类，但在这里调用方法的对象就是这些集合类，又是怎么做到让一个Java中的类调用它本身没有的方法那？在后面我们讲到扩展函数的时候你就会知道了！

让函数更好调用

现在我们知道了如何创建一个集合，接下来让我们打印它的内容。Java的集合都有一个默认的toString 实现，但它的何世华的输出是固定的，而且往往不是你需要的样子：

val list = listOf(1, 2, 3)
println(list) //触发toString的调用

//输出
[1, 2, 3]

假设你需要用分号来分隔每一个元素，然后用括号括起来，而不是采用默认实现。要解决这个问题，Java项目会使用第三方库，比如Guava和Apache Commons，或者是在这个项目中重写打印函数。在Kotlin中，它的标准库中有一个专门的函数来处理这种情况。但是这里我们先不借助Kotlin的工具，而是自己写实现函数：

fun <T> joinToString(
        collection: Collection<T>,
        separator: String,
        prefix: String,
        postfix: String
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator) //不用再第一个元素前添加分隔符
        result.append(element)
    }
    result.append(postfix)
    return result.toString()
}

这个函数是泛型，它可以支持元素为任意类型的集合。让我们来验证一下，这个函数是否可行：

val list = listOf(1, 2, 3)
println(joinToString(list, ";", "(", ")"))

//输出
(1;2;3)

看来是可行的，接下来我们要考虑的是如何修改让这个函数的调用更加简洁呢？毕竟每次调用都要传入四个参数也是挺麻烦的。

命名参数

我们关注的第一个问题就是函数的可读性。就以joinToString 来看：

joinToString(list, "", "", "")

你能看得出这些String都对应什么参数吗？可能必须要借助IDE工具或者查看函数说明或者函数本身才能知道这些参数的含义。在Kotlin中，可以做的更优雅：

println(joinToString(list, separator = "", prefix = "", postfix = ""))

当你调用一个Kotlin定义的函数时，可以显示得标明一些参数的名称。如果在调用一个函数时，指明了一个参数的名称，为了避免混淆，那它之后的所有参数都需要标明名称。

ps: 当你在Kotlin中调用Java定义的函数时，不能采用命名参数。因为把参数名称存到 .class文件是Java8以及更高版本的一个可选功能，而Kotlin需要保持和Java6的兼容性。

可能到这里你只是觉得命名参数让函数便于理解，但是调用变得复杂了，我还得多写参数的名称！别急，与下面说的默认参数相结合时，你就知道命名参数的好了。

默认参数值

Java的另一个普遍存在问题是：一些类的重载函数实在太多了。这些重载大多是为了向后兼容，方便API的使用者，最终导致的结果是重复。在Kotlin中，可以在声明函数的时候，指定参数的默认值，这样可以避免创建重载的函数。让我们尝试改进一下前面的joinToString 函数。在大多数情况下，我们可能只会改变分隔符或者改变前后缀，所以我们把这些设置为默认值：

fun <T> joinToString(
        collection: Collection<T>,
        separator: String = ",",
        prefix: String = "",
        postfix: String = ""
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator) //不用再第一个元素前添加分隔符
        result.append(element)
    }
    result.append(postfix)
    return result.toString()
}

现在在调用一下这个函数，可以省略掉有默认值的参数，效果就像在Java中声明的重载函数一样。

println(joinToString(list))
println(joinToString(list, ";"))

//输出
1,2,3
1;2;3

当你使用常规的调用语法时，必须按照函数申明中定义的参数顺序来给定参数，可以省略的只有排在末尾的参数。如果使用命名参数，可以省略中的一些参数，也可以以你想要的任意顺序只给定你需要的参数：

//打乱了参数顺序，并且separator参数使用了默认值
println(joinToString(prefix = "{", collection = list, postfix = "}"))

//输出
{1,2,3}

注意，参数的默认值是被编译到被调用的函数中，而不是调用的地方。如果你改变了参数默认值并重新编译这个函数，没有给参数重新赋值的调用者，将会开始使用新的默认值。

Java没有参数默认值的概念，当你从Java中调用Kotlin函数的时候，必须显示得指定所有参数值。如果需要从Java代码中调用也能更简便，可以使用@JvmOverloads注解函数。这个指示编译器生成Java的重载函数，从最后一个开始省略每个函数。例如joinToString函数，编译器就会生成如下重载函数： public static final String joinToString(@NotNull Collection collection, @NotNull String separator, @NotNull String prefix) public static final String joinToString(@NotNull Collection collection, @NotNull String separator) public static final String joinToString(@NotNull Collection collection) 因此，当你项目同时存在Java和Kotlin时，对有默认参数值的函数习惯性地加上@JvmOverloads注解是个不错的做法。

消除静态工具类：顶层函数和属性

Java作为一门面对对象的语言，需要所有的代码都写作类的函数。但实际上项目中总有一些函数不属于任何一个类，最终产生了一些类不包含任何状态或者实例函数，仅仅是作为一堆静态函数的容器。在JDK中，最明显的例子应该就是Collections了，还有你的项目中是不是有很多以Util作为后缀的类？在Kotlin中，根本不需要去创建这些无意义的类，你可以把这些函数直接放到代码文件的顶层，不用从属于任何类。事实上joinToString函数之前就是直接定义在Join.kt 文件。

package com.huburt.imagepicker

@JvmOverloads
fun <T> joinToString(...): String {...}

这会怎样运行呢？当编译这个文件的时候，会生成一些类，因为JVM只能执行类中的代码。当你在使用Kotlin的时候，知道这些就够了。但是如果你需要从Java中来调用这些函数，你就必须理解它将怎样被编译，来看下编译后的类是怎样的：

package com.huburt.imagepicker

public class JoinKt {
	public static String joinToString(...){...}
}

可以看到Kotlin编译生成的类的名称，对应于包含函数的文件名称，这个文件中的所有顶层函数编译为这个类的静态函数。因此，当从Java调用这个函数的时候，和调用任何其他静态函数一样简单：

import com.huburt.imagepicker.JoinKt

JoinKt.joinToString(...)

修改文件类名

是不是觉得Kt结尾的类使用起来很别扭，Kotlin提供了方法改变生成类的类名，只需要为这个kt文件添加@JvmName的注解，将其放到这个文件的开头，位于包名的前面：

@file:JvmName("Join") //指定类名
package com.huburt.imagepicker

@JvmOverloads
fun <T> joinToString(...): String {...}

现在就可以用新的类名调用这个函数：

import com.huburt.imagepicker.Join

Join.joinToString(...)

顶层属性

和函数一样，属性也可以放到文件的顶层。从Java的角度来看就是静态属性，没啥特别的,而且由于没有了类的存在，这种属性用到的机会也不多。需要注意的是顶层函数和其他任意属性一样，默认是通过访问器暴露给Java使用的（也就是通过getter和setter方法）。为了方便使用，如果你想要把一个常量以public static final 的属性暴露给Java，可以用const 来修饰属性：

const val TAG = "tag"

这样就等同与Java的：

public static final String TAG = "tag"

给别人的类添加方法：扩展函数和属性

Kotlin的一大特色就是可以平滑的与现有代码集成。你可以完全在原有的Java代码基础上开始使用Kotlin。对于原有的Java代码可以不修改源码的情况下扩展功能：扩展函数。这一点是我认为Kotlin最强大的地方了。扩展函数非常简单，它就是一个类的成员函数，不过定义在类的外面。为了方便阐述，让我们添加一个方法，来计算一个字符串的最后一个字符：

package strings

	//String ->接收者类型               //this ->接收者类型
fun String.lastChar(): Char = this.get(this.length - 1)

你所要做的，就是把你要扩展的类或者接口的名称，放到即将添加的函数前面，这个类的名称被称为接收者类型；用来调用这个扩展函数的那个对象，叫做接收者对象。接着就可以像调用类的普通成员函数一样去调用这个函数了：

println("Kotlin".lastChar())
//输出
n

在这个例子中，String就是接收者类型，而“Kotlin”就是接收者对象。在这个扩展函数中，可以像其他成员函数一样用this，也可以像普通函数一样省略它：

package strings

fun String.lastChar(): Char = get(length - 1) //省略this调用string对象其他函数

导入扩展函数

对于你定义的扩展函数，它不会自动的在整个项目范围内生效。如果你需要使用它，需要进行导入，导入单个函数与导入类的语法相同：

import strings.lastChar

val c = "Kotlin".lastChar()

当然也可以用*表示文件下所有内容：import strings.*

另外还可以使用as 关键字来修改导入的类或则函数的名称：

import strings.lastChar as last

val c = "Kotlin".last()

在导入的时候重命名可以解决函数名重复的问题。

从Java中调用扩展函数

实际上，扩展函数是静态函数，它把调用对象作为函数的第一个参数。在Java中调用扩展函数和其他顶层函数一样，通过.kt文件生成Java类调用静态的扩展函数，把接收者对象传入第一个参数即可。例如上面提到的lastChar扩展函数是定义在StringUtil.kt中，在Java中就可以这样调用：

char c = StringUtilKt.lastChar("Java")

作为扩展函数的工具函数

现在我们可以写一个joinToString 函数的终极版本了，它和你在Kotlin标准库中看到的一模一样：

@JvmOverloads
fun <T> Collection<T>.joinToString(
        separator: String = ",",
        prefix: String = "",
        postfix: String = ""
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in this.withIndex()) { //this是接收者对象，即T的集合
        if (index > 0) result.append(separator)
        result.append(element)
    }
    result.append(postfix)
    return result.toString()
}

//使用
println(list.joinToString())
println(list.joinToString(";"))
println(list.joinToString(prefix = "{", postfix = "}"))

将原来的参数Collection，提出来，作为接收者类型编写的扩展函数，使用方法也像是Collection类的成员函数一样了（当然Java调用还是静态方法，第一个参数传入Collection对象）。

不可重写的扩展函数

先来看一个重写的例子：

//Kotlin中class默认是final的，如果需要继承需要修饰open，函数也相同
open class View {
    open fun click() = println("View clicked")
}

class Button : View() { //继承
    override fun click() = println("Button clicked")
}

当你声明了类型为View的变量，那它可以被赋值为Button类型的对象，因为Button是View的一个子类。当你在调用这个变量的一般函数，比如click的时候，如果Button复写了这个函数，name这里将会调用到Button中复写的函数：

val view: View = Button()
view.click()

//输出
Button clicked

但是对于扩展函数来说，并不是这样的。扩展函数并不是类的一部分，它是声明在类之外的。尽管可以给基类和子类都分别定义一个同名的扩展函数，当这个函数被调用时，它会用到哪一个呢？这里，它是由该变量的静态类型所决定的，而不是这个变量的运行时类型。

fun View.showOff() = println("i'm a view!")

fun Button.showOff() = println("i'm a button!")

val view: View = Button()
view.click()

//输出
i'm a view!

当你在调用一个类型为View的变量的showOff函数时，对应的扩展函数会被调用，尽管实际上这个变量现在是一个Button对象。回想一下，扩展函数会在Java中编译为静态函数，同时接受值将会作为第一个参数。这样其实2个showOff扩展函数就是不同参数的静态函数，

View view = new Button();
XxKt.showOff(view);  //定义在Xx.kt文件中

参数的类型决定了调用那个静态函数，想要调用Button的扩展函数，则必须先将参数转成Button类型才行：XxKt.showOff((Button)view);

因此，扩展函数也是有局限性的，扩展函数是能扩展，即定义新的函数，而不能重写改变原有函数的实现（本质是一个静态函数）。如果定了一个类中本身存在成员函数同名的扩展函数，Kotlin种调用该方法的时候会如何呢？（Java中没有这个顾虑，调用方式不同）

open class View {
    open fun click() = println("View clicked")
}

fun View.click() = println("扩展函数")

val view = View()
view.click()

//输出
View clicked

明显了吧~ 对于有同名成员函数和扩展函数时，在Kotlin中调用始终执行成员函数的代码，扩展函数并不起作用，相当于没有定义。这一点在实际开发中需要特别注意了！

扩展属性

扩展属性提供了一种方法，用于扩展类的API，可以用来访问属性，用的是属性语法而不是函数的语法。尽管他们被称为属性，但它们可以没有任何状态，因为没有合适的地方来存储它，不可能给现有的Java对象的实例添加额外的字段。举个例子吧：

val String.lastChar: Char
    get() = get(length - 1)

同样是获取字符串的最后一个字符，这次是用扩展属性的方式定义。扩展属性也像接收者的一个普通成员属性一样，这里必须定义getter函数，因为没有支持字段，因此没有默认的getter的实现。同理，初始化也不可以：因为没有地方存储初始值。刚刚定义是一个val的扩展属性，也可以定义var属性：

var StringBuilder.lastChar: Char
    get() = get(length - 1)
    set(value) {
        setCharAt(length - 1, value)
    }

还记得上一篇文章的自定义访问器的内容吗？这里的定义方式与自定义访问器一致，val 属性不可变，因此只需要定义getter，而var 属性可变，所以getter和setter都需要。可能不是很好理解扩展属性，或者会和真正的属性混淆，下面列出了扩展属性转换成Java的代码，你就会比较直观的理解了。

   public static final char getLastChar(@NotNull String $receiver) {
      return $receiver.charAt($receiver.length() - 1);
   }

   public static final char getLastChar(@NotNull StringBuilder $receiver) {
      return $receiver.charAt($receiver.length() - 1);
   }

   public static final void setLastChar(@NotNull StringBuilder $receiver, char value) {
      $receiver.setCharAt($receiver.length() - 1, value);
   }

和扩展函数是相同的，仅仅是静态函数：提供获取lastChar的功能，这样的定义方式可以在Kotlin中像使用普通属性的调用方式来使用扩展属性，给你一种这是属性的感觉，但本质上在Java中就是静态函数。

处理集合：可变参数、中缀调用和库的支持

扩展Java集合的API

val strings = listOf("first", "second", "fourteenth")
println(strings.last())
val numbers = setOf(1, 14, 2)
println(numbers.max())

还记的之前我们使用上面的方式获取了list的最后一个元素，以及set中的最大值。到这里你可能已经知道了，last() 和max() 都是扩展函数，自己点进方法验证一下吧！

可变参数

如果你也看了listOf 函数的定义，你一定看到了这个：

public fun <T> listOf(vararg elements: T): List<T>

也就是vararg 关键字，这让函数支持任意个数的参数。在Java中同样的可变参数是在类型后面跟上... ，上面的方法在Java则是：

public <T> List<T> listOf(T... elements)

但是Kotlin的可变参数相较于Java还是有点区别：当需要传递的参数已经包装在数组中时，调用该函数的语法，在Java中可以按原样传递数组，而Kotlin则要求你显示地解包数组，以便每个数组元素在函数中能作为单独的参数来调用。从技术的角度来讲，这个功能被称为展开运算符，而使用的时候，不过是在对应的参数前面放一个* ：

val array = arrayOf("a", "b")
val list = listOf("c", array)
println(list)
val list2 = listOf<String>("c", *array)
println(list2)

//输出
[c, [Ljava.lang.String;@5305068a]
[c, a, b]

通过对照可以看到，如果不加* ，其实是把数组对象当做了集合的元素。加上* 才是将数组中所有元素添加到集合中。listOf 也可以指定泛型<String> ，你可以尝试在listOf("c", array) 这里加泛型，第二个参数array就会提示类型不正确。

Java中没有展开，我们也可以调用Kotlin的listOf函数，该函数声明在Collections.kt文件下：

List<String> strings = CollectionsKt.listOf(array);
System.out.println(strings);
//List<String> strings = CollectionsKt.listOf("c", array);//无法编译

//输出
[a, b]

Java中可以直接传入数组，但是不能同时传入单个元素和数组。

键值对的处理：中缀调用和解构声明

还记得创建map的方式吗？

val map = mapOf(1 to "one", 7 to "seven", 52 to "fifty-five")

之前说过to 并不是一个内置的结构，而是一种特殊的函数调用，被称为中缀调用。在中缀调用中，没有添加额外的分隔符，函数名称是直接放在目标对象名称和参数之间的，以下两种调用方式是等价的：

1.to("one")//普通调用
1 to "one" //中缀调用

中缀调用可以与只有一个参数的函数一起使用，换句话说就是只要函数只有一个参数，都可以支持在Kotlin中的中缀调用，无论是普通的函数还是扩展函数。要允许使用中缀符号调用函数，需要使用infix 修饰符来标记它。例如to 函数的声明：

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

to函数会返回一个Pair类型的对象，Pair是Kotlin标准库中的类，它是用来表示一对元素。我们也可以直接用Pair的内容来初始化两个变量：

val (number, name) = 1 to "one"

这个功能称之为解构声明，1 to "one" 会返回一个Pair对象，Pair包含一对元素，也就是1和one，接着又定义了变量(number, name) 分别指向Pair中的1和one。解构声明特征不止用于Pair。还可以使用map的key和value内容来初始化两个变量。并且还适用于循环，正如你在使用的withIndex 函数的joinToString 实现中看到的：

for ((index, element) in collection.withIndex()) {
    println("$index, $element")
}

to 函数是一个扩展函数，可以创建一对任何元素，这意味着它是泛型接受者的扩展：可以使用1 to "one"、 "one" to 1 、list to list.size()等写法。我们来看看mapOf 函数的声明：

public fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

与listOf 一样，mapOf 接受可变数量的参数，但这次他们应该是键值对。尽管在Kotlin中创建map可能看起来像特殊的解构，而它不过是一个具有简明语法的常规函数。

字符串和正则表达式的处理

Kotlin定义了一系列扩展函数，使标准Java字符串使用起来更加方便。

分割字符串

Java中我们会使用String的split方法分割字符串。但有时候会产生一些意外的情况，例如当我们这样写"12.345-6.A".split(".") 的时候，我们期待的结果是得到一个[12, 345-6, A]数组。但是Java的split方法竟然返回一个空数组！这是应为它将一个正则表达式作为参数，并根据表达式将字符串分割成多个字符串。这里的点（.）是表示任何字符的正则表达式。在Kotlin中不会出现这种令人费解的情况，因为正则表达式需要一个Regex类型承载，而不是String。这样确保了字符串不会被当做正则表达式。

println("12.345-6.A".split("\\.|-".toRegex())) //显示地创建一个正则表达式
//输出
[12, 345, 6, A ]

这里正则表达式语法与Java的完全相同，我们匹配一个点（对它转义表示我们指的时字面量）或者破折号。对于一些简单的情况，就不需要正则表达式了，Kotlin中的spilt扩展函数的其他重载支持任意数量的纯文本字符串分隔符：

println("12.345-6.A".split(".", "-")) //指定多个分隔符

等同于上面正则的分割。

正则表达式和三重引号的字符串

现在有这样一个需求：解析文件的完整路径名称/Users/hubert/kotlin/chapter.adoc 到对应的组件：目录、文件名、扩展名。Kotlin标准库中包含了一些可以用来获取在给定分隔符第一次（或最后一次）出现之前（或之后）的子字符串的函数。

 val path = "/Users/hubert/kotlin/chapter.adoc"
val directory = path.substringBeforeLast("/")
val fullName = path.substringAfterLast("/")
val fileName = fullName.substringBeforeLast(".")
val extension = fullName.substringAfterLast(".")
println("Dir: $directory, name: $fileName, ext: $extension")

//输出
Dir: /Users/hubert/kotlin, name: chapter, ext: adoc

解析字符串在Kotlin中变得更加容易，但如果你仍然想使用正则表达式，也是没有问题的：

val regex = """(.+)/(.+)\.(.+)""".toRegex()
val matchResult = regex.matchEntire(path)
if (matchResult != null) {
    val (directory, fileName, extension) = matchResult.destructured
    println("Dir: $directory, name: $fileName, ext: $extension")
}

这里正则表达式写在一个三重引号的字符串中。在这样的字符串中，不需要对任何字符进行转义，包括反斜线，所以可以用\. 而不是\\. 来表示点，正如写一个普通字符串的字面值。在这个正则表达式中：第一段(.+) 表示目录，/ 表示最后一个斜线，第二段(.+) 表示文件名，\. 表示最后一个点，第三段(.+) 表示扩展名。

多行三重引号的字符串

三重引号字符串的目的，不仅在于避免转义字符，而且使它可以包含任何字符，包括换行符。它提供了一种更简单的方法，从而可以简单的把包含换行符的文本嵌入到程序中：

val kotlinLogo = """|//
        .|//
        .|/ \
    """.trimMargin(".")
print(kotlinLogo)

//输出
|//
|//
|/ \

多行字符串包含三重引号之间的所有字符，包括用于格式化代码的缩进。如果要更好的表示这样的字符串，可以去掉缩进（左边距）。为此，可以向字符串内容添加前缀，标记边距的结尾，然后调用trimMargin 来删除每行中的前缀和前面的空格。在这个例子中使用了. 来作为前缀。

让你的代码更整洁：局部函数和扩展

许多开发人员认为，好代码的重要标准之一就是减少重复代码。Kotlin提供了局部函数来解决常见的代码重复问题。下面的例子中是在将user的信息保存到数据库前，对数据进行校验的代码：

class User(val id: Int, val name: String, val address: String)

fun saveUser(user: User) {
    if (user.name.isEmpty()) {
        throw IllegalArgumentException("Can't save user ${user.id}:empty Name")
    }
    if (user.address.isEmpty()) {
        throw IllegalArgumentException("Can't save user ${user.id}:empty Name")
    }
    //保存user到数据库
}

分别对每个属性校验的代码就是重复的代码，特别当属性多的时候就重复的更多。这种时候将验证的代码放到局部函数中，可以摆脱重复同时保持清晰的代码结构。局部函数，顾名思义就是定义在函数中的函数。我们使用局部函数来改造上面这个例子：

class User(val id: Int, val name: String, val address: String)

fun saveUser(user: User) {
    //声明一个局部函数
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            //局部函数可以直接访问外部函数的参数：user
            throw IllegalArgumentException("Can't save user ${user.id}:empty $fieldName")
        }
    }
    validate(user.name,"Name")
    validate(user.address,"Address")
    //保存user到数据库
}

我们还可以继续改进，将逻辑提取到扩展函数中：

class User(val id: Int, val name: String, val address: String)

fun User.validateBeforeSave() {
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("Can't save user $id:empty $fieldName")
        }
    }
    validate(name, "Name")//扩展函数直接访问接收者对象user的属性
    validate(address, "Address")
}

fun saveUser(user: User) {
    user.validateBeforeSave()
    //保存user到数据库
}