Android开发经验谈Kotlin编程kotlin

Lazy 和 Lateinit 的选择

2019-08-02  本文已影响7人  ___刘辉良

前言

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

  1. 声明可空类型。但是你会发现,当我们在使用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"
    }
}

  1. 我们使用延迟初始化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 注意事项

  1. lateinit 只能作用于可变的属性上,也就是说你不能作用在val的属性上。
  2. 当你使用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被完全忽视了。而且它只会被初始化一次。

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

首先是 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 <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

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

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, 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状态。从而达到懒加载的作用。

上一篇 下一篇

猜你喜欢

热点阅读