kotlin函数与闭包 & Lambda语法

函数的特性语法

允许参数有默认值

fun parint（name:String ="xiaoming"）:String?{
 parint("$name")
return name;
}

用途：通常用于当重载函数特别多的时候，有默认值的函数可以大大减少重载函数的数量

fun echo(name:String)=println("$name")

当函数体是有一行时，可通过= 将函数体赋值给函数

嵌套函数

fun function(){
	val str="hello world"
	fun say(count:Int=10){
		println("$count")
		if(count >0){
			say(count-1)
		}
	}
	say()
}

用途：在某些条件下触发递归的函数不希望被外部函数访问到的函数

扩展函数

定义：Kotlin 可以对一个类的属性和方法进行扩展。
扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。

//File 表示函数的接收者，也就是函数扩展的对象  readText 扩展函数的名称
fun File.readText(charset：Charset=Charsets.UTF_8):String =readBytes().toString(cherset)

val file =File()
val content=file.readText()

//在java 中使用FilesKt 调用扩展函数
String content=FilesKt.readText(file,Charsets.UTF-8)

主要用途：对一个第三方sdk 或者说那个类是我们无法控制的时候，当需要新增一些自己需要用到的方法时，可以使用扩展函数

扩展函数的静态解析

//open 非final 子类可继承
open class Animal
class Dog:Animal()

fun Animal.name()="animal"
fun Dog.name()="dog"

fun Animal.printName(anim:Animal){
	println(anim.name())
}
fun main(args:Array<String>){
	Dog.println(Dog())
}

输出结果： animal

//上述代码在编译后，如下
public static final String name(Animal receiver){
	return "animal"
}
public static final String name(Dog receiver){
	return "dog"
}
//添加的扩展函数;
//在编译后，在扩展函数的参数里会多加一个函数，第一个参数是要扩展的那个类的对象
public static final void printlnName(Animal r,Animal a){
	String str=name(a){
	Stystem.out.println(str)
}
//最后在调用printlnName 函数时，Dog 被强转成了Animal 对象的，所以调用的时Animal 的 name
public static final void main(String [] args){
	printlnName((Animal)new Dog(),(Animal)new Dog())
}

结论：kotlin 的扩展函数是静态的给类添加函数，不具备运行时的一个多态效应的

kotlin Lambda 语法

fun main(args:Array<String>){
	val thread =Thread({-> Unit})
	thread.start()
}

//如果lambad 没有参数，可以省略箭头符号 ->
fun main(args:Array<String>){
	val thread =Thread({ })
	thread.start()
}

//如果lambda 是函数的最后一个参数，可以将大括号放在小括号外面
fun main(args:Array<String>){
	val thread =Thread(){}
	thread.start()
}

//如果函数只有一个参数且这个参数就是lambda, 则可以省略小括号

lambda 闭包声明

//{} 表示闭包 ，闭包参数申明后加上箭头，表示后面的部分是lambda 的闭包体
val echo = {name:String -> 
	println(name)
}

在kotlin 中，lambda 闭包的参数是有上限的。
因为kotlin 的类在编译以后会被编译成class 文件，kotlin 的lambda 在编译以后会被编译成匿名内部类，在kotlin 中自定义了22个 functions，functions 后面紧跟的数字就表示有多少个参数。

高阶函数

定义：高阶就是指，函数或lambda 的参数又是一个函数或 lambda

//当lambda 作为参数时，若其没有返回值，也需要显示申明它返回一个Unit 对象
fun onlyif(isDebug :Boolean,block:()->Unit){
	if(isDebug) block()
}
//调用
fun main(args:Array<String>):Unit{
	onlyif(true){
		println("打印日志")
	}
}

重点：在kotlin中函数是“一等公民”

val runnable =Runnable{
	println("Runnable::run")
}

val function:()->Unit
//可以直接使用对象加 :: 后面直接跟方法名的语法，引用一个函数申明。而不像对象直接点一个函数，这样的语法是直接去执行一个函数
在高阶函数的参数中，要想作为函数传递给高阶函数的时候，必须要传递函数的申明
functionn =runnable::run

onlyif(true,function)

内联函数

kotlin 的lambda 在编译的时候会被编译成一个匿名内部类的形式，如果是在代码中有大量重复的lambda 表达式的话，代码会生成很多临时无用的对象，可以使用inline 修饰方法，这样当方法在编译时就会拆解方法的调用为语句调用，进而减少创建不必要的对象

inline fun onlyif(isDebug :Boolean,block:()->Unit){
	if(isDebug) block()
}
//编译后生成如下代码
pbulic static final void onlyif(boolen isDebug,Function0<Unit> block){
	if(isDebug){
		block.invoke()
	}
}

注意：过度使用inline 关键字会增加编译器负担，同时会使代码块变得很庞大，查找起问题来非常麻烦。所以，通常只会用来修饰高阶函数，而不会乱用他