Kotlin

• Kotlin从Scala语言上借鉴了很多, 但更像是精挑细选有利特性得到的子集,
  这使得它比Scala适合用于工程, 因为范式选择的余地更小, 学习成本更低.
• Kotlin兼容Java生态的能力比Scala强.
• Kotlin的编译速度比Scala快.
• Kotlin社区没有Scala社区那么有毒.

// 扩展类的方法
fun String.addEnthusiasm(amount: Int = 1) = this + "!".repeat(amount)
println("Hello World".addEnthusiasm())
// 扩展类的伴生对象
fun String.Companion.toURL(link: String) = java.net.URL(link)
// 扩展匹配接口的任意函数
fun <T, R, U> ((T) -> R).andThen(next: (R) -> U): (T) -> U = { input: T ->
  next(this(input))
}

val String.newVowels
    get() = count { "aeiouy".contains(it) }

fun interface IntPredicate {
  fun accept(i: Int): Boolean
}
val isEven = IntPredicate { it %2 == 0 }

• 接口不能包含字段.
• 一个类只能继承一个抽象类, 但可以实现多个接口.
• 抽象类有构造函数, 接口没有构造函数.

class Person {
  companion object {
    fun load() {
      // ...
    }
  }
}

window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
      // ...
    }
  }
)

• 主构造函数的参数
• 属性, 从上往下依序初始化.
  如果期间遇到init块, 则运行init块.
• 次构造函数

class Rect(val height: Int, val width: Int) {
  // 定义类的不可变属性
  val isSquare: Booolean
  // 覆盖该属性的getter
  get() = height == width
  // 定义类的可变属性
  var name: String
  // 覆盖该属性的setter
  set(value) {
    field = value.trim()
  }
}

• public(默认)
• private
• protected
• internal

class Child(arg1, arg2) : Super(arg1, arg2)

class Point(val: x: Int, val y: Int) {
  operator fun plus(other: Point): Point {
    return Point(x + other.x, y + other.y)
  }
}

• Any? 所有类型
• Any 所有非空类型

• Byte
• Short
• Int
• Long

• Float
• Double

• Char
• String

• requireNotNull, 参数为null值时抛出IllegalArgumentException异常, 否则返回非null值
  它的抛出的异常类型决定了该断言通常写在函数开头, 用来检查函数的输入值.
• checkNotNull, 参数为null值时抛出IllegalStateException异常, 否则返回非null值
  可以在任何地方使用, 和requireNotNull的唯一区别是抛出的异常类型不同.
• error, 参需为null时抛出异常并打印错误信息, 否则返回非null值

• require, 参数为false时抛出异常
• assert, 参数为false是抛出异常, 并在编译器上标记

// lambda表达式
val log: (String, String) -> String = { sender, message -> 
  // lambda表达式内不能使用return关键字, 只有最后一个表达式会返回
  "$sender: $message"
}
// 有参数类型定义的lambda表达式
{ sender: String, message: String ->
  "$sender: $message"
}
// 无参数lambda表达式可以省略参数部分
{
  val message = "Hello World"
  println(message)
}()
// 单参数lambda表达式可以用it关键字缩写
{ it == 'something' }
// 相当于
{ x -> x == 'something' }

val result = if (condition) {
  "True"
} else {
  "False"
}
// 省略花括号
val result = if (condition) "True" else "False"

val result = when (value) {
  0 -> "It is small"
  in 1..99 -> "It is normal"
  else -> "It is big"
}

val multiline = """Line1
                  |Line2
                  |Line3""" // 使用|创建不包含空白缩进的跨行字符串
val multiline = """Line1
                  ~Line2
                  ~Line3""".trimMargin("~") // 创建不包含空白缩进的跨行字符串的另一种方法

val name = "World"
println("Hello $name") // 插入变量
println("Hello ${name}") // 插入表达式

// 这里不能用Manager继承Worker来实现, 因为这么做会破坏语义
class Manager(val worker: Worker) {
  fun work() = worker.work()
  fun takeVacation() = worker.work()
}
val pm = Manager(Programmer())
pm.work()

// 语法要求by的左边是一个接口, 右边是接口的实现.
class Manager(val staff: Worker): Worker by staff {
  override fun takeVacation() = staff.work() // 委托类中被定义的方法不会路由到staff
}
val pm = Manager(Programmer())
pm.work()

class Post(dataSource: MutableMap<String, Any>) {
  val title: String by dataSource // 访问title时, 实际上会调用dataSource.getValue("title")或dataSource.setValue("title", value)
  val likes: Int by dataSource // 访问likes时, 实际上会调用dataSource.getValue("likes")或dataSource.setValue("likes", value)
}

val channel = Channel<Int>() // Channel的第一个参数决定了缓冲大小, 默认为无缓冲
launch {
  for (x in 1..5) {
    channel.send(x * x)
  }
}
repeat(5) {
  println(channel.receive())
}