Kotlin基本语法

javabean

public class Book {
    private long id;
    private String name;
    
    ...
    getter and setter
    ...
    
}

data class Book(
    val id: Long,
    val name: String) {
        // 构造函数的函数体可以写在init
        init {
            ...
        }
    }
}
data class Forecast(val dtae: Date, val temperature: Float, val details: String)

复制

val f1 = Forecast(Date(), 22.5f, "Cool")
val f2 = f1.copy(temperature = 22f)

映射对象到变量

val f1 = Forecast(Date(), 22.5f, "Cool")
val (date, temperature, details) = f1
会被编译为
val date = f1.component1()
val temperature = = f1.component2()
val details = f1.component3()

别名

import com.animal.dog as puppy  

空安全

// 不能通过编译，不能为空
val not NullBook: Book = null
// 可以为空
val not book: Book? = null
// 不能通过编译，book可能为空
book.print()
// book != null 执行
book?.print()
// 如进行空检查，不需要安全调用操作符调用
if (book != null) {
    book.print()
}
// 确保不为空才会调用，否则抛出异常
book!!.print()
// 使用三元运算符来给定一个是Null时的替代值
val name = book?.name ?: "empty"

习惯用法

// If not null 缩写
val files = File("Test").listFiles()
println(files?.size)

// If not null and else 缩写
val files = File("Test").listFiles()
println(files?.size ?: "empty")

// if null 执行一个语句
val data = ……
val email = data["email"] ?: throw IllegalStateException("Email is missing!")

// if not null 执行代码
val data = ……
data?.let {
    …… // 代码会执行到此处, 假如data不为null
}

// 使用可空布尔
val b: Boolean? = ……
if (b == true) {
    ……
} else {
    // `b` 是 false 或者 null
}

Lambdas

view.setOnClickListener { toast("haha") }

继承

所有类默认不可继承（final），使用open或abstract声明的类可被继承

open class Animal(name: String)
class B(name: String,surname: String) : Animal(name)

函数

使用fun关键字进行定义。当没有指定返回值时，返回Unit，类似void，但Unit是一个真正的对象。
当返回结果可用一个表达式计算出来可以使用等号。

fun add(x: Int,y: Int) : Int = x + y

当函数参数指定为默认值，调用的时候可以不传值进入。

基本类型

• 数字/字符类型不会自动转型，必须使用明确的类型转换。

val i: Int = 7
val d: Double = i.toDouble()
val c: Char = 'c'
val ii: Int = c.toInt()

• 位运算，| 使用 or ,& 使用 and

val a = flag1 or flag2
val b = flag1 and flag2

• 字面可以写明具体类型。

// 没有八进制！！！
val i = 12
val iHex = 0x0f
val l = 3L
val d = 3.5
val f  = 3.5F

• String可以像数组一样访问被迭代。

val s = "aaa"
val c = s[2]
for (c in s) {
    pring(c)
}

val & var

var： 可变变量

val： 不可变量。实例化之后不能再去改变状态，如果需要一个对象修改之后的版本，会在再创建一个新的对象。编程更加健壮和可预估，是线程安全的，因为不可变，所有线程访问到的对象都是同一个。尽可能地使用val。

Companion objects

使用companion object，里面是静态属性、常量或者函数，就像java中的静态属性或者方法。

When 表达式

when 取代了switch

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个块
        print("x is neither 1 nor 2")
    }
}

// 多个分支条件放在一起，用逗号分隔：
when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

// 检测一个值在（in）或者不在（!in）一个区间或者集合中：
when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

// 检测一个值是（is）或者不是（!is）一个特定类型的值
fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}

// when 取代 if-else if链。
when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

操作符表

一元操作符
二元操作符 数组操作符 等于操作符

PS: 操作符 === 和 ！== 分别是java中的 == 和 ！= ,并且不能被重载。

函数调用

修饰符

修饰符	描述
public	默认修饰符（当类为private，public成员类也不可见）
private	只能被自己所在文件可见
protected	只能被用在类或接口中的成员上
internal	对整个module可见（当类为private，internal修饰的可见性会限制与它所在的这个类的可见性）

构造器

构造器默认为public，可以修改为private

class C private constructor(a: Int) {...}

单例

class App : Application() {
    companion object {
        var instance: App by DelegatesExt.notNullSingleValue()
    }
    override fun onCreate() {
        super.onCreate()
        instance = this
    }
}

扩展函数

toast("free style")
longToast("free style")

执行一个请求

public class Request(var url: String) {
    public fun run() {
        val str = URL(url).readText()
    }
}

主线程外执行

async() {
    Request(url).run()
    uiThread { longToast("Request performed") }
}

uiThread 可依赖于调用者，如果被一个activity调用，activity.isFinishing()返回TRUE，uiThread不会执行，所以不会在activity销毁时崩溃~
异步调用

async() {
    val res = RequestForecastCommand("1111").execute()
    uiThread {
        forecastList.adapter = ForecastListAdapter(res)
    }
}

内联函数

内联函数：编译时被替换，可以减少内存分配格运行时开销。

（如果一个函数接受一个函数作为它的参数，普通函数内部会创建一个含有那个函数的对象；内联函数会吧我们调用这个函数的地方替换掉，不需要生成一个内部对象。）

• apply：调用某对象的apply，在函数范围内，可以调用该对象的任意方法并返回该对象，返回当前自己的对象。
• let：默认当前对象作为闭包的it参数，返回函数内最后一行，或指定return。
• with：一个单独的函数，返回最后一行，直接调用对象的方法。（let + apply）
• run：类似apply，返回最后一行。

// 对一个对象实例调用多个方法 （with）
// 这个例子才充分体现了with有没有！！！！之前看到的都什么鬼
class Turtle {
        fun penDown()
        fun penUp()
        fun turn(degrees: Double)
        fun forward(pixels: Double)
}
val myTurtle = Turtle()
with(myTurtle) { // 画一个 100 像素的正方形
        penDown()
        for(i in 1..4) {
            forward(100.0)
            turn(90.0)
        }
        penUp()
}

函数名	定义	参数	返回值	extension	其他
let	fun <T, R> T.let(f: (T) -> R): R = f(this)	it	闭包返回	是
apply	fun <T> T.apply(f: T.() -> Unit): T { f(); return this }	无（this）	this	是
with	fun <T, R> with(receiver: T, f: T.() -> R): R = receiver.f()	无（this）	闭包返回	否	调用方式不同
run	fun <T, R> T.run(f: T.() -> R): R = f()	无（this）	闭包返回	是

区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。

for (i in 1..100) { …… }  // 闭区间：包含 100
for (i in 1 until 100) { …… } // 半开区间：不包含 100
for (x in 2..10 step 2) { …… }
for (x in 10 downTo 1) { …… }
if (x in 1..10) { …… }