三、表达式

一. 常量和变量

变量

var a = 2

val b = 2 // 只读变量

常量
使用 const 关键字修饰，只能定义在全局范围，只能修饰基本类型，必须立即用字面量初始化

const val b = 3 // 等同于 Java 中 static final int b = 3;

常量引用

val person = Person(18, "Andy") // person是堆上创建对象
person.age = 19 // 对象改变但引用没变

编译期和运行时常量

const val b = 3

编译时即可确定常量的值，并用值替换调用处

val c: Int

运行时才能确定值，调用处通过引用获取值

二. 分支表达式

if ... else ..
和 Java 的 if 语句一样，只是在 kotlin 中叫表达式
when
等同于 Java 中的 switch

// java
switch (a) {
  case 0: 
    c = 5;
  break
  default:
    c = 20;
}

// kotlin
when(a) {
  0 -> c = 5
  else -> c= 20
}
// 改善成：
c = when(a) {
  0 -> 5
  else -> 20
}

Java 中的 when 在 kotlin 中

var x: Any = ...
c = when {
  x is String -> x.length
  x == 1 -> 100
  else -> 20
}

c = when(val input = readLine()) {
  null -> 0
  else -> input.length
}

try ... catch

try {
  c = a / b
} catch (e : Exception){
  e.printStackTrace()
  c = 0
}

三. 运算符与中缀表达式

运算符
（1）kotlin 支持运算符重载
（2）运算符的范围仅限官方指定的符号
可以看一下官网介绍：
https://kotlinlang.org/docs/reference/operator-overloading.html
比较常见的：
（1）== 与 equals

// 这两个写法一样
"Hello" == "World"
"Hello".equals("World")

（2）"+" 与 plus
（4）in 与 contains
（5）[] 与 get

val map = mapOf(
  "Hello" to 2,
  "World" to 3)

val value = map["Hello"]
// 等同于
val value = map.get("Hello")

（6）[] 与 set

val map = mutableMapOf(
  "Hello" to 2,
  "World" to 3)

map["World"] = 4
// 等同于
map.set("World",4)

（7）> 与 compareTo

2 > 3
// 等同于
2.compareTo(3) > 0

（8）() 与 invoke

val func = fun(){
  println("Hello")
}

func()
// 等同于
func.invoke()

中缀表达式

2 to 3

infix fun <A,B> A.to(that: B): Pair<A, B> = Pair(this, that)

四. Lambda 表达式

一个普通函数

fun func(){
  println("Hello")
}

匿名函数，去掉函数名 func

fun(){
  println("Hello")
}

匿名函数的传递，此时的 func 是变量名

val func = fun(){
  println("Hello")
}

匿名函数的类型

val func: () -> Unit = fun(){
  println("Hello")
}

Lambda 表达式的定义
Java 中 Lambda 表达式是一个 AMS 格式的语法糖，kotlin 中 Lambda 是一个匿名函数的语法糖。

// Java
Runnable lambda = () -> {
  System.out.println("Hello")
};

// Kotlin
val lambda = {
  println("Hello")
}

Lambda 表达式的类型，返回值的类型就是函数体最后一行返回类型，返回值就是最后一行
（1）没有参数的

val lambda: () -> Unit = {
  println("Hello")
}

（2）有参数的

// java
interface Function1 {
  void invoke(int p);
}
Function1 f1 = (p) -> {
  System.out.println(p);
}

// Kotlin
val f1: (Int) -> Unit = {
  p: Int -> println(p)
}
//或
val f1: Function1<Int,Unit> = {
  p -> println(p)
}
//或
val f1= {
  p: Int -> println(p)
}

（3）参数省略形式

val f1: Function1<Int,Unit> = {
  println(it)
}

五. 案例

为 String 实现四则运算

operator fun String.minus(right: Any?) 
  = this.replaceFirst(right.toString(), "")

operator fun String.times(right: Int): String {
  return (1..right).joinToString(""){this}
}

operator fun String.div(right: Any?): Int {
  val right = right.toString()
  return this.windowed(right.length,1) {
    it == right
  }.count{ it }
}

fun main() {
  val value = "HelloWorld World"

  println(value - "World")

  println(value * 2)

  println(value / "l")


}