目录：
1、函数的特性语法
2、嵌套函数
3、扩展函数
4、Lambda闭包语法
5、高阶函数
6、内联函数

1、函数的特性语法

• 函数的参数可以声明默认值
• 如果函数体只有一个语句的话，可以将该语句直接赋值给该函数。

fun echo(name:String){
    println("$name")
}
fun echo(name:String = "Zhangtao"){
    println("$name")
}
fun echo(name:String) = println("$name")

2、函数嵌套

用途：在某些情况下出发递归的函数，或不希望被外部函数访问到的函数。

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

3、扩展函数

kotlin特性：静态给一个类扩展成员方法和成员变量。
用类名点方法名的方式

//给File类扩展一个readText方法
fun File.readText(charset:Charset = Charsets.UTF-8):String=readBytes().toString(charset)

//调用
fun main(args:Array<String>){
    val file = File("Project2.iml")
    println(file.readText())
}

java如何使用kotlin的扩展函数呢？

public class Main{
    public static void main(String[] args){
        File file = new File("project2.iml");
        String content = FilesKt.readText(file,Charsets.UTF-8);
        System.out.println(content);
    }
}

注：该扩展函数并不是File本身的函数，它编译的时候会被编译到那个类对应的class里面去，在java中我们调用的是FileKt，第一个参数是需要扩展这个类的对象，该参数不可省略。

• 为什么说这是静态的扩展呢？

//open值得是不final，与java的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().printName(Dog())//这里输出animal
}

• kotlin的扩展函数它实际上是静态的给一个类添加的，它是不具备运行时的一个多态效应的。

编译完之后：

public static final String name(Animal receiver){
    return "animal";
}
public static final String name(Dog receiver){
    return "dog";
}
public static final void printName(Animal r,Animal a){
    String str = name(a)
    System.out.println(str);
}
public static final void main(String [] args){
    //强转成了animal
    printName((Animal)new Dog(), (Animal)new Dog());
}

4、kotlin的lambda闭包

public static void main(String[] args){
    Thread thread = new Thread(new Runnable(){
        public void run(){
            // ...
        }
    });
    thread.start();
}

Java8的Lambda语法：

• 将Runnable对象省略成()-> 的形式替代。

public static void main(String[] args){
    Thread thread = new Thread(() -> {
        //...
    });
    thread.start();
}

kotlin的Lambda语法：

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

• 如果Lambda没有参数，可以省略箭头符号->

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

• 如果Lambda是函数的最后一个参数，可以将大括号放在小括号外面

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

• 最简单形态：如果函数只有一个参数且这个参数是Lambda，则可以省略小括号

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

• 如果Lambda只有一个参数的话，可以不写，然后用it去替代它。

val letResult = user.let(user:User->"let::${user.javaClass}")
|
|
val letResult = user.let{"let::${it.javaClass}"}

Lambda闭包声明

//name:String：参数
//->：闭包体
val echo = { name:String ->
    println(name)
}
fun main(args: Array<String>){
    echo.invoke("hello")
    echo("hello ")
}

• Lambda参数有上限22个。
• 如果传23个，会抛出NoClassDefFoundError，因为编译成class的时候，会编译成Funcation23，但是内置最多Funcation22，所以才会找不到。

fun onlyif(isDebug:Boolean,block:()->Unit){
    if (isDebug)block()
}
fun main(args:Array<String>):Unit{
    onlyif(true){
        println("打印日志")
    }
}

• 注意：main函数中onlyif(true)用大括号括起来的部分是Lambda函数(onlyif第二参)，当Lambda作为函数的最后一个参数时，可以写在函数的小括号之外。

5、高阶函数

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

• 对象.函数，这种是函数的调用。
• 如果要把函数当做参数传递，需要传递一个函数的声明。
• 如果传递的是“执行函数”的话，传递的实际上是函数的返回值。

val runnable = Runnable{
    println("Runnable::run")
}
//声明一个参数为空，无返回值的函数对象
val funcation:() -> Unit
//将runnable的run方法赋值给声明好的函数
function = runnable::run
//将该函数作为参数传递给onlyif
onlyif(true,function)

6、用内联优化代码

• Kotlin的Lambda是一个匿名对象
• 可以使用inline修饰方法，这样当方法在编译时就会拆解方法的调用为语句调用，进而减少创建不必要的对象。

创建方式：在高阶函数之前增加inline关键字。

inline fun onlyif(isDebug:Boolean,block:()->Unit){
    if (isDebug)block()
}
fun main(args:Array<String>):Unit{
    onlyif(true){
        println("打印日志")
    }
}

编译后的class：

public static final void onlyif(boolean isDebug,Function0<Unit>block){
    if(isDebug){
        block.invoke();
    }
}
public static final void main(String[] args){
    //拆解成了语句调用
    boolean isDebug = true;
    if(isDebug){
        String str = "打印日志";
        System.out.println(str);
    }
}

过分使用inline关键字会造成：

• 增加编译器编译的负担。
• 使得代码块变得庞大。