方法的声明

fun main() {
    println(functionLearn(10))
}

fun functionLearn(days:Int):Boolean{
    return days>100
}

在kotlin 中，函数是一等公民，可以直接申明。无须写在类中

成员方法

fun main(){
	Person().test1()
}
class Person{
	fun test1(){
		println("成员方法")
	}
}

类方法（静态方法）

在kotlin 中没有static 关键字，需要使用 companin object(伴生对象)

fun main(){
	Person().test1()
	Person.test2()
}
class Person{
	fun test1(){
		println("成员方法")
	}
	companion object {
		fun test2(){
		println("类方法")
		}
	}
}

通过object 修饰类，可以定义一个静态类。如下
应用场景：工具类

fun main(){
	NumUtil.double(2)
}
object NumUtil{
	fun double(num :Int):Int{
		return num*2
	}
}

单表达式方法

当方法返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可

fun double(x:Int):Int = x*2

局部方法

kotlin 方法可以申明在一些局部的作用域里（在方法中再定义方法）

fun main(){
	 magic()
}
fun magic(){
	fun foo(v:Int):Int{
		return 	v*v
	}
	
	val v1=(0..100).random()
	return foo(v1)
}

方法高级特性

高阶函数

定义：将函数作为参数或者作为返回值的函数

函数作为参数

fun main(){
    val list = listOf<Int>(1,2,3)
    val result= list.sum{
        println("${it}")
    }
    println("result ${result}")
}


fun List<Int>.sum(callback:(Int)->Unit):Int{
    var result = 0
    for(v in this){//this 代表 List<Int>
        result+=v
        callback(v)
    }
    return result
}

函数作为返回值

fun main() {
    val listString = listOf<String>("1","2","3","4")
    val  result2=listString.toIntSum()(2)
    println("计算结果${result2}")
}
fun List<String>.toIntSum(): (scale: Int) -> Float {
    println("第一层函数")
    return fun(scale): Float {
        var result = 0f
        for (v in this) {
            result += v.toInt() * scale
        }
        return result
    }
}

闭包（Cloure）

闭包可以理解为能够读取其他方法内部变量的方法
闭包是将方法内部和方法外部连接起来的桥梁

闭包的特性

• 方法可以作为另一个方法的返回值或参数，还可以作为一个变量的值
• 方法可以嵌套定义，即在一个方法内部可以定义另一个方法

闭包的好处

• 加强模块化（能够已简单的方式开发较小的模块，从而提高开发速率，和程序的复用性）
• 抽象（闭包是数据和行为的一些组合，使得闭包拥有较好的抽象能力）
• 灵活
• 代码简洁

示例

fun main(){
	testClosure(1)(2){
        println(it)
    }
}
fun testClosure(v1: Int): (v2:Int, (Int) -> Unit) -> Unit {
    return fun(v2: Int, printer: (Int) -> Unit) {
        printer(v1+v2)
    }
}

解构申明

data class Result(var msg:String , var code:Int)
fun test1(){
	var result = Result("succecs",0)
	val (msg,code)=result
	println("msg: ${msg}  code:${code}")
}

匿名方法

顾名思义没有方法名的方法就叫匿名方法

val fun(x:Int,y:Int) :Int = {
	return x+y
}

kotlin 方法字面值

可以理解为未申明的方法

//定义了一个变量temp ,而变量的类型是（Int）->Boolean 是个函数

fun test2(){
	var temp:((Int)-> Boolean)?=null
	//{num -> (num>10)} 方法字面值
	temp = {num -> (num>10)}
	println("temp(11) : ${temp(11)}")
}

方法参数

默认参数

方法参数可以有默认值，当省略相应的参数时使用默认值
优点：与Java相比，这可以减少重载数量

fun read(b:Array<Byte>,off:Int=0,len:Int =b.size){
}

可变数量参数

通过vararg 来修饰可变数量的参数

fun main(){
	println(append('a','b','c'))
}
fun append(vararg str:Char):String{
	val result = StringBuffer()
	for(char in str){
		result.append(char)
	}
	return result.toString()
}

Lambda 表达式

特点

view.setOnClickListener(new View.OnClickListener(){
	@Override
	public void onClick(View v){
		Toast.markText(v.getContent(),"lambda 简介之道",Toast.LENGth_LONG).show();
	}
})

VS

view.setOnClickListener{ v -> Toast.markText(v.getContent(),"lambda 简介之道",Toast.LENGth_LONG).show();}

• 是匿名方法
• 二是可传递（Lambda 表达式可作为参数传递）

Lambda 语法

无参数情况：

var/val 变量名 = {操作的代码}

fun test(){
	println("无参数")
}
//lambda 语法
val test = {println("无参数")}

有参数的情况

var/val 变量名:(参数的类型，参数类型，...) -> 返回值类型 = {参数1，参数2 -> 
	操作的代码
}
val test1:(Int,Int) ->Int={a,b -> 
	a+b
}
等价于
var/val 变量名 = {参数1:类型，参数2：:类型，... ->
	操作参数的代码
	}
val test1={a:Int,b:Int ->
	a+b
}

认识it

• it 并不是kotlin 中的一个关键字（保留字）
• it 是在当一个高阶方法中Lambda 表达式的参数只有一个的时候可以使用it 来使用此参数
• it 可表示为单个参数的隐式名称，是kotlin 语言约定的

//这里举例一个kotlin 语言自带的一个高阶方法filter ,此方法的作用是过滤掉不满足条件的值
val arr = arrayOf(1,3,5,7,9)
//过滤掉数组中元素小于2的元素，取其第一个打印。这里的it就表示每一个元素
println(arr.filter{it <5}.component1())

如何使用下划线_

在使用lambda 表达时的时候，可以用下划线（_）表示未使用的参数，表示不处理这个参数。
在遍历一个Map 集合的时候，这当非常有用

val map=mapOf("key1" to "vul1","key2" to "vul2")
map.forEach{(key,value)->
	println("$key $ value")
} 
//当不需要key 时
map.forEach{(_,value)->
    println(" $ value")
}