Kotlin的函数基本使用

 package com.example.homework_712

import android.os.Build
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.support.annotation.RequiresApi
import java.nio.file.Files
import java.nio.file.Paths

fun main(args :Array<String>){

    hanshu()

}

fun hanshu(){   //TODO 函数字面量

    val printHello={ println("高阳")}
    println(printHello)

}

fun Feibonaqie(total:Int):Int=when(total){  //TODO 递归 重复调用 耗内存
    0->1
    1->1
    else -> Feibonaqie(total-1)+ Feibonaqie(total-2)
}
// TODO applay 函数

/**
 *  TODO apply函数的返回值是本身，在函数内部，你可以任意调用对象的属性或方法或给属性赋值等apply函数极大的简化了给对象赋值等操作,并且会将自身返回。
 */

fun myApplay(){

    val task= Runnable { println("火箭总冠军") }
    Thread(task).apply { }.start()

    val t= Runnable { println("running") }
    val thread=Thread(t)
    thread.start()
}

//TODO let函数
/**
 * TODO 在let中如果使用return语句，将退出整个函数，如果不使用return语句，退出let块，并返回数值。
 */
fun MyLet():Int{

    "MyLet".plus(){
        println("123")
    }

    return  3030
}


//TODO with 函数
/**
 * todo with函数中的参数是一个对象，我们可以带方法中直接引用对象的公有属性或者公有方法，而不用使用方法名。如果一段代码你需要多次使用一个对象，那么你就可以使用with函数

 */
fun  MyWith(){
   with(ArrayList<String>()){
       add("斯蒂芬库里")
       add("詹姆斯哈登")
       add("保罗乔治")
       add("勒布朗詹姆斯")
       println(this)
   }.let { println(it) }
}

//TODO run 函数    run函数实际上可以说是let和with两个函数的结合体，run函数只接收一个lambda函数为参数，以闭包形式返回，返回值为最后一行的值或者指定的return的表达式
fun MyRun(){
    ArrayList<String>().run {
        add("雪蕊")
        add("梦圆")
        add("若男")
        add("冰倩")


    }.let { println(it) }
}

//TODO Lazy函数   如果你想要线程安全，使用 blockingLazy(): 它还是按照同样的方式工作，但保证了它的值只会在一个线程中计算，并且所有的线程都获取的同一个值。
fun  MyLazy(){  //TODO

    fun requestJson():String="{name  age}"
    val lazy = lazy { requestJson() }
}

// TODO use 函数
/**
 * TODO use函数内部实现也是通过try-catch-finally块捕捉的方式，所以不用担心会有异常抛出导致程序退出 close操作在finally里面执行，所以无论是正常结束还是出现异常，都能正确关闭调用者

 */

@RequiresApi(Build.VERSION_CODES.O)
fun MyUse(){

   val input= Files.newInputStream(Paths.get("f:\\myFormation.txt"))
    val byte=input.use { input.read() }
}

//TODO repeat 函数
/**
 *  TODO 有两个参数  第一个是重复的次数 第二个在大括号里写要执行的代码  一直执行到结束次数完毕
 */
fun MyRepeat(){
     repeat(8,{ println("高阳高阳")})
}

//TODO require 函数
/**
 * TODO  两个参数  1：条件 2：如果不满足则会报的异常错误信息
 */
fun myRequire(x:Int){
    require(x>5,{"数字必须大于5！！！"})
}


//TODO  泛型函数
fun <T>outString(a:T,b:T,c:T):String{

    return "$a,$b,$c"
}

//TODO lambda 的表达式
 /**
  *
  * todo 在Kotlin实际上可以把Lambda表达式分为两个大类，一个是普通的lambda表达式，另一个则是带接收者的lambda表达式
  * TODO 基本用法
  *
  * TODO 1 含有实际参数
  * TODO 2 含有函数体(尽管函数体为空，也得声明出来)
  * TODO 3 以上内部必须被包含在花括号内部
  *
  */

fun MyLambda(a:Int,b:Int):Int{

     return a+b;
 }

//TODO lambda的语法  {参数1,参数2,参数3,参数n -> 要执行的参数}
var Sum={x:Int,y:Int->x*y}

//TODO 高阶函数：才函数中可以有n个参数 在这n个参数里可以有函数作为参数 或者以返回值作为参数