class A private constructor() {
companion object {
val instance: A by lazy { A() }
}
}
或者
class App : Application() {
companion object {
lateinit var instance: App
private set
}
override fun onCreate() {
super.onCreate()
instance = this
}
}
- Kotlin中的继承
例子：
interface XYHolder {
val x: Int
val y: Int
}
方法1 继承interface：
data class XY(override val x: Int, override val y: Int) : XYHolder
方法2使用代理：
data class B(val a: Int, private val xyh: XYHolder) : XYHolder by xyh
方法3 使用抽象类：
abstract class Resource （var name : String, var age : Int ){
abstract var addr : String
abstract val weight : Float
abstract var id: Long
abstract var location: String
}
data class Book（name : String, age : Int, var no : String, var score : Int, override var addr: String, override val weight: Float） (
override var id: Long = 0,
override var location: String = "",
var isbn: String
) : Resource()
方法4 如果父类构造方法没有入参：
sealed class Either<out L, out R> {
data class Left<out L, out R>(val value: L) : Either<L, R>()
data class Right<out L, out R>(val value: R) : Either<L, R>()
}
- 对象表达式，对象声明和伴随对象的区别
对象表达式在使用的地方被立即执行。 对象声明是延迟加载的， 在第一次使用的时候被初始化。 伴生对象所在的类被加载，伴生对象被初始化，与Java静态成员类似，虽然本质上 伴随对象是真实对象的实例。
伴随对象声明时可以不指定对象名称，对象声明需要指定对象名字。 - 当函数可能被其他模块多次调用，并且代码为10 行以下时，
用inline关键字可以提高代码运行效率。
而内联一个相当大的函数将显著增加编译后的代码行数。现代处理器由于更好的利用了指令缓存, 小巧的代码往往执行更快。
- Kotlin与RxJava Retrofit结合使用时，发现虽然Observable.subscribe方法的onError方法参数的入参error标明是Throwable!，但网络不好的时候，error可能为null。
解决方法是使用error? 而不是error，如下所示：
ServiceGenerator.createService(LiveAPI::class.java)
.getRoomList(category.id,pageNumber)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ result ->
// 处理网络返回的数据
}, { error ->
// 处理出错的情况
error?.printStackTrace() // 使用error?， 因为error可能为null
})
- 协变与逆变
** 协变
List<out T>
val doubleList: List<Double> = listOf(1.0, 2.0)
val numberList: List<Number> = doubleList
out 声名协变的形参T，表示List<Base> 是 List<Derived> 的超类
协变用于生产者的情况，即形参T在此类中的方法中只能作为返回值（作为入参要加UnsafeVariance注解），表示只能被读取。
用现实生活举例：一家生产羊肉的工厂是一家生产肉的工厂
肉商 = 羊肉商 这样的赋值是正确的，肉是形参，厂商是类
** 逆变
Comparable<in T>
interface Comparable<in T> {
operator fun compareTo(other: T): Int
}
fun demo(x: Comparable<Number>) {
x.compareTo(1.0) // 1.0 has type Double, which is a subtype of Number
// Thus, we can assign x to a variable of type Comparable<Double>
val y: Comparable<Double> = x // OK!
}
in 声名逆变的形参T，表示Comparable<Derived> 是Comparable<Base>的超类
逆变用于消费者的情况，即形参T在此类中的方法中只能作为入参（作为返回值要加UnsafeVariance注解），表示只能被输入。
用现实生活举例：一个能吃肉的人是一个能吃羊肉的人
能吃羊肉的人 = 能吃肉的人
这样的赋值是正确的，肉是形参，人是类
总结：
PECS: Producer Extends，Consumer Super
Producer out，Consumer in
如果既是生产者也是消费者，就两个修饰符都不能用了
