Kotlin-object关键字到底有几种用法？

object在Kotlin有三种用法使用匿名内部类创建对象、单例、伴生对象。因为三者都是创建了对象，因此统一用object来声明。

1、匿名内部类创建对象

interface OnclickListener {
    fun onClick(msg: String)
}

fun main() {
    val listener = object : OnclickListener {
        override fun onClick(msg: String) {
        }
    }
}

当匿名内部类中只有一个需要实现的方法，我们可以使用SAM转换，使得代码更加简洁

val l = OnclickListener {}

做了一个实验，如果声明的接口是OnclickListener Java的接口，可以使用SAM。而如果声明的接口是kotlin的接口，则不能使用SAM，还是需要使用object 匿名内部类的方式，如

//Java接口

public interface OnclickListener {
    void onClick();
}

//kotlin接口
interface OnclickListener2 {
    fun onClick()
}

fun main() {
    val l = OnclickListener {
    }
    //kotlin接口 使用SAM报错
    val l2 = OnclickListener2 {

    }
    //kotlin接口 使用objec匿名内部类的方式
    val l3 = object : OnclickListener2 {
        override fun onClick() {

        }
    }
}

在Java中匿名内部类不能再继承其他的类和实现接口，但是再Kotlin却可以。如：

interface OnclickListener {
    fun onClick(msg: String)
}

abstract class Student() {
    abstract fun getName();

}

fun main() {
    val listener = object : OnclickListener, Student() {
        override fun onClick(msg: String) {
        }

        override fun getName() {

        }
    }
}

在日常开发中，当我们需要继承某个类，并同时实现某个接口的时候，并且只使用一次，后面就不在需要了，这个时候我们可以通过匿名内部类的方式继承并实现。

2、object单例

以下我们通过object关键字实现了一个单例。

object Student {
}

我们把kotlin代码转成字节码再反编译成Java代码，看看对应的Java是如何实现的

public final class Student {
   @NotNull
   public static final Student INSTANCE;

   private Student() {
   }

   static {
      Student var0 = new Student();
      INSTANCE = var0;
   }
}

从Java代码看来，非常简单。通过静态代码块实现的饿汉式的单例。在类初始化的时候就会创建Student对象。但是这种方法创建的单例对象缺点也非常明显：

• 不支持懒加载，类初始化的时候就会创建Student对象
• 不支持传参，我们通过Java代码可以看到是无参的构造函数。在Android开发中，我们的单例往往都是需要传递参数，例如传递Context对象。
  后续介绍如何解决？

3、伴生对象

以上我们说到了使用object 实现单例，现在我们看看kotlin在类中嵌套object 的情况

class Teacher {
    object Dog {
        fun say() {
            println("hello world")
        }
    }
}
fun main() {
    Teacher.Dog.say()
}

转成Java代码

public final class Teacher {

   public static final class Dog {
      @NotNull
      public static final Teacher.Dog INSTANCE;

      public final void say() {
         String var1 = "hello world";
         boolean var2 = false;
         System.out.println(var1);
      }

      private Dog() {
      }

      static {
         Teacher.Dog var0 = new Teacher.Dog();
         INSTANCE = var0;
      }
   }
}
public final class TeacherKt {
   public static final void main() {
      Teacher.Dog.INSTANCE.say();
   }

}

我们发现在Kotlin类中嵌套object单例，Java中其实就是在类中嵌套一个静态内部类，静态内部类通过静态代码块的方式实现单例。这样我们就可以通过外部类访问内部类再访问其中的单例成员。

嵌套单例加上companion 关键字

class Teacher {
    companion object Dog {
        fun say() {
            println("hello world")
        }
    }
}
fun main() {
    Teacher.say()
}

加上companion 关键字之后，我们发现可以直接通过Teacher 类访问Dog 中的say方法。有点类似Java中的静态成员，我们转成Java代码看看？

// Teacher.java
public final class Teacher {
   @NotNull
   public static final Teacher.Dog Dog = new Teacher.Dog((DefaultConstructorMarker)null);

   public static final class Dog {
      public final void say() {
         String var1 = "hello world";
         boolean var2 = false;
         System.out.println(var1);
      }

      private Dog() {
      }

      public Dog(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}
public final class TeacherKt {
   public static final void main() {
      Teacher.Dog.say();
   }
   public static void main(String[] var0) {
      main();
   }
}

加上companion 关键字之后其实最终效果都是一样的，都是通过Teacher访问Dog单例对象。只是实现方法不一样，前者是再Dog内部静态代码块创建Dog单例对象，赋给Dog成员，访问的时候通过Teacher访问Dog的成员。后者则是在外部类Teacher通过静态成员的方式创建Dog单例对象，因此访问的时候可以直接通过Teacher访问单例成员。但是最终效果都是一样的。内部都是一个单例对象。并不是静态方法和静态属性。
如果我们想实现像Java中的static方式，可以在object中的方法成员加上 @JvmStatic注解

object Teacher {
    @JvmStatic
    fun test() {
    }
}
fun main() {
    Teacher.test()
}

public final class Teacher {
   @NotNull
   public static final Teacher INSTANCE;

   @JvmStatic
   public static final void test() {
   }

   private Teacher() {
   }

   static {
      Teacher var0 = new Teacher();
      INSTANCE = var0;
   }
}

public final class TeacherKt {
   public static final void main() {
      Teacher.test();
   }

   public static void main(String[] var0) {
      main();
   }
}

在开发中我们常常省略了伴生对象的名字

class Teacher {
    companion object {
        fun sy() {
        }
    }
}

fun main() {
    Teacher.sy()
}

这样的话系统会给我们默认创建一个静态内部类

public final class Teacher {
   @NotNull
   public static final Teacher.Companion Companion = new Teacher.Companion((DefaultConstructorMarker)null);
   public static final class Companion {
      public final void sy() {
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

public final class TeacherKt {
   public static final void main() {
      Teacher.Companion.sy();
   }

   public static void main(String[] var0) {
      main();
   }
}

回到最开始说的，object的不同用法，最终都是表示创建了一个对象。因此kotlin使用了object关键字。

4、关于工厂设计模式

所谓工厂设计模式，就是当我们想要统一管理一个类对象的创建的时候，我们可以将这个类的构造函数私有，使用工厂方法统一暴露。以下我们通过kotlin伴生对象来实现

class User private constructor(val name: String) {
    companion object {
        fun create(name: String): User {
            return User(name)
        }
    }
}

fun main() {
    val user = User.create("xiaoming")
    println(user.name)
    
}

另外四种单例的写法

• 借助懒加载

//方式一
object StudentManager {
    val student by lazy { Student() }
}
class Student
//方式2
class Student2 private constructor() {
    companion object {
        val student3 = Student2()
        val student2 by lazy { Student2() }
    }
}

其本质都是在object单例内部创建单例对象。至于 by lazy 为什么能懒加载，后续探讨~

• 伴生对象Double Check

class PersonManager private constructor() {
    companion object {
        @Volatile
        private var INSTANCE: PersonManager? = null;
        fun getInstance(): PersonManager =
            //锁object
            INSTANCE ?: synchronized(this) {
                INSTANCE ?: PersonManager().also { INSTANCE = it }
            }
    }
}

等同于Java的Double Check

public class PersonManager2 {
    private volatile static PersonManager2 INSTANCE;

    private PersonManager2() { }

    public static PersonManager2 getInstacnce() {
        if (INSTANCE == null) {
            //锁class
            synchronized (PersonManager2.class) {
                if (INSTANCE == null) {
                    INSTANCE = new PersonManager2();
                }
            }
        }
        return INSTANCE;

    }

}

• 抽象类模板实现公共单例
  将以上的doubule chek升级成 抽象类公共模板，

abstract class BaseSingleton {
    @Volatile
    private var instance: T? = null

    protected abstract fun creat(p: P): T

    fun getInstance(p: P): T = instance ?: synchronized(this) {
        instance ?: creat(p).also { instance = it }
    }

}

class DogManager private constructor(val name: String) {
    companion object : BaseSingleton() {
        override fun creat(p: String): DogManager = DogManager(p)

    }
}

fun main() {
    val dog = DogManager.getInstance("this dog")
    println(dog.name)
    val dog2 = DogManager.getInstance("this dog2")
    println(dog2==dog)
}

• 接口模板实现公共单例（不推荐）

interface InterfaceSingleton {
    //
    var instance: T?

    fun getInstance(p: P): T = instance ?: synchronized(this) {
        instance ?: creat(p).also { instance = it }
    }
    fun creat(p: P): T
}
class PigManager private constructor(val name: String) {
    companion object : InterfaceSingleton {
        //重写接口中的方法
        override fun creat(p: String): PigManager = PigManager(p)
        //重写接口中的成员
        override var instance: PigManager? = null

    }

}

之所以不推荐使用接口模板的原因是因为kotlin接口的局限性

• 接口中的成员属性，如果转成Java而言其实是set get方法，因此不能使用private（接口的特性）而一般单例中我们都是使用private修饰单例对象成员，并且由于是set get方法必须要实现重写接口中的成员，代码比较麻烦
• 无法使用@Volatile修饰，因为接口中的成员其实是函数不是真正意义的成员变量。并发问题没有做到最好
• 对于val和var关键字，当使用private修饰的时候，其实就是声明了一个普通的成员变量。如果不使用private关键字修饰，那么就会默认持有set和get方法，因此对于抽象类和接口，抽象类使用了private修饰了成员，就是一个普通的成员，接口不能使用private修饰，就会持有set和get方法。就会导致以上的问题。