Android开发学习之路--Kotlin之类及对象

前言

1 类和继承

1.1 类

class MyClass {
}

1.2 构造函数

一个主构造函数以及多个二级构造函数

class Person constructor(firstName: String) {
}
//也可以省略constructor，写成：
class Person(firstName: String) {
}

在@Inject的时候不能省略constructor

class Person @Inject constructor(firstName: String) {
}

初始化代码可以放在以init做前缀的初始化块内

class Person(firstName: String) {
    init {
        Log.d("Person", Person initialized with name ${name}")
    }
}

声明属性并在主构造函数中初始化:

class Person(val firstName: String, val lastName: String, var age: Int) {
}

1.3 继承

所有的类都有共同的父类 Any. 声明一个明确的父类，需要在类头后加冒号再加父类：

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

kotlin中所有的类都是final, 允许别的类继承这个类需使用open或者abstract关键字

1.4 抽象类

抽象类或函数默认是带着的open注解的

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

1.5 伴随对象

类似java的静态方法调用

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

1.6 内部类

类可以标记为 inner 这样就可以访问外部类的成员.内部类拥有外部类的一个对象
引用

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() = bar
    }
}
val demo = Outer().Inner().foo() //==1

1.7 匿名内部类

tv_hello.setOnClickListener(object: View.OnClickListener{
    override fun onClick(v: View?) {

    }
})
//或者lambda表达式
tv_hello.setOnClickListener{}

1.8 嵌套类

类可以嵌套在其他类中

class Outer {
    private val bar: Int = 1
    class Nested {
        fun foo() = 2
    }
}

1.9 延迟初始化属性

属性加上 lateinit 修饰符

laterinit var name: String

1.10 模块

internal 修饰符是指成员的可见性是只在同一个模块中才可见的

2 扩展(extension)

2.1 函数扩展

fun MutableList<Int>.swap(x: Int, y: Int) {
    val temp = this[x] // this 对应 list
    this[x] = this[y]
    this[y] = tmp
}

常见的扩展比如toast,可以扩展Context类

fun Context.toast(message: String, length: Int = Toast.LENGTH_SHORT) {
    Toast.makeText(this, message, length)
}

2.2 属性扩展

扩展属性，获取list中的最后一个index

val <T> List<T>.lastIndex: Int
    get() = size-1

3 数据类

我们经常创建一个只保存数据的类, 用 data 标注

data class User(val name: String, val age: Int)

如果数据类有无参构造函数，需将主构造函数中，将成员属性初始化。

data class User(val name: String = "", val age: Int = 0)

4 泛型

4.1 泛型类

和Java类似，这里的T就是泛型的对象，声明一个泛型类

class Box<T>(t: T){
    var value = t
}

创建实例

val box: Box<Int> = Box<Int>(1)

4.2 泛型函数

声明一个泛型函数，T表示类型，这里处理了Int,String和其他

fun <T> print(content: T) {
     when (content) {
         is Int -> println(content)
         is String -> printlin(content)
         else -> println("unkown type")
     }
}