Kotlin - 单例、伴生对象、对象表达式 object

一、概念

object 更适合用于无状态的工具类、常量集合，或者作为依赖注入框架内部的模块定义。

1.1 object 关键字的几种用法

1.2 几种类似“Java静态方法”的方式 

Kotlin 极度弱化了静态方法这个概念，提供了比静态方法更好用的语法特性，同样是通过【类名.函数名】来调用。

1.3 乱用的隐患

单体提供了全局访问入口，无需注入哪里都能调用，非常方便但也带来了一些风险影响。更适合用于无状态的工具类、常量集合，或者作为依赖注入框架内部的模块定义。替代方案是使用接口和依赖注入。

• 隐藏的依赖：任何一个类都可能在内部悄悄依赖 XXXManager，你无法从它的构造函数或公开 API 中看出这一点。
• 全局状态：一个全局可变的状态，任何地方的任何代码都可能修改它，导致行为不可预测，尤其是在多线程环境中。
• 测试噩梦：你无法在单元测试中轻易地替换或 mock UserManager 的行为。例如，你如何测试“token 失效”的场景？

// 通过接口和依赖注入
interface SessionProvider {
    fun getToken(): String?
    fun saveToken(token: String)
}

class InMemorySessionProvider : SessionProvider {
    private var userToken: String? = null
    // ... 实现方法
}

@Singleton // 在依赖注入框架中声明其生命周期
class InMemorySessionProvider @Inject constructor() : SessionProvider { ... }

// 在 ViewModel 或其他类中注入
class MyViewModel @Inject constructor(
    private val sessionProvider: SessionProvider
) : ViewModel() {
    fun doSomething() {
        val token = sessionProvider.getToken()
        // ...
    }
}

二、单例（对象声明）

定义一个类并创建它的实例。可以继承类实现接口、包含属性和方法，但是不能手动声明构造。由于不能使用构造函数，可以使用 init()。需要构造传参见下方伴生对象。

 可以声明在顶层、也可以声明在类中（见下方和伴生对象对比）

object Demo{
    val name = "单例"
    fun show() = println(name)
}

Demo.show()
println(Demo.name)

反编译成Java代码：（饿汉）

public final class Demo {
    //成员变量
    private static String name;
    //通过静态字段提供实例
    public static final Demo INSTANCE;
    //私有化构造
    private Demo() { }
    //静态代码块中初始化
    static {
        Demo var0 = new Demo();
        INSTANCE = var0;
        name = "单例";
    }
    //成员方法
    public final void show() {
        String var1 = name;
        System.out.println(var1);
    }
    //生成的getter、setter
    public final String getName() { return name; }
    public final void setName(@NotNull String var1) {
        Intrinsics.checkNotNullParameter(var1, "<set-?>");
        name = var1;
    }
}

 模仿Java方式写Kotlin带参数单例：

class Demo private constructor(
    private var id: Long,
    private var name: String
) {
    companion object {
        private var instance: Demo? = null
        fun getInstance(id: Long, name: String) {
            instance ?: synchronized(this) {
                instance ?: Demo(id, name).also { instance = it }
            }
        }
    }
}

三、伴生对象（静态调用）

• 伴随着类而存在的对象，在类加载的时候被实例化，多个实例会共享。Kotlin 中没有 static 静态的概念，可以使用顶层函数和常量。顶层函数不能访问类中私有的成员，在伴生对象中需要用外部实例来访问（静态内部类无法直接访问外部类中的非静态成员），例如Outter().num。
• 伴生对象的名称可以省略（默认为Companion），不管伴生对象的名称是否手动声明，都可以直接用外部类名调用伴生对象中的属性和方法。
• 当类中成员和伴生对象中成员重名的时候，类名调用的是伴生对象中的，实例调用的是类中的。

class Outer {
    companion object Inner {    //Inner名称可以省略
        var str: String = ""
        fun show(){}
    }
}

fun main() {
    Outer.str = ""
    Outer.show()
    Outer.Inner.str = "" //编译器会提示 Inner 是多余的
    Outer.Inner.show() //编译器会提示 Inner 是多余的
    val obj: Outer.Inner = Outer.Inner
    obj.str = ""
    obj.show()
}

3.1 伴生对象 & 类中单例

Kotlin代码：

class Demo {
    //伴生对象
    companion object One {    //不取名的话，默认名称是 Companion
        var a = 1    //可以自定义getter、setter
        val b = 2
        fun one() = println("伴生对象")
    }
    //单例
    object Two {
        var c = 3    //可以自定义getter、setter
        val d = 4
        fun two() = println("单例")
    }
}

 反编译成Java代码：

public final class Demo {
    //伴生对象中的成员变量（外部类持有）
    private static int a = 1;
    private static final int b = 2;
    //持有伴生对象实例（外部类持有）
    public static final Demo.One One = new Demo.One((DefaultConstructorMarker)null);
    
    //伴生对象
    public static final class One {
        //私有化构造
        private One() { }
        // $FF: synthetic method    合成的方法
        public AA(DefaultConstructorMarker $constructor_marker) {
            this();
        }
        //成员方法
        public final void one() {
            String var1 = "伴生对象";
            System.out.println(var1);
        }
        //生成的getter、setter
        public final int getA() { return Demo.a; }
        public final void setA(int var1) { Demo.a = var1; }
        public final int getB() { return Demo.b; }
    }
    
    //单例
    public static final class Two {
        //通过静态字段提供实例
        public static final Demo.Two INSTANCE;
        //私有化构造
        private Two() { }
        //静态代码块中初始化
        static {
            Demo.Two var0 = new Demo.Two();
            INSTANCE = var0;
            c = 3;
            d = 4;
        }
        //成员变量
        private static int c;
        private static final int d;
        //成员方法
        public final void two() {
            String var1 = "单例";
            System.out.println(var1);
        }
        //生成的getter、setter
        public final int getC() { return c; }
        public final void setC(int var1) { c = var1; }
        public final int getD() { return d; }
    }

}

在伴生对象中的定义的 val/var 反编译后的权限修饰符是private，因此会生成一个静态对象和 getter/setter，成本远超一个静态参数的价值，可以做如下优化：

• 静态常量：由于 val 反编译是 private static final，因此会生成 getter。使用 consta val 反编译是 public static final，就不会生成 getter 了。
• 静态变量：由于 var 反编译是 private static，因此会生成 getter&setter。使用 @JvmFeild 反编译是 public static，就不会生成 getter&setter。

3.2 静态工厂

interface Car {
    val brand: String
    companion object {
        operator fun invoke(type: CarType): Car {
            return when (type) {
                CarType.AUDI -> Audi()    
                CarType.BMW -> BMW()
            }
        }
    }
}

Car(CarType.BMW)

3.3 扩展方法

虽然是在伴生对象上扩展，实际相当于给外部类增加了静态方法。

fun Outter.Companion.show(){}
Outter.show()

3.4 Java互调

反编译成 Java 代码发现伴生对象是外部类持有的一个静态实例，属性和方法全都需要通过Outter().Inner.XXX来调用，想要通过 类名.XXX 调用，可以使用注解 @JvmStatic 修饰函数、@JvmField 修饰属性，就在外部类中增加了对应的 public static 字段和方法。

//Kotlin
class Demo {
    companion object Three {
        @JvmField
        var a = 1
        @JvmField
        val b = 2
        @JvmStatic
        fun three() = println("单例")
    }
//Java
class Demo {
    public static int a = 1;
    public static final int b = 2;
    public static final void three() { Three.three(); }
}

3.5 需要传参的单例

object 修饰类不能有构造，因此用 private 修饰普通类的构造，在伴生对象中创建实例并提供获取方法。以下是双重校验锁，比懒汉效率高。

class Demo private constructor(
    val name: String
) {
    companion object {
        // volatile确保多线程环境下的可见性
        @Volatile
        private var instance: Demo? = null
        fun getInstance(name: String): Demo {
            //第一次检查，避免不必要的同步
            if (instance == null) {
                synchronized(this) {
                    // 第二次检查，确保只创建一个实例
                    if (instance == null) instance == Demo(name)
                }
            }
            return instance!!
        }
    }
}

//上面 getInstance() 可简写
fun getInstance(name: String) = instance ?: synchronized(this) {
    instance ?: Demo(name).also { instance = it }
}

四、对象表达式（匿名内部类）

4.1 赋值给变量

4.1.1 无继承无实现

val obj = object {
    init { println() }
    val name = ""
    fun show() { println() }
}

4.1.2 单个父类型

abstract class A{}
interface B{}
val obj1: A = object : A() {}
val obj2: B = object : B {}

4.1.3 多个父类型

abstract class AA{ abstract fun aa() }
interface BB{ fun bb() }
//用作顶层变量
val obj1: AA = object: AA(), BB {
    override fun aa() {}
    override fun bb() {}
}
private val obj2 = object: AA(), BB {
    override fun aa() {}
    override fun bb() {}
}
//用作成员变量
class Demo {
    val obj3: AA = object: AA(), BB {
        override fun aa() {}
        override fun bb() {}
    }
    private val obj4 = object: AA(), BB {
        override fun aa() {}
        override fun bb() {}
    }
}
//用作局部变量
fun show(){
    val obj = object : AA(), BB {
        override fun aa() {}
        override fun bb() {}
    }
}

4.2 匿名对象传参、闭包

fun outer() {
    var num = 0    //被访问的局部可以声明为 var，而不是有 final 的 val
    val obj = object {
        fun inner() { num += 1 }
    }
}

​//Android中设置点击监听时，访问外部局部变量
fun show() {
    var num = 0
    //用对象表达式写
    xxx.setOnClickListener(object : View.OnClickListener{
        override fun onClick(v: View){ num += 1 }
    })
    //用 Lambda 简写（仅针对只有一个抽象方法的接口，多方法重写只能用对象表达式）
    xxx.setOnClickListener{ view -> num += 1 }
}