2019-02-21 Kotlin基础语法

2 minute read

基础语法

定义函数

  fun sum(a: Int, b: Int) {
      return a+b
  }
  // 表达式作为函数体, 返回类型自动推断
  fun sum(a: Int, b: Int) = a + b

定义变量

 // 立刻赋值, 只能赋值一次
 val a: Int = 1;
 // 变量
 var x = 5;

if表达式

fun maxOf(a: Int, b: Int) = if(a > b) a else b

可空值和null检查

// 当变量值可为null, 必须在声明处的类型后添加?标识可为空
fun parseInt(str: String): Int? {

}

遍历map/pair型list

for((k, v) in map) {
  println("$k->$v");
}

延迟属性

val p: String by lazy {

}

扩展函数

fun String.spaceToCamelCase(){...}

if not null缩写

val files = new File("Test").listFiles()
println(files?.size)

返回when表达式

fun transform(color:  String): Int {
  return when(color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
  }
}

try/catch表达式

fun test() {
  val result = try{
    count()
  } catch(e: ArithmeticException) {
    throw IllegalArgumentException(e)
  }
}

单个对象实例调用多个方法 (with)

class Turtle {
  fun penDown()
  fun penUp()
  fun turn(degress: Double)
  fun forward(pixels: Double)
}
val myTurtle = Turtle()
with(myTurtle) {
  penDown()
  for(i in 1..4) {
    forward(100.0)
    turn(90.0)
  }
  penUp
}

属性和字段

// 延迟初始化属性与变量
// 属性为空不希望在构造函数初始化, 可以用lateinit
lateinit var subject: TestSubject

类与继承

// 主构造函数, constructor无可见性修饰符可省
class Person constructor(firstName: String) {
  // 次构造函数
  constructor(firstName: String, lastName: String) {
    ...
  }
}

// kotlin类默认是final, 要继承需要声明为open
open class Base {
  open fun v(){...}
}
class Derived() : Base() {
  override fun v() {...}
}

// 抽象类
open class Base {
  open fun f() {}
}
abstract class Derived : Base {
  override abstract fun f()
}

// 对象声明/单例模式
object DataProviderManager {
  fun registerDataProvider(provider: DataProvider) {}
}
// 对象声明初始化是线程安全的
DataProviderManager.registerDataProvider(..)

数据类

// 生成只保存数据的类
// 自动生成equals()、hashCode()
data class User(val name: String, val age: Int) {}

委托/委托属性

interface Base {}

class BaseImpl(val x: Int) : Base {
  ...
}

// by子语句表示b将会在Derived内部存储, 并且编辑器生成转发b所有Base的方法
class Derived(b: Base) : Base by b {}

fun main() {
  var b = BaseImpl(10)
  Derived(b).print()
}

// 延迟属性, 委托实现
val lazyValue: String by lazy {
  print("computed")
  "Hello"
}
fun main() {
  println(lazyValue)
}

// 可观察属性 Observable
class User {
  // 初始值no name
  var name: String by Delegates.Observable("no name") {
    prop, old, new ->
    println("$old -> $new")
  }
}

fun main() {
  val user = User()
  user.name = "first"
  user.name = "second"
}

// 把属性储存在映射中
class User(val map: Map<String, Any?) {
  val name: String by map
  val age: Int by map
}

val user = User(mapOf(
  "name" to "John"
  "age" to 25
))

println(user.name)
println(user.age)

kotlin调用Java

Getter和Setter

fun calendarDemo() {
val calendar = Calendar.getInstance()
if(calendar.firstDayOfWeek == Calendar.SUNDAY){//调用Java #getFirstDayOfWeek
calendar.firstDayOfWeek = Calendar.MONDAY//调用Java #setFirstDayOfWeek
}
}

返回void的方法, 在kotlin接收为Unit
Java使用kotlin标识符并转义, 部分支持作为方法调用, 如in、object、is, 使用如下foo.is(bar)

Java调用kotlin
- 包级函数

// example.kt, 编译生成为xx.ExampleKt.Java的静态方法
package demo
class Foo
fun bar() {...}

// Java
new demo.Foo();
demo.ExampleKt.bar();

实例字段 ```java class C(id: String) { @JvmField val ID = id }

// Java class JavaClient { public String getID(C c) { return c.ID; } }

  - 静态方法
```java
  class C {
    companion object{
      @JvmStatic fun foo() {}
    }
  }

// Java
  C.foo()

协程

venciallee

2019-02-21 Kotlin基础语法

基础语法

You may also enjoy