kotlin语言 变量和函数

变量, 常量, 类型

import org.example.Main
import java.util.stream.Stream

    // 编译时常量, 支持如下类型 : String ,Int ,Double ,Float ,Long ,Short ,Byte ,Char ,Boolean
    const val MAX_VAlUE = 256
fun main() {
    // 声明一个变量
    var aInt: Int = 1 // kotlin可以自动推断出类型时, 类型声明可以省略
    // 声明一个常量
    val bInt = 2

    /*
        Kotlin 只提供引用类型这一种数据类型, 没有基本类型
        但实际上会被编译器视情况优化为java的基本类型

        kotlin内置的数据类型:
            String 字符串 "Estragon"
            char 单字符 'X'
            Boolean
            Int
            Double 小数 3.14
            List 元素集合 3, 1, 2, 4, 3
            Set 无重复元素的集合 "Larry", "Moe", "Curly"
            Map 键值对集合 "small" to 5.99, "medium" to 7.99, "large" to 10.99

    */

    // range
    var aRange = 1..3
    println((1..3).toList()) // [1, 2, 3]

    // for cycle in kotlin
    for (i in aRange) {
        println(i) //123
    }

    for(i in 1 until 3){
        println(i) //12
    }

    // `if-else` and `when` in kotlin is an expression not a statement


    // when expression , similar to switch in java
    var aCase = "1";
    val faction = when (aCase) {
        "1" -> "Keepers of the Mines"
        "2" -> "Keepers of the Mines"
        "3" -> "Free People of the Rolling Hills"
        "4" -> "Free People of the Rolling Hills"
        else -> {}
    }

    // string template can add variable or expression in string
    var int1 = 1
    println("hello ${int1}")
    println("hello $int1") // only variable can omit `{}`


}

函数

函数基础

fun main() {
    fun1(1)
    fun1(1,2,3)
    fun1(1,b=2,a=1)

}
// 默认参数
fun fun1(n: Int, a:Int=0, b:Int=1):Int{
    println("n =$n, a = $a, b = $b")
    return 0
}

// todo: 如果在默认参数之后的最后⼀个参数是 lambda 表达式，它可以在括号外传⼊：


// 单表达式函数 , 返回类型可自动推断时可省略
fun doubleX1(x: Int) = x * 2

fun test1() {
    // 可变数量的参数, 可传入多个此类型的变量作为参数
    fun varArgFun(vararg a: Int, b: Int) {
        println("a=$a, b=$b")
        println(a::class.java.simpleName) // int[]
    }
    varArgFun(1,2,3,b=2)
    // 数组前面加*, 伸展（spread）操作符数据内容作为可变参数的一部分(有点像C语言)
    varArgFun(*(intArrayOf(1,2)),3,b=2)

    // infix 中缀函数
    infix fun Int.doubleX(x: Int): Int {
        return x*2
    }
    // ⽤中缀表⽰法调⽤该函数
    1 doubleX 2
    // 等同于这样
    1.doubleX(2)

    // kotlin支持局部函数, 此局部函数支持闭包
    var c = 1;
    fun closureTest(){
        c =2;
    }
}

⾼阶函数与 lambda 表达式

Kotlin 函数都是头等的，函数一种类型, 可以实例化函数对象

函数类型实例化

1. 使⽤函数字⾯值的代码块

   lambda 表达式: { a, b -> a + b }

   匿名函数: fun(s: String): Int { return s.toIntOrNull() ?: 0 }

2. 已有函数的引用, 用双冒号加函数名

   顶层、局部、成员、扩展函数：::isOdd 、String::toInt

   顶层、成员、扩展属性：List::size

   构造函数：::Regex

3. 函数类型的类实例化

   class IntTransformer: (Int) -> Int {
   override operator fun invoke(x: Int): Int = TODO()
   }
   val intFunction: (Int) -> Int = IntTransformer()
   
   

执行函数实例

1. 通过其 invoke(……) 操作符调⽤：f.invoke(x)
2. 直接 f(x)

Lambda 表达式

Lambda 表达式的完整语法形式如下：

​ val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

省略所有可以省略的后

​ val sum = { x: Int, y: Int -> x + y }

拖尾 lambda 表达式 :

​ 如果函数的最后⼀个参数是函数，那么作为相应参数传⼊的 lambda 表达式可以放在 圆括号之外：

​ val product = items.fold(1) { acc, e -> acc * e }

it：单个参数的隐式名称, 如果编译器⾃⼰可以识别出签名, 可以这样写

​ ints.filter { it > 0 }

从 lambda 表达式中返回⼀个值, 下面两个调用等价

ints.filter {
	val shouldFilter = it > 0
	shouldFilter
}

ints.filter {
	val shouldFilter = it > 0
	return@filter shouldFilter
}

!!! lambda不能指定函数返回的类型

匿名函数

以下匿名函数等价, 匿名函数总是需要return

var fun2 = fun(x: Int, y: Int): Int = x + y

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

使用时和函数一样

ints.filter(fun(item) = item > 0)

闭包