函数的定义与调用

亦凉 2023-07-05 10:04 3阅读 0赞

### 1、在kotlin中创建集合 ###

--------------------

kotlin没有自己专门的集合类，而是采用的[java][]的集合类，不过书写方式不一样。

val set=hashSetOf(1,7,53) //对应hashset
    val list=arrayListOf(1,7,53)   //ArrayList
    val map=hashMapOf(1 to "one",7 to "seven",53 to "fifty-three")//HashMap

不过kotlin有自己新增的方法：last()，max()集合中最后一个元素和最大的元素。

### 2、让函数更好调用 ###

--------------------

java的集合都有一个默认的toString()实现，但是它的输出格式是固定的。

val list=listOf(1,2,3)//listOf对应的是（Arrays内部类ArrayList）
    println(list)
    结果：[1,2,3]

上面的结果是固定格式的，默认实现了toString().

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）

当我们想要改变集合输出格式的时候可以自定义，像上面这样：逗号变分号。

#### 2.1 命名参数 ####

在上面的例子中，我们单看这一句joinToString(list,"; ","(",")")会发现我们必须要找到上面对应的函数声明才能更好的理解我们写的是啥。  
为了解决这个问题，kotlin引出了命名参数:当调用一个kotlin自定义的函数时，可以显式地标明一些参数的名称。

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

#### 2.2 默认参数值 ####

在声明函数的时候，指定参数的默认值，可以避免创建重载的函数。

fun <T> joinToString(collection:Collection<T>,separator:String,prefix:String,postfix:String):String

当你调用的时候可以用所有参数来调用这个函数，也可以省略掉部分参数。

### 3、扩展函数和属性 ###

--------------------

Kotlin 可以对一个类的属性和方法进行扩展，且不需要继承或使用 Decorator 模式。  
扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。

#### 3.1 导入和扩展函数 ####

扩展函数可以在已有类中添加新的方法，不会对原类做修改.  
扩展函数定义形式：

fun receiverType.functionName(params){
        body
    }

*  receiverType：表示函数的接收者，也就是函数扩展的对象
 *  functionName：扩展函数的名称
 *  params：扩展函数的参数，可以为NULL  
    以下实例扩展 User 类 ：

class User(var name:String)
    
    /**扩展函数**/
    fun User.Print(){
        print("用户名 $name")
    }
    
    fun main(arg:Array<String>){
        var user = User("Runoob")
        user.Print()
    }
    实例执行输出结果为：
    用户名 Runoob

下面代码为 MutableList 添加一个swap 函数：

// 扩展函数 swap,调换不同位置的值
    fun MutableList<Int>.swap(index1: Int, index2: Int) {
        val tmp = this[index1]     //  this 对应该列表
        this[index1] = this[index2]
        this[index2] = tmp
    }
    
    fun main(args: Array<String>) {
    
        val l = mutableListOf(1, 2, 3)
        // 位置 0 和 2 的值做了互换
        l.swap(0, 2) // 'swap()' 函数内的 'this' 将指向 'l' 的值
    
        println(l.toString())
    }
    实例执行输出结果为：
    [3, 2, 1]

#### 3.2 不可重写的扩展函数 ####

扩展函数是静态解析的，并不是接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的:

open class C
    
    class D: C()
    
    fun C.foo() = "c"   // 扩展函数 foo
    
    fun D.foo() = "d"   // 扩展函数 foo
    
    fun printFoo(c: C) {
        println(c.foo())  // 类型是 C 类
    }
    
    fun main(arg:Array<String>){
        printFoo(D())
    }
    实例执行输出结果为：
    c

若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。

class C {
        fun foo() { println("成员函数") }
    }
    
    fun C.foo() { println("扩展函数") }
    
    fun main(arg:Array<String>){
        var c = C()
        c.foo()
    }
    实例执行输出结果为：
    成员函数

#### 3.3 扩展属性 ####

除了函数，Kotlin 也支持属性对属性进行扩展:

val <T> List<T>.lastIndex: Int
        get() = size - 1

扩展属性允许定义在类或者kotlin文件中，不允许定义在函数中。初始化属性因为属性没有后端字段（backing field），所以不允许被初始化，只能由显式提供的 getter/setter 定义。

val Foo.bar = 1 // 错误：扩展属性不能有初始化器

扩展属性只能被声明为 val。

### 4、可变参数、中缀调用和库的支持 ###

--------------------

#### 4.1 扩展java集合的API ####

fun <T> List<T>.last():T//返回最后一个元素
    fun Collection<Int>.max():Int//返回集合中的最大值

为什么kotlin用的是java的集合，却能给它添加自己又增加的方法？  
函数last和max都被声明成了扩展函数。

#### 4.2 可变参数：让函数支持任意数量的参数 ####

可变参数的关键字vararg，可以用来声明一个函数将可能有任意数量的参数  
fun listOf (vararg values:T):List \{...\}  
kotlin库中是这样定义listOf()函数的，正因为这样我们调用它时才可以传递任意个数的参数给它  
kotlin和java的另一个区别是：当需要传递的参数已经包装在数组中时，调用该函数的语法。  
在java中可以按原样传递数组，kotlin要求你显式地解包数组。这个叫做展开运算符，在参数前面加\*

fun main(args:Array<String>){
        val list=listOf("args: ",*args)
        println(list)
    }

#### 4.3 键值对的处理：中缀调用和重构声明 ####

val map=mapOf(1 to "one",7 to "seven",53 to "fifty-three")

这行代码中的单词to不是内置结构，而是一种特殊的函数调用，被称为中缀调用。

重构声明：  
中缀调用可以与只有一个参数的函数一起使用，无论是普通的函数还是扩展函数。要允许使用中缀符合调用函数，需要使用infix修饰符来标记它。

infix fun Any.to(other:Any)=Pair(this,other)

我们可以直接用Pair的内容来初始化两个变量。  
val （number,name)=1 to "one"  
这个功能称为解构声明。

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

--------------------

#### 5.1 分割字符串 ####

println("12.345-6.A".split("\\.|-".toRegex()))
    结果：[12,345,6,A]

kotlin提供了一些名为split的，具有不同参数的重载的扩展函数。用来承载正则表达式的值需要一个Regex类型，而不是String。上面例子中就是使用扩展函数toRegex将字符串转换为正则表达式。  
但是对于一些简单的情况，不需要使用正则表达式。kotlin中的split扩展函数的其他重载支持任意数量的纯文本字符串分隔符：

println("12.345-6.A".split(".","-"))
    [12,345,6,A]

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

我们解析一个文件路径：/Users/yole/kolin-book/chapter.doc  
①使用String的扩展函数来解析文件路径

fun parsePath(path:String){
        val directory=path.substringBeforeLast("/")
        val fullName=path.substringAfterLast("/")
        val fileName=fullName.subStringBeforeLast(".")
        val extension=fullName.subStringAfterLast(".")
        println("Dir:$directory,name:$fileName,ext:$extension")
    }
    parsePath("/Users/yole/kolin-book/chapter.doc")
    结果：Dir:Users/yole/kolin-book,name:chapter,ext:doc

②使用正则表达式来解析文件路径

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

三重引号字符串不需要对任何字符进行转义。第一个（.+)包含最后一个斜线前的字串。第二个包含最后一个点前的字串，第三个包含剩余部分。

#### 5.3 多行三重引号的字符串 ####

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

val kotlinLogo="""| //
                     .|//
                     .|/ \"""
    println(kotlinLogo.trimMargin("."))
    结果： | //
          |//
          |/ \

[java]: http://www.wityx.com