android - Kotlin 中的对象和顶级函数哪个更好？

Question

我在Tool.kt中放了一些实用工具，方法A和方法B都可以正常工作。

我认为方法 B 会在我启动应用程序时保留在内存中，即使我从未调用过 fun <T> preference(context: Context, name: String, default: T) 也是如此。

我认为方法 A 仅在调用 DelegatesExt.preference(this,"ZipCode",100L) 时分配内存

所以我认为方法 A 比方法 B 好，对吧？

方法A

object DelegatesExt {
   fun <T> preference(context: Context, name: String,   default: T) = Preference(context, name, default)
}


class Preference<T>(private val context: Context, private val name: String,
        private val default: T) {

    private val prefs: SharedPreferences by lazy {
        context.getSharedPreferences("default", Context.MODE_PRIVATE)
    }

    operator fun getValue(thisRef: Any?, property: KProperty<*>): T = findPreference(name, default)

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        putPreference(name, value)
    }

    @Suppress("UNCHECKED_CAST")
    private fun findPreference(name: String, default: T): T = with(prefs) {
        val res: Any = when (default) {
            is Long -> getLong(name, default)
            is String -> getString(name, default)
            is Int -> getInt(name, default)
            is Boolean -> getBoolean(name, default)
            is Float -> getFloat(name, default)
            else -> throw IllegalArgumentException("This type can be saved into Preferences")
        }

        res as T
    }

    @SuppressLint("CommitPrefEdits")
    private fun putPreference(name: String, value: T) = with(prefs.edit()) {
        when (value) {
            is Long -> putLong(name, value)
            is String -> putString(name, value)
            is Int -> putInt(name, value)
            is Boolean -> putBoolean(name, value)
            is Float -> putFloat(name, value)
            else -> throw IllegalArgumentException("This type can't be saved into Preferences")
        }.apply()
    }
}

方法B

fun <T> preference(context: Context, name: String,   default: T) = Preference(context, name, default)



class Preference<T>(private val context: Context, private val name: String,
        private val default: T) {

    private val prefs: SharedPreferences by lazy {
        context.getSharedPreferences("default", Context.MODE_PRIVATE)
    }

    operator fun getValue(thisRef: Any?, property: KProperty<*>): T = findPreference(name, default)

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        putPreference(name, value)
    }

    @Suppress("UNCHECKED_CAST")
    private fun findPreference(name: String, default: T): T = with(prefs) {
        val res: Any = when (default) {
            is Long -> getLong(name, default)
            is String -> getString(name, default)
            is Int -> getInt(name, default)
            is Boolean -> getBoolean(name, default)
            is Float -> getFloat(name, default)
            else -> throw IllegalArgumentException("This type can be saved into Preferences")
        }

        res as T
    }

    @SuppressLint("CommitPrefEdits")
    private fun putPreference(name: String, value: T) = with(prefs.edit()) {
        when (value) {
            is Long -> putLong(name, value)
            is String -> putString(name, value)
            is Int -> putInt(name, value)
            is Boolean -> putBoolean(name, value)
            is Float -> putFloat(name, value)
            else -> throw IllegalArgumentException("This type can't be saved into Preferences")
        }.apply()
    }
}

Answer 1

方法 A 将分配 object DelegatesExt在静态类初始化期间 - 一旦您引用 DelegatesExt在你的代码中，因为 object在 Kotlin 中是具有惰性初始化的单例。

然后，当您调用 DelegatesExt.preference(...) , 它会分配你的 Preference<T>目的。顺便说一句，它会在每次调用时分配一个新实例，这不是一个好主意。

然后，当您调用 getValue 时或 setValue , SharedPreferences将被分配(每个 Preference<T> 实例仅分配一次)。

方法 B 不分配冗余 object DelegatesExt , 和 Preference<T>也将在每个方法调用上分配。这将被编译为与 Java 中具有静态方法的类有效相同的代码。

但是Preference<T>不会在 preference 之前分配方法调用(在这两种情况下)。

长话短说，两个选项几乎相同，除了 object DelegatesExt。是否被分配。但是值得停止分配新的 Preference<T>在每个 preference方法调用。