Kotlin语法杂记

var val
var是可变的，跟java中定义变量一样；
val是不可变的，类似java中的final关键字，默认实现了get方法；

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter

Elvis 操作符 ?:

var temp1 = str1?.length?:-1;

?:相当于if...else，上面的解释就是：当str1不为空的时候返回str1.length，否则返回-1

非空

//类型后面加?表示可为空
var str1:String? = "12";
str1 = null // ok
//类型定义了非空，使用的时候需要结合以下规则使用,例如：
str1!!.length
str1?.length
if(str1!=null) str1.length

函数方法
以下方法等价：

fun sum(a:Int,b:Int):Int{
    test = a+b
    return test
}

fun sum1(a:Int,b:Int) = a+b;

标签
可以使用@标签限制循环，如下面定义的loop@标签：

loop@ for (b in 1..9){
        print("b:"+b+"\n")
        for (c in 1..9){
            if (c==4) break@loop
            print("c:"+c+"\n")
        }
    }
    print("end")

当c==4时，将从外层循环终止进入 print("end")

当要返一个回值的时候，解析器优先选用标签限制的 return，即

return@temp 1

表示从@temp处返回1

类相关

val site = Test() //实例一个类， Kotlin 中没有 new 关键字
site.name           // 使用 . 号来引用属性

1:修改 getter 方法， setter 方法

class Person {

    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set

    var no: Int = 100
        get() = field                // 后端变量,备用字段使用field关键字声明,field 关键词只能用于属性的访问器
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        } 
}

构造与次级构造
主构造函数不能包含任何的代码，初始代码可以放在初始块中，初始化代码块以init关键字开头。
次构造函数必须都要，或直接或间接通过另一个次构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字：

class Runoob  constructor(name: String) {  // 类名为 Runoob 

    init {
        println("初始化网站名: ${name}")
    }

    // 次构造函数
    constructor (name: String, alexa: Int) : this(name) {
        println("Alexa 排名 $alexa")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

无需对抽象类或抽象成员标注open注解

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

嵌套类的使用：

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

fun main(args: Array<String>) {
    val demo = Outer.Nested().foo() // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}