Kotlin?object的幾種用法示例詳解

更新時間：2022年12月08日 11:03:03 作者：無糖可樂愛好者

這篇文章主要為大家介紹了Kotlin?object的幾種用法示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

1.object：匿名內部類

在Android最常用的匿名內部類之一就是點擊事件，用Java語言寫的話就是下面這樣：

public interface OnClickListener {
    void onClick(View v);
}
button.setOnClickListener(new View.OnClickListener(){
    @Override
    public void onClick(View v){
    }
});

上面的代碼在Kotlin中就要這么寫

interface OnClickListener {
    fun onClick(v: View)
}
button.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View) {
    }
})

上面的代碼中object: View.OnClickListener就是匿名內部類的使用方式。

這里的代碼為了說明【object: 匿名內部類】的用法所以寫的比較啰嗦，如果用Lambda寫法的話可以這么寫

button.setOnClickListener {
}

上面是匿名內部類常用的一種方式，還有另一種用法就是：在繼承一個抽象類的同時還可以實現(xiàn)多個接口，直接看代碼：

interface Behavior {
    fun sleep()
}
interface Characteristics {
    fun gender()
}
abstract class Person {
    abstract fun walk()
}
fun main() {
    // 這個匿名內部類，在繼承了Person類的同時，還實現(xiàn)了Behavior(行為)、Characteristics(特征)兩個接口
    val item = object : Person(), Behavior, Characteristics {
        override fun sleep() {
        }
        override fun gender() {
        }
        override fun walk() {
        }
    }
}

對上面的代碼說明：在繼承了Person類的同時，還實現(xiàn)了Behavior(行為)、Characteristics(特征)兩個接口并分別重寫了他們的方法，這種用法靈活性比較高。

2.object: 伴生對象

Kotlin 當中沒有 static 關鍵字，所以我們沒有辦法直接定義靜態(tài)方法和靜態(tài)變量。不過，Kotlin 還是為我們提供了伴生對象，來幫助實現(xiàn)靜態(tài)方法和變量。

先看一種嵌套類的特殊情況

class Person {
    object InnerSingleton {
        fun foo() {}
    }
}
//反編譯后的Java代碼
public final class Person {
    public static final class InnerSingleton {
        @NotNull
        public static final Person.InnerSingleton INSTANCE;
        public final void foo() {
        }
        private InnerSingleton() {
        }
        static {
            Person.InnerSingleton var0 = new Person.InnerSingleton();
            INSTANCE = var0;
        }
    }
}

由以上代碼可知定義的foo方法并不是一個靜態(tài)方法，那要如何實現(xiàn)這個靜態(tài)方法呢，可以foo方法上面加入注解@JvmStatic，這樣反編譯后foo方法就是一個靜態(tài)方法了

class Person {
    object InnerSingleton {
        @JvmStatic
        fun foo() {}
    }
}
//反編譯后的Java代碼
public final class Person {
    public static final class InnerSingleton {
        @NotNull
        public static final Person.InnerSingleton INSTANCE;
        @JvmStatic
        public static final void foo() {
        }
        private InnerSingleton() {
        }
        static {
            Person.InnerSingleton var0 = new Person.InnerSingleton();
            INSTANCE = var0;
        }
    }
}

經(jīng)過這么改動Kotlin和Java的實現(xiàn)方式就都可以這么寫

Person.InnerSingleton.foo()

此時還有一個問題，foo方法的InnerSingleton有點多余，它并沒有實際意義，想直接調用Person.foo()要怎么做？

在object前面加入一個companion關鍵字即可

//Kotlin代碼
class Person {
    companion object InnerSingleton {
        @JvmStatic
        fun foo() {
        }
    }
}
//反編譯后的代碼
public final class Person {
    @NotNull
    public static final Person.InnerSingleton InnerSingleton = new Person.InnerSingleton((DefaultConstructorMarker)null);
    @JvmStatic
    public static final void foo() {
        InnerSingleton.foo();
    }
    public static final class InnerSingleton {
        @JvmStatic
        public final void foo() {
        }
        private InnerSingleton() {
        }
        // $FF: synthetic method
        public InnerSingleton(DefaultConstructorMarker $constructor_marker) {
            this();
        }
    }
}

加入companion就實現(xiàn)了Person.foo()的調用。companion object就是Kotlin中的伴生對象， 它其實是嵌套單例的一種也是情況。

通過上面的代碼可以得出一個結論：當伴生對象存在時如果還存在

@JvmStatic修飾的方法或者屬性，那么Kotlin編譯成Java代碼后它就會被挪到外部的類中變成靜態(tài)成員。嵌套單例是

object單例的一種特殊情況，伴身對象是嵌套單例的一種特殊情況。

3.單例模式

Kotlin中定義一個普通的單例模式非常簡單只需要在類名前面用object聲明即可

object Utils{
}

這樣就能實現(xiàn)單例，但是Java中的單例是比較復雜的，并且還有懶漢式和餓漢式之分，這樣真的就能定義嗎？

我們看一下這段代碼反編譯成Java的代碼看一看就很清楚了：

public final class Utils {
    @NotNull
    public static final Utils INSTANCE;
    private Utils() {
    }
    static {
        Utils var0 = new Utils();
        INSTANCE = var0;
    }
}

static中的代碼由虛擬機決定只會運行一次，同時在保證線程安全的前提下也保證了INSTANCE只運行一次。

但是這里有2個缺陷：

不支持懶加載
不能傳遞參數(shù)，在Android中會經(jīng)常用到context的情況，不能傳參這個用法就沒有意義

那要如何解決？

單例模式——借助懶加載委托

class Person(val name: String) {
}
fun main() {
    val user by lazy { Person("張三") }
    println("user is name ${user.name}")
}

上面的代碼使用了by lazy{ }創(chuàng)建了Person對象，而Person對象最終創(chuàng)建的時機是在println創(chuàng)建的，也就是說懶加載委托的特點就是只有在使用這個對象是才會創(chuàng)建實例。

單例模式—— 伴生對象 Double Check

直接看代碼，代碼是從《朱凱·Kotlin編程第一課》直接拷貝過來的

class UserManager private constructor(name: String) {
    companion object {
        @Volatile
        private var INSTANCE: UserManager? = null
        fun getInstance(name: String): UserManager =
        // 第一次判空
        INSTANCE ?: synchronized(this) {
            // 第二次判空
            INSTANCE ?: UserManager(name).also { INSTANCE = it }
        }
    }
}
fun main() {
    // 使用
    UserManager.getInstance("Tom")
}

這里首先定義了一個INSTANCE并且用private修飾這樣就可以保證不能被外界直接訪問，同時添加了@Volatile注解可以保證INSTANCE的可見性，而 getInstance() 方法當中的 synchronized，保證了 INSTANCE 的原子性。因此，這種方案還是線程安全的。

另外還要注意的一點是初始化定義的INSTANCE的默認值時null你這也就保證了只有在使用它的時候才會被實例化，也就是說實現(xiàn)懶加載的模式。

這中實現(xiàn)方式也是可以傳參的，在getInstance()方法中定義需要的屬性即可實現(xiàn)傳參

這個代碼其實跟Java的懶漢模式 + synchronized 同步鎖非常相似

public class UserManager {
    private static volatile UserManager mInstance = null;
    private UserManager() {
    }
    public static UserManager getInstance() {
        if (mInstance == null) {
            synchronized (UserManager.class) {
                if (mInstance == null) {
                    mInstance = new UserManager();
                }
            }
        }
        return mInstance;
    }
}

上面介紹了3中單例模式的實現(xiàn)方式，他們的使用場景如下：

如果單例占用內存很小并且堆內存不敏感也不需要傳參，直接使用object即可，例如常用且無需傳參的的Utils類；
如果單例占用內存很小并且不需要傳參，但是它的內部屬性會觸發(fā)消耗資源的網(wǎng)絡請求和數(shù)據(jù)庫查詢，這是就需要用object搭配by lazy{ }；
如果工程比較簡單，只有少數(shù)的單例場景、懶加載需求、需要傳遞參數(shù)就需要使用Double Check的方式了，例如PreferenceUtils。