Kotlin学习笔记（十七）object 关键字

1.对象声明

object关键字通过对象声明来实现Java 中的单实例模式，与普通类不同，对象声明在定义的时候就被创建，无需构造方法。Kotlin中的对象声明被编译成了通过静态字段持有它的单实例的类。

fun main() {
    println(MyObject.SingleClass.name)
    MyObject.SingleClass.getSex()
}

class MyObject {
    //通过object关键字实现单例
    object SingleClass {
        val name = listOf(1, 2, 3)
        fun getSex() {
            println("性别")
        }
    }
}

[1, 2, 3]
性别

2.伴生对象

如果我们想要实现通过类似Java中静态的方式，直接通过类可以访问成员，我们可以通过伴生对象，companion object来实现

fun main() {
    println(MyStatis.name)
    MyStatis.getSex()
}
class MyStatis {
   companion object{
       val name = listOf(1, 2, 3)
       fun getSex() {
           println("性别")
       }
   }
}

[1, 2, 3]
性别

1.工厂模式

使用伴生对象实现工厂模式

fun main() {
    //因为私有化，没法调用构造方法创建
    //val factor = MyFactor("小明")
    //通过工厂初始化MyFactor对象
   val factor = MyFactor.instance("小明")
    println(factor.name)
}
//私有的构造方法
private class MyFactor private constructor(val name: String) {
    companion object {
        fun instance(name:String) =MyFactor(name)
    }
}

小明

2.指定名称

伴生对象的名字默认是Companion,也可以自定义名字，也可以省略名字

fun main() {
    MyStatis.Companion.getSex()

}

class MyStatis {
    companion object  {
        val name = listOf(1, 2, 3)
        fun getSex() {
            println("性别")
        }
    }
}

fun main() {
    MyStatis.MyTest.getSex()

}

class MyStatis {
    companion object MyTest  {
        val name = listOf(1, 2, 3)
        fun getSex() {
            println("性别")
        }
    }
}

3.实现接口

伴生对象也可以实现接口

fun main() {
    newThread(MyStatis).start()
}
fun newThread(run:Runnable) = Thread(run)
class MyStatis {
    companion object MyTest:Runnable  {
        override fun run() {
            println("这是开启了一个线程")
        }
    }
}

这是开启了一个线程

3.对象表达式

object声明的表达式可以替换Java中的匿名内部类，并且object表达式中的代码，可以修改外部声明的变量值

fun main() {
    newThread().start()
}
fun newThread() = Thread(object :Runnable{
    var count = 1
    override fun run() {
        //修改count的值
        count++
        println(count)
    }

})

2