对象引用对于非静态的字段 方法或属性_Kotlin Vocabulary | 唯一的 "对象"...

在 Java 语言中，static 关键字主要用于表明方法和属性是属于某个对象，而不是属于对象的实例。static 关键字也用于创建 Singleton (单例)，单例模式是非常常见的设计模式，它可以帮您创建某个对象的唯一实例，并且其它对象也可以访问和分享该实例。Kotlin 可以更加优雅地实现这种设计模式。您只需使用一个关键字: object，就可以实现单例。接下来的内容会告诉大家在 Java 和 Kotlin 中实现单例的区别，以及在 Kotlin 中如何在不使用 static 关键字的情况下实现单例，(其实就是通过 object 关键字实现的)，然后为大家详解使用 object 时底层的实现机制。 首先，我们先聊聊这个应用场景的背景 —— 为什么我们需要一个单例呢？

什么是单例？

单例是一种设计模式，它保证一个类只有唯一一个实例，并且提供全局可访问该对象的接口。单例非常适合那些需要在应用的不同地方共享的对象，以及初始化实例非常消耗资源的场景下使用。

Java 中的单例

要保证一个类只有一个实例，您需要控制对象的创建方式。要使类有且仅有一个实例，需要将构造方法定义为私有的 (private)，并且创建一个公共可访问的静态对象引用。与此同时，您一般不会在启动的时候创建单例，因为使用单例的对象在创建的时候非常耗费资源。要实现这个目的，需要提供一个静态方法，方法里会检查是否已经创建该对象。这个静态方法必须返回之前创建的实例，或者调用构造函数然后返回实例。

public class Singleton{    private static Singleton INSTANCE;    private Singleton(){}    public static Singleton getInstance(){        if (INSTANCE == null){            INSTANCE = new Singleton();        }        return INSTANCE;    }    private int count = 0;    public int count(){ return count++; }}

上面的代码看上去没什么，但是其实里面有个大问题: 这段代码无法保证线程安全。某一时刻当一个线程刚刚运行完 if 语句的时候有可能被挂起，而与此同时另外一个线程调用该方法并且创建单例。而之前被挂起的线程会继续运行，并创建另外一个实例。

public class Singleton{    private static Singleton INSTANCE = new Singleton();    private Singleton(){}    public static Singleton getInstance(){        if (INSTANCE == null) {                // 一次检查            synchronized (Singleton.class) {                if (INSTANCE == null) {        // 二次检查                    INSTANCE = new Singleton();                }            }        }        return INSTANCE;    }    private int count = 0;    public int count(){ return count++; }}

要解决线程同步的问题，您可以使用二次检查锁定。在二次检查锁定中，如果实例为空，则会通过 synchronized 关键字创建同步锁并，且对实例进行二次检查保证当前实例仍为空。如果此时实例仍为空，那么会创建单例。然而这还不够，单例对象还需要使用 volatile 关键字。volatile 关键字告诉编译器该变量可能会被并发运行的线程异步修改。上述内容就会导致大量的模板代码，每次当您创建单例时就需要重复它们。对于这么一个简单的任务却使用了如此繁杂的代码，所以 Java 中创建单例时通常会使用枚举。

Kotlin 中的单例

那么我们再来看看 Kotlin。Kotlin 中并没有静态方法或者静态字段，那么我们如何在 Kotlin 中创建单例呢？

实际上，可以通过 Android Studio/IntelliJ 来帮助我们理解这一问题。当您将 Java 的单例代码转换为 Kotlin 代码时，所有的静态属性和方法就会被移动到 companion object 中。

class Singleton private constructor() {    private var count = 0    fun count(): Int {        return count++    }    companion object {        private var INSTANCE: Singleton? =            Singleton()//二次检查        // Single Checked        val instance: Singleton?            get() {                if (INSTANCE == null) { //首次检查                    synchronized(Singleton::class.java) {                        if (INSTANCE == null) { //二次检查                            INSTANCE =                                Singleton()                        }                    }                }                return INSTANCE            }    }}

经过转换的代码已经够实现我们想要的效果，但其实可以让代码更简洁。可以从 object 代码中去掉构造函数和 companion 关键字。文章后面会告诉大家 object 和 companion objects 之间的区别。

object Singleton {    private var count: Int = 0    fun count() {        count++    }}

当您想使用 count() 方法的时候，您可以通过 Singleton 对象调用该方法。在 Kotlin 中，object 是一种特殊的类，它只有一个实例。如果您创建类的时候使用的是 object 关键字而不是 class，Kotlin 编译器会将构造方法设置为私有的，并且为 object 类创建一个静态引用，同时在一个静态代码块里初始化该引用。当静态字段第一次被访问的时候会调用静态代码块一次。即使没有 synchronized 关键字，JVM 处理静态代码块和处理同步代码块的方式相类似。当 Singleton 类进行初始化的时候，JVM 会从同步代码块中获得一个锁，如此一来，其它线程就无法访问它。当同步锁被释放的时候，就已经创建了 Singleton 实例，并且该静态代码块也不会再被运行。这样就保证了有且仅有一个 Singleton 实例，这就满足了单例的要求。这样一来，object 即保证了线程安全，也实现了首次访问的延迟创建。我们来看一下反编译的 Kotlin 字节码，深入了解一下底层是如何实现的。

如果想查看一个 Kotlin 类的字节码，依次选择 Tools > Kotlin > Show Kotlin Bytecode。Kotlin 字节码显示以后，点击 Decompile 来查看反编译的 Java 代码。

public final class Singleton {   private static int count;   public static final Singleton INSTANCE;   public final int getCount() {return count;}   public final void setCount(int var1) {count = var1;}   public final int count() {      int var1 = count++;      return var1;   }   private Singleton() {}   static {      Singleton var0 = new Singleton();      INSTANCE = var0;   }}

然而 object 也有一定的限制。object 声明里不能包含构造函数，也就是说无法传参给它。即使它支持传参，由于静态代码块无法访问构造方法中的非静态参数，所以传入的参数也无法使用。

⚠️ 和其它静态方法一样，静态的初始化代码块只能访问一个类的静态属性。静态的代码块的调用要早于构造方法，所以静态代码块无法访问对象的属性或者传递给构造函数的参数。

companion object

companion object 和 object 相类似。companion object 常常在类中声明，并且它们的属性可以通过宿主类名进行访问。companion object 不需要定义名称。如果定义了 companion object 的名称，也可以通过名称来访问它的类成员。

class SomeClass {    //…    companion object {        private var count: Int = 0        fun count() {            count++        }    }}class AnotherClass {    //…    companion object Counter {        private var count: Int = 0        fun count() {            count++        }    }}//不定义名称的场景SomeClass.count()//定义名称的场景AnotherClass.Counter.count()

举个例子，这里我们有两个相似的类定义，分别是带名称和不带名称的 companion object。可以通过 SomeClass 来调用 count() 方法，就像 SomeClass 的静态成员一样；或者也可以通过使用 Counter 来调用 count() 方法，就像 AnotherClass 的静态成员一样。反编译 companion object 会得到一个带有私有构造函数的内联类。宿主类会通过一个合成构造方法来初始化一个内部类，这个内部类只有宿主类才能够访问。宿主类会保持一个 companion object 的公共引用，可用于其它类访问。

public final class AnotherClass {    private static int count;    public static final AnotherClass.Counter Counter = new AnotherClass.Counter((DefaultConstructorMarker)null);    public static final class Counter {        public final void count() {            AnotherClass.count = AnotherClass.count + 1;        }        private Counter() { }        // $FF: synthetic method        public Counter(DefaultConstructorMarker $constructor_marker) {            this();        }    }        public static final class Companion {        public final void count() {            AnotherClass.count = AnotherClass.count + 1;        }        private Companion() {}    }}

Object 表达式

到目前为止，我们已经在声明对象的时候使用了 object 关键字，不过它也可以用于 object 表达式。当作为表达式使用时，object 关键字可以帮助您创建匿名对象和匿名内部类。

比如您需要一个临时对象来保持一些数据值时，可以立即声明对象并使用所需的数值进行初始化，之后再访问它们。

val tempValues = object : {    var value = 2    var anotherValue = 3    var someOtherValue = 4}tempValues.value += tempValues.anotherValue

在所生成的代码中，这个操作会被转换为一个匿名的 Java 类，并且该对象会被标记为 来保存匿名对象及其 getter 和 setter。

 tempValues = new Object() {    private int value = 2;    private int anotherValue = 3;    private int someOtherValue = 4;    // x,y,z 的 getter 和 setter    //...};

object 关键字无需使用模板代码就可以创建匿名类。您可以使用 object 表达式，而 Kotlin 编译器则会生成包裹类的声明来创建一个匿名类。

//Kotlin 代码val t1 = Thread(object : Runnable {        override fun run() {         // 逻辑代码    }})t1.start()//反编译的 Java 代码Thread t1 = new Thread((Runnable)(new Runnable() {     public void run() {          }}));t1.start();

object 关键字会帮助您使用更少的代码创建线程安全的单例、匿名对象和匿名类。通过 object 和 companion object， Kotlin 会生成全部所需的代码来实现类似 static 关键字的功能。此外，您还可以避免模板代码的困扰，仅通过使用 object 表达式来创建匿名对象和匿名类。

---

推荐阅读

 点击屏末 | 阅读原文 | 了解更多关于用 Kotlin 进行 Android 开发的相关资料

---