Kotlin 基础-程序结构（上）

1、常量与变量

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"
复制代码

2、函数

咱们先来看看函数的语法，以下

- 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 编写函数的建议

• 遵循单一职责原则，功能要单一。
• 函数起名应该要顾名思义，尽可能避免不符合规范的命名。
• 参数的个数不要太多。

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("这里不会被打印")
}
复制代码