kotlin学习笔记

---

如果不为空则...的简写

val files = File("Test").listFiles()
//对files加了不为空的判断(?)
println(files?.size())

如果不为空则...否则...的简写

val files = File("Test").listFiles()
//对files加了不为空的判断（？），同时加了为空的判断（？：）
println(files?.size?:"empty")//如果files为空则打印empty

如果为空，则执行语句，使用？：符号，为空时执行语句

val data = ...
val email = data["emaile"] ? : throw IllegalStateException("Email is missing!")
val name = data["name"] ?:let{
...
}

如果不为空，则执行语句，使用？符号，加非空判断，.let{}是不为空的时候执行

val data = ...
data?.let{
...
}

data?.let{
 // todo
}?:defaultValueIfValueIsNull

返回when判断

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

如果一个函数只有一个并且是表达式函数体并且是返回类型自动推断的话，可以直接等于返回值

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

try/catch(表达式)
Kotlin的try/catch 表达式同java类似，Kotlin可以直接赋值

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

使用with调用一个对象实例的多个方法

class Turtle{
    fun penDown()
    fun penUp()
    fun turn(degress:Double)
    fun forward(pixels:Double)
}
val myTurtle = Turtle()
//如果正常写
myTurtle.penDown()
for(I in 1..4){
    myTurtle.forward(100.0)
    myTurtle.turn(90.0)
}
mTurtle.penUp()

//使用with将对象实例引用，代码减少很多
with(myTurtle){
   penDown()
   for(I in 1..4){
      forward(100.0)
      turn(90.0)   
}
   penUp()
}

同样，在Adapter里面可以直接使用with来替换holder.itemView

with(holder.itemView){
    new_item_text.text = mDatas?.get(position)?.desc
    new_item_user.text = mDatas?.get(position)?.who.let { "" }
}

---

继承

open class Base(p: Int)
class Derived(p: Int) : Base(p)

注意：一个类如果要被别的类继承，要加上open关键字，在类名的最前面，默认情况下，Kotlin中的所有类都是final的，Kotlin的接口以及成员默认都是open。
同样，如果父类有主构造函数，则子类必须在主构造函数中初始化

/**
* 父类
*/
open class BaseKot(name:String){}
/**
* 子类
*/
class Kot(name:String):BaseKot(name){}

如果子类没有主构造函数，则可以在二级构造函数中使用super关键字初始化或者在代理另一个构造函数

/**
* 父类
*/
open class BaseKot(name: String) {
   open var age:Int get() = 0//get()=0 与 = 0 相同
   open fun v(){}
}
/**
* 子类
*/
class Kot:BaseKot{
   constructor(name:String):super(name){}
}

可以在子类的主构造函数中声明override

class Kot(override var age : Int):BaseKot(){
    override fun v(){
        super.v()   
   }
}

使用super实现
子类中的代码可以使用super关键字调用其父类的函数与属性访问器的实现

open class Foo {
   open fun f() { println("Foo.f()") }
   open val x: Int get() = 1
}

class Bar : Foo() {
   override fun f() { 
       super.f()
       println("Bar.f()") 
   }
   
   override val x: Int get() = super.x + 1
}

在一个内部类中访问外部类的父类，可以通过由外部类名限定的super关键字来实现：super@Outer:

class Bar : Foo() {
    override fun f() { /* …… */ }
    override val x: Int get() = 0
    
    inner class Baz {
        fun g() {
            super@Bar.f() // 调用 Foo 实现的 f()
            println(super@Bar.x) // 使用 Foo 实现的 x 的 getter
        }
    }
}

---

重写的规则

在Kotlin中，实现继承通常遵循如下规则：如果一个类从它的直接父类继承了同一个成员的多个实现，那么它必须复写这个成员并且提供自己的实现，要使用父类中提供的方法，用super<Base>来表示

open class A {
    open fun f() { print("A") }
    fun a() { print("a") } // 不会被重写
}

interface B {
    fun f() { print("B") } // 接口成员默认是open的 
    fun b() { print("b") }
}

class C() : A(), B {
    // The compiler requires f() to be overridden:
    override fun f() {
        super<A>.f() // call to A.f()
        super<B>.f() // call to B.f()
    }
}