Kotlin-函数

4.1 模块化程序设计

独立模块由顺序、分支和循环着三种基本结构组成，其特点主要表现在主程序与独立模块之间的数据输入和输出。即主程序与模块函数之间的数据传递

//计算1!+2!+3!+4!+....+7!+8!
fun sum( n:Int) :Double{
    var i=1
    var s:Double=0.0
    do{
        s=s+ fac(i)
        i++
    }while(i<=n)
    return s
}

fun fac(n:Int) :Double{
    var i:Int=1
    var f:Double=1.0

    for(hh in 1..n){
        f=f*i
        i++
    }
    return f
}

fun main(args:Array<String>){
    println(sum(8))
}

4.2函数定义

//函数定义
fun double(x:Int):Int{
    return 2*x
}

无默认值函数

//函数定义
fun double(x:Int):Int{
    return 2*x
}

有默认值函数

//有默认值函数
fun plus(a:Int,b:Int=0):Int{
    return a+b
}

单表达式函数

//单表达式函数
fun ex(x:Int):Int=x*2

fun no(nub:Int):Int{
    if(nub!=null){
        return nub
    }else{
        return 0
    }
}
fun main(args:Array<String>){
    println(no(10))
}

4.3函数调用

无默认值的函数调用

//无默认值的函数调用
fun main(args:Array<String>){
    println(double(10))
}

有默认值的函数调用

//有默认值的函数调用
fun main(args:Array<String>){
    println(plus(10))

    println(plus(10,15))
}

4.4可变参数

//可变参数函数的使用
fun <T> asList(vararg ts :T): List<T>{
    val result=ArrayList<T>()
    for(t in ts) result.add(t)
    return result
}

fun main(args:Array<String>){
    val a=arrayOf(1,2,3)
    val list=asList(-1,0,*a,4)
    println(list)
}

//尾递归函数
tailrec fun fac(n:Int):Double{
    var t:Double=1.0
    if(n==0||n==1){
        t=1.0
    }else{
        t=n*fac(n-1)
    }
    return t
}

4.6高阶函数

fun <T> lock(lock:Lock,body:()->:T){
    lock.lock()
    try{
        return body()
    }
    finally {
        lock.unlock
    }
}

map是常用的高阶函数

fun <T,R> list<T>.map(transform:(T)->R):List<R>{
    val result=arratListOf<R>()
    for(item in this)
        result.add(transform(item))
    return result
}

4.8Lambda表达式

更改数组中的元素

//更改数组中的元素
fun main(args:Array<String>){
    val a=arrayOf(5,4,3)
    val b=a.map{"第${it}个"}
    for(s in b){
        println(s)
    }
}