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<P, T> {
@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<String, DogManager>() {
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<P, T> {
//
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<String, PigManager> {
//重写接口中的方法
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方法。就会导致以上的问题。
