Kotlin 语法

1. 说明
  .java 必须是一个 public 的class
  .kt toplevel 可以是 变量，常量，类，多个, 混合
2. 声明变量

  lateinit var str:String //不能null，必须引用类型
  var sstr:String by lazy("by lazy string") //委托懒加载 不可变量
  const val π = 3.14 //不允许改变

3. 函数

 fun div(c: Int, d:Float = 1f){
 }

 fun more(vararg a: Int): Int{
  return a.get(0) + a.get(1)+a.get(2)
 }  

4. 语法
  4.1 for 语句

private fun demo() {
        //打印 0 至 10
        for (i in 0..10) {
            println(i)
        }
        // 打印 0 至 9
        for (i in 0 until 10) {
            println(i)
        }
        // 打印 0 至 10 步长为 2
        for (i in 0..10 step 2) {
            println(i)
        }
        // 打印 10 至 0 步长为 2
        for (i in 10 downTo 0 step 2) {
            println(i)
        }
    }

  4.2 when 语法

    private fun demo1(i: Type) {
        // var i:Type
        when (i) {
            i is String -> {
                println("i")
            }
            i !is Float -> {

            }
            i in 0..10 -> {

            }
            else -> {
            }
        }
    }

5. 类
  5.1 class

//class
class AClass() {
    //属性
    var name: String = ""
    lateinit var b: String //不能null，必须引用类型

    //函数
    fun getSomeInfo(): String {
        this::b.isInitialized //是否初始化 boolean
        return ""
    }
}

  5.2 object

//object
object ObClass {
    //成员函数，属性，单例静态函数
    fun a1() {}
}

  5.3 data class

//data class
data class DaClass(var name: String, var age: Int = 20) {
    var grade: String = ""
}

  5.4 sealed class

//sealed class
//密封类， 类似枚举类型作用 必须在同一个kt文件内去声明
sealed class SlClass()
data class Ac(var a: Int) : SlClass()
object obc: SlClass()

6. 构造函数
  6.1 常用的构造函数

class ClassA(private var b: Int = 9)
class ClassB private constructor(var a: Int) {
    var b = a
    fun test() {
        var c = b
    }
}

class ClassC {
    constructor()
    constructor(b: Int)
    constructor(a: Int, n: String = "")
    init {
    // init some data
    }
}

  6.2高阶函数

var s: String? = null
    //高阶函数
    //also, with, let, apply, run
    private fun demo() {
        //执行 s 的情况下，再做什么事
        s?.also {
        }
        //
        s?.let {
        }
        s?.apply {
        }
        with(s){
        }
        s?.run {
        }
        //java.Observer: 表示包名在多个重复类引用的时候用到，类名相同，包名不同
        //typealias ob = java.Observer
    }