Question

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

我认为即使我从未调用fun <T> preference(context: Context, name: String, default: T)

，我启动应用时方法B也会保留在内存中

我认为方法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

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

它究竟会留在记忆中的是什么？
不，除了在Kotlin中调用时使用方法相同。但事实上，方法B preference位于类ToolKt内，如果您尝试从Java调用它，可以看到它。
为什么要定义preference个函数而不是直接使用Preference构造函数？ Kotlin构造函数没有像Java那样的类型推断问题。

Answer 2

方法A 会在静态类初始化期间分配Summary of ZMQ_STREAM characteristics Compatible peer sockets none Direction Bidirectional Send/receive pattern Unrestricted Outgoing routing strategy See text ( above ) Incoming routing strategy Fair-queued Action in mute state EAGAIN - 只要您在代码中引用object DelegatesExt，因为Kotlin中的DelegatesExt是懒惰的单身人士初始化。

然后，当您拨打object时，它会分配您的DelegatesExt.preference(...)对象。顺便说一下，它会在每次调用时分配一个新实例，这不是一个好主意。

然后，当您拨打Preference<T>或getValue时，setValue将被分配（仅每SharedPreferences个实例一次）。

方法B 不会分配冗余Preference<T>，并且还会在每个方法调用上分配object DelegatesExt。这将被编译为与Java中使用静态方法的类相同的代码。

但在Preference<T>方法调用之前不会分配Preference<T>。（在这两种情况下）。

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

在Kotlin中哪一个更好的对象或顶级功能？

2 个答案: