Kotlin与Java单利模式对比实现

饿汉式

//Java实现
public class SingletonCless {
    private static SingletonCless instance=new SingletonCless();
    private SingletonCless(){}
    public static SingletonCless getInstance(){
        return instance;
    }
}
//Kotlin对象声明方式实现
object SingletonCless {
    var text:String="饿汉式单利"
    fun show(){
        println(text)
    }
}

对于Kotlin的对象声明，初次接触Kotlin的可能会有些陌生，包括下面即将用到的半生对象，不懂的小伙伴点击传送门先去了解下 —>传送门

懒汉式(线程安全的)

//Java实现
public class SingletonClass2 {
    private static SingletonClass2 instance;
    private SingletonClass2(){}
    public static synchronized SingletonClass2 getInstance(){//使用同步锁
        if(instance==null){
            instance=new SingletonClass2();
        }
        return instance;
    }
}

//Kotlin伴生对象方式实现
class SingletonClass2 private constructor(){
    init {
        println("懒汉式单利实例化了")
    }
    //伴生对象
    companion object{
        //自定义属性访问器，field为Kotlin幕后字段
        private var instance:SingletonClass2?=null
            get() {
                if (field==null){
                    field= SingletonClass2()
                }
                return field
            }
        @Synchronized
        fun getInstances():SingletonClass2{
            return instance!!
        }
    }
    fun show(){
        println("我是张三")
    }
}

上述的Kotlin代码中,在伴生对象中我们自定义了一个属性访问器，在其中实例化对象并赋值给幕后字段field，除了几个新概念，其逻辑跟Java基本相似

双重校验锁式（Double Check)

//Java实现
public class SingletonClass3 {
    private volatile static SingletonClass3 instance;
    private SingletonClass3(){} 
    public static SingletonClass3 getInstance(){
        if(instance==null){
            synchronized (SingletonClass3.class){
                if(instance==null){
                    instance=new SingletonClass3();
                }
            }
        }
        return instance;
    }
}

//Kotlin实现
class SingletonClass3 private constructor(){
    init {
        println("我被实例化了")
    }
    companion object{
        val getInstances:SingletonClass3 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED){
            SingletonClass3()
        }
    }
    fun show(){
        println("实例化的方法")
    }
}

此处用到了Kotlin的延迟属性 Lazy

静态内部类式

//Java实现
public class SingletonClass4 {
    private static class SingletonHolder{
        private static SingletonClass4 instance=new SingletonClass4();
    }
    private SingletonClass4(){}
    public static SingletonClass4 getInstance(){
        return SingletonHolder.instance;
    }
}
//kotlin实现
class SingletonClass4 private constructor() {
    companion object {
        val instance = SingletonHolder.holder
    }
    private object SingletonHolder {
        val holder= SingletonClass4()
    }

}