Kotlin 基础-程序结构(上)

作者: 小小小小怪兽_666 | 来源:发表于2019-03-14 16:09 被阅读43次

    Kotlin 基础-程序结构(上)

    一、常量与变量

    1.1 类型推导

    在 Kotlin 中,只要是编译器认识的类型,就可以自动推导出变量的类型,不需要我们显示的指定。

    val a = "fancyluo" //推导 String
    val b = 666        //推导 Int
    val c = a + b      //推导 String
    

    1.2 常量

    Kotlin 中使用 value 的缩写 val 来表示一个不可变的值类型,与 Java 中 final 的用法类似。

    // Java
    public static final String NAME = "fancyluo"
     
    // Kotlin
    val NAME = "fancyluo"
    

    以上的两行代码在使用上来说是一样的,如果你想重新给「NAME」赋值,是不被允许的,编译器会报错。 但是,它们本质上还是有区别的,下面引入一个概念 编译期常量:值在编译期就已经确定的常量,并且会把对它的引用全部替换为它的值。 Java 使用 final 定义的是编译期常量,而 Kotlin 使用 val 定义的是不可变的值类型,也可以称为运行时常量。如果想要在 Kotlin 中定义编译期常量,那么需要使用 const 关键字。

    const val NAME = "fancyluo"
    

    1.3 变量

    Kotlin 中使用 variable 的缩写 var 来表示变量,变量可以被重新赋值。

    var x = "fancyluo"
    x = "HiphopMan"
    

    二、函数

    我们先来看看函数的语法,如下

    - fun [函数名]([参数列表]):[返回值类型]{[函数体]}
    - fun [函数名]([参数列表]) = [表达式]
    

    Kotlin 中的函数以 fun 开头,下面以几个例子来说明 Kotlin 函数的使用方法。

    2.1 有返回值

    Kotlin 中函数的返回值写在参数列表的后面,以冒号加一个返回值的类型表示。

    fun count(price: Int, sum: Int): Int {
        return price * sum
    }
    

    如果一个函数只是返回一个表达式的值,那可以使用更简洁的写法,直接使用等号后面跟表达式即可。

    fun count(price: Int, sum: Int): Int = price * sum
    

    如果可以推导出表达式的类型,那么返回值也可以忽略不写。

    fun count(price: Int, sum: Int) = price * sum
    

    2.2 无返回值

    Kotlin 中函数如果没有返回值,默认返回的是 Unit,类似于 Java 中的 void。Unit 本身没什么意义,平时开发中并不用显示的指定,只要知道这么一回事就好了。

    fun printName(name:String):Unit{
        println(name)
    }
    

    当函数体为一个表达式的时候可以用简化的写法,这时候函数的返回值就是表达式的返回值,都是返回 Unit。

    fun printName(name:String) = println(name)
    

    2.3 匿名函数

    匿名函数无需函数名,但必须赋值给一个变量或常量,否则编译器会报错。

    var sum = fun(a: Int, b: Int) = a + b
     
    println(sum(6,6))
    

    2.4 编写函数的建议

    1.遵循单一职责原则,功能要单一。
    2.函数起名应该要顾名思义,尽量避免不符合规范的命名。
    3.参数的个数不要太多。

    三、Lambda 表达式

    3.1 语法与示例

    我们先来看看 Lambda 表达式的语法。

    • {[参数列表] -> [函数体,最后一行是返回值]}

    Lambda 表达式其实也就是匿名函数,下面看个例子。

    // 匿名函数
    var sum = fun(a: Int, b: Int) = a + b
    // Lambda 表达式
    var sum = { a: Int, b: Int -> a + b }
    // 无参无返回值
    var printName = { println("fancyluo") }
    

    可以看到,上面定义的 Lambda 表达式有两个参数 a 和 b,a + b 则为表达式的返回值,参数和返回值之间使用 -> 来分隔。如果 Lambda 表达式没有返回值,那么 -> 可以省略。 大家看到前面的例子会不会认为 Lambda 表达式只能写一行呢?其实不然,函数体可以有多行,最后一行为 Lambda 表达式的返回值。

    var sum = { a: Int, b: Int ->
        println("a + b = ${a + b}")
        a + b
    }
    

    那么 Lambda 表达式如何调用呢?使用 (),相当于执行了 invoke()。

    println(sum(1, 2))
    println(sum.invoke(1, 2))
    

    3.2 Lambda 表达式的类型

    在 Kotlin 中,函数也是一种类型,可以被赋值和传递

    // 无参且返回值为 Unit 的函数类型:() -> Unit
    val printName = { print("fancyluo")}
     
    // 接收两个整型参数且返回一个整型的函数类型:(Int,Int) -> Int
    val sum = { a: Int, b: Int -> a + b }
     
    // Array 的扩展方法
    // 接收一个 T 类型参数并返回 Unit 类型的函数类型
    public inline fun <T> Array<out T>.forEach(action: (T) -> Unit): Unit {
        for (element in this) action(element)
    }
    

    前面我们说过,调用 Lambda 表达式就是调用其 invoke() 方法,而 Kotlin 在Functions.kt 文件里定义了 Function0 ~ Function22 这 23 个类型,Lambda 表达式的invoke() 方法接收几个参数,叫表明它是 FuntionN 类型。以上面的例子来说,printName 就是 Function0 类型,sum 就是 Function2 类型。

    // Function0 类型:() -> Unit
    public interface Function0<out R> : Function<R> {
        public operator fun invoke(): R
    }
     
    // Function2 类型:(Int,Int) -> Int
    public interface Function2<in P1, in P2, out R> : Function<R> {
        public operator fun invoke(p1: P1, p2: P2): R
    }
    

    那如果我们定义了接收 23 个参数的 Lambda 表达式呢?那么运行时就会抛出找不到Function23 这个类的异常。

    3.3 Lambda 表达式的简化

    当使用 Lambda 表达式作为函数的参数时,可以有很多简化的写法,下面一一演示。

    // 完整写法 
    intArrayOf(1, 2, 3, 4).forEach({ element -> println(element) })
     
    // Lambda 表达式参数只有一个的时候,可以忽略不写,使用 it 代替
    intArrayOf(1, 2, 3, 4).forEach({ println(it) })
     
    // 函数的最后一个参数是 Lambda 表达式,大括号可以移到括号外边
    intArrayOf(1, 2, 3, 4).forEach(){ println(it) }
     
    // 函数只有Lambda 表达式一个参数,小括号也可以省略
    intArrayOf(1, 2, 3, 4).forEach{ println(it) }
     
    // forEach 参数类型:(T) -> Unit
    // println 函数类型:(Any) -> Unit
    // 入参、返回值与形参一致的函数可以用函数引用的方式作为实参传入
    intArrayOf(1, 2, 3, 4).forEach(::println)
    

    最后再提一个问题,看如下代码。

    fun main(args: Array<String>) {
        intArrayOf(1, 2, 3, 4).forEach {
            if (it == 3) return
            println(it)
        }
        println("这里不会被打印")
    }
    
    

    在 Lambda 表达式里面使用 return 相当于 return 了 main 函数。如果只想终止迭代的话,需要使用标签。

    fun main(args: Array<String>) {
        intArrayOf(1, 2, 3, 4).forEach ForEach@ {
            if (it == 3) return@ForEach
            println(it)
        }
        println("这里不会被打印")
    }
    

    相关文章

      网友评论

        本文标题:Kotlin 基础-程序结构(上)

        本文链接:https://www.haomeiwen.com/subject/mihcmqtx.html