一.函数

1.函数的声明，关键字是fun
    fun getSum(a: Int, b: Int): Int {
        return (a + b)
}
fun test(): Unit {
    
}
解释：函数名称，参数类型，返回值类型(没有返回值则省略或者用Unit代替)
2.函数的调用和Java一样，方法名或者通过对象调用
3.参数:
    1.形式，name:type,多个参数用,隔开
    2.默认参数:参数可以用默认值,默认值通过类型后面的 = 及给出的值来定义。当省略相应的参数时，该参数使用默认值:
    class User {
        fun getSum(a: Int, b: Int=5): Int {
            return (a + b)
        }
    }
    //使用
    var user = User()
    var sum = user.getSum(5)
    println("带有默认参数的计算结果为:$sum")//带有默认参数的计算结果为:10
    sum = user.getSum(5,10)
    println("正常的的计算结果为:$sum")//正常的的计算结果为:15
    3.覆盖函数：
        1.如果覆盖一个带有默认参数的函数时，必须从函数签名中省略默认的参数值:
            open class A {
                open fun foo(i: Int = 10) { /*......*/ }
            }
            class B : A() {
                override fun foo(i: Int) { /*......*/ } // 不能有默认值
            } 
    4.具名参数：可以在调用函数时使用具名的函数参数。
    5.单表达式函数：
        当函数返回单个表达式时，可以省略花括号并且在=符号之后指定代码体即可，当然，返回值也是可选的
        fun doubldTheNumber(number: Int): Int = number * 2
    6.可变数量的参数:
        1.函数的参数(通常是最后一个)可以用vararg修饰符标记
4.函数的作用域
    1.在Kotlin中，函数可以在文件的顶层声明（而Java中，函数必须作为类的一部分），此外，除了顶层函数，Kotlin中函数也可以声明在局部作用域，作为成员函数以及扩展函数
    2.局部函数:一个函数在另一个函数的内部(java中没有)
        class User {
            fun test() {
                var a = 1
                fun innerTest() {
                    println("inner print a:$a")
                }
            innerTest()
            println("out print a:$a")
        }
        //inner print a:1
        //out print a:1
        成员函数可以访问外部函数的局部变量
    3.成员函数：类或对象内部定义的函数
    4.泛型函数
        class User {
            fun <T> singleTonList(item: T): List<T> {
                return listOf(item)
            }
        }
5.尾递归        
6.高阶函数
    1.Kotlin的函数都是头等的，这意味着，它们可以存储于变量与数据结构中，作为参数传递给其他高阶函数以及从其他高阶函数返回
    2.高阶函数:将函数作为参数或者将函数作为返回值的参数
7.Lambda表达式
    1.Lambda表达式的完整语法:
        var sum: (Int, Int) -> Int = { x: Int, y: Int ->x + y}
    解释:Lambda表达式总是扩在花括号内，完整语法形式的参数放在花括号内，并有可选的类型标注，函数体跟在一个->符号之后，如果Lambda表达式
    推断出返回类型不是Unit，那么该Lambda主体中的最后一个(或可能是单个)表达式会视为返回值，
    如果把所有的可选标注都留下，则看起来如下:
      var total = { x, y -> x + y }//这个式子报错，没明白啥意思
    2.传递末尾的Lambda表达式
        在Kotlin中有个约定:如果函数的最后一个参数是函数，那么作为相应参数传入的Lambda表达式，可以放在圆括号外
            var items = listOf<Int>()
            val product = items.fold(1) { acc, e -> acc * e }
        同样一脸懵逼...
    3.it:单个参数的隐式名称
        如果编译器可以自己识别出签名，也可以不用声明唯一的参数并忽略->.该参数会隐式声明为it
    4.从Lambda表达式中返回一个值
        我们可以使用限定的返回语法从 lambda 显式返回一个值。否则，将隐式返回最后一个表达式的值。
        因此，以下两个片段是等价的:（懵逼...）
        ints.filter {
            val shouldFilter = it > 0 shouldFilter
        }
        ints.filter {
            val shouldFilter = it > 0 return@filter shouldFilter
        }
        这一约定连同在圆括号外传递 lambda 表达式一起支持 LINQ-⻛格 的代码:
        strings.filter { it.length == 5 }.sortedBy { it }.map { it.toUpperCase() }
8.匿名函数
9.闭包
10.带有接收者的函数字面值
11.内联函数
    1.禁用内联
    2.非局部返回
12.具体化的类型参数