Java的单例与kotlin的单例对比

单例的核心·都是差不多的，都是只能允许一个类当中只有一个实例，并且提供一个访问该类对象实例的全局访问点

1.Java

1.1饿汉式

class Util1{
    private static Util1 instance = new Util1();//声明对象并私有化
    private Util1(){

    }//构造函数私有化
    public static Util1 getInstance(){
        return  instance;
    }
}

然后我们到另外一个类或者方法里面引用就可以了

  public void show(){
        Util1 utl = Util1.getInstance();//调用懒汉
        

    }

1.2饿汉式

class Util2{
    private static Util2 utz;//声明对象不实例化
    private Util2(){
    }//构造函数私有化
    public static Util2 getInstance(){
        if(utz == null){
            synchronized (Util2.class){
                if(utz == null){
                    utz = new Util2();
                }
            }
        }
        return utz;
    }
}

然后在另一个类调用该类的方法就可以得到对象

 Util2 util2 =Util2.getInstance();//调用饿汉

2.Kotlin

2.1饿汉式

class Person private constructor(){
    companion object{
        val instance = Person()

    }
}

注意到这里用到了伴生对象，kotlin的伴生对象用companion关键字来指定，可以省略伴生对象的名称，伴生对象的成员可通过只使用类名作为限定符来调用，伴生对象的成员看起来像其他语言的静态成员，在运行时他们仍然是真实对象的实例成员，就是它们只是在静态类里面，本身并没有静态化

然后就可以直接调用

fun main(){
    Person.instance
    
}

2.2懒汉式

class Sqlite private constructor(){
    companion object{
        var default: Sqlite?=null
        fun getInstance(): Sqlite{
            if (default == null){
                synchronized(this) {
                    default = Sqlite()
                }
            }
            return default!!
        }


    }
    fun show(){
        println("hello")
    }

}

其实这里由于是kotlin，就可以更加简便，简化版

class Sqlite2 private constructor(){
    companion object{
        val default: Sqlite2 by lazy(LazyThreadSafetyMode.SYNCHRONIZED){
            Sqlite2()
        }


    }
    fun show(){
        println("hello")
    }

}

然后我们在main函数里面测试一下就可以了

fun main(){
    //Person.instance
    Sqlite.getInstance().show()
    Sqlite2.default.show()
}

其实通过上面我们可以看出来kotlin比Java简便很多，而且所谓的懒汉式其实就是饿汉式的延迟加载，开始是否实例化对象没有