Lazy 和 Lateinit

我们都知道，在kotlin中声明不为空类型变量都需要立即进行初始化，不管是可变的还是不可变的。但是 Activity 和Fragment对象的创建和视图的加载是分开进行的，所以我们不能直接初始化一些控件。那么如何处理这种情况呢？

声明可空类型。但是你会发现，当我们在使用mTextView都需要带上?来访问。
class MainActivity : AppCompatActivity() {

private var mTextView: TextView? = null

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    mTextView = findViewById(R.id.tv_content)
    mTextView?.text="hello world"
}

}

我们使用延迟初始化lateinit来让编译器绕过的警告。这样我们就可以不用马上初始化。
class MainActivity : AppCompatActivity() {

private lateinit var mTextView: TextView

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    mTextView = findViewById(R.id.tv_content)
    mTextView.text = "hello world"
}

}
虽然能够处理上述的问题。但明显不够。我们需要知道lateinit的更多细节，能够在项目中更好的使用它。

lateinit 注意事项
lateinit 只能作用于可变的属性上，也就是说你不能作用在val的属性上。
当你使用lateinit修饰后，之后一定要自行初始化。编译器已经无法推断你是否初始化。
private lateinit var mTextView: TextView

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //虽然你没有初始化，编译器不会存在任何警告
    mTextView.text = "hello world"
}

有没有办法处理上述的问题呢？

Kotlin中还提供了一个lazy来处理延迟操作。具体使用如下

class MainActivity : AppCompatActivity() {

private val mTextView: TextView by lazy {
    print("i am init")
    findViewById<TextView>(R.id.tv_content)
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    mTextView.text = "hello world"
}

}

当你真正需要用到mTextView的时候, lazy 后面的block才会执行。假设你并没有使用到mTextView。它是不会被初始化的。当然上述lateinit存在的注意事项，在lazy被完全忽视了。而且它只会被初始化一次。

到这里，我们已经大概知道了lazy和lateinit的使用，如果你想深究一下里面的原理的话。可以继续阅读下去。

首先是 lateinit,当我们将kotlin代码转化成java代码的时候，你会发现其实lateinit只是绕过编译器的小把戏~

public final class MainActivity extends AppCompatActivity {
private TextView mTextView;
private HashMap _$_findViewCache;

protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(-1300009);
View var10001 = this.findViewById(-1000066);
Intrinsics.checkExpressionValueIsNotNull(var10001, “findViewById(R.id.tv_content)”);
this.mTextView = (TextView)var10001;
TextView var10000 = this.mTextView;
if (var10000 == null) {
Intrinsics.throwUninitializedPropertyAccessException(“mTextView”);
}
var10000.setText((CharSequence)“hello world”);
}
…
}

接下来是lazy,当我们跟进lazy源代码的时候，会发现一个这样的函数

public actual fun lazy(initializer: () -> T): Lazy = SynchronizedLazyImpl(initializer)

它将我们的block根据SynchronizedLazyImpl包装成Lazy类型的参数。 我们继续看SynchronizedLazyImpl实现

private class SynchronizedLazyImpl(initializer: () -> T, lock: Any? = null) : Lazy, Serializable {
private var initializer: (() -> T)? = initializer
@Volatile private var _value: Any? = UNINITIALIZED_VALUE
// final field is required to enable safe publication of constructed instance
private val lock = lock ?: this

override val value: T
    get() {
        val _v1 = _value
        if (_v1 !== UNINITIALIZED_VALUE) {
            @Suppress("UNCHECKED_CAST")
            return _v1 as T
        }

        return synchronized(lock) {
            val _v2 = _value
            if (_v2 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST") (_v2 as T)
            } else {
                val typedValue = initializer!!()
                _value = typedValue
                initializer = null
                typedValue
            }
        }
    }

override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE

override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."

private fun writeReplace(): Any = InitializedLazyImpl(value)

}
SynchronizedLazyImpl 里面的默认状态是UNINITIALIZED_VALUE，当我们调用了对象的属性或则方法的时候,SynchronizedLazyImpl才会调用block里面的逻辑。然后改变_value状态。从而达到懒加载的作用。

补充一下lateinit 只能声明var 类型，lazy 只能声明val 类型
扩展
var 类型 与 val 类型就相当于 java 中定义了final 一样