Kotlin中object和companion object 区别

文章参考网址：
区别Kotlin中的object和companion object关键字

概念：

• object声明（一个类）是延迟加载的，只有当第一次被访问时才会初始化，所以被用来实现单例
• companion object是当包含它的类被加载时就初始化了的，这一点和Java的static还是一样的

基本区别：

• object 可以定义在全局也可以在类的内部使用
• object 就是单例模式的化身
• object 可以实现 Java 中的匿名类
• companion object 就是 Java 中的 static 变量
• companion object 只能定义在对应的类中

更多区别：

• object 可以作为变量的定义也可以是表达式
• object 匿名类可以继承并超越 Java 中匿名类而实现多个接口
• object 表达式当场实例化，但定义的 object 变量是延迟实例化的
• object 和 companion object 都可以为其取名也可以隐姓埋名
• object 匿名内部类甚至可以引用并更改局部变量
• companion object 甚至还可以被扩展
• Java 中需要结合 @JvmStatic 和 @JvmField 使用

object的使用

package com.example.todayheadline.demo


/**
 * object和companion object 区别
 */
fun main() {
   System.out.println("开始了")
   //object实现单例模式
   // 1.object可以定义在类全局中，也可以定义在类内部
   // 2.object被定义后即被实力化，所以不能写构造方法
   // 3.内部object类不能访问外部类的变量
   OutClass.outParm
   OutClass.outfun()
   OutTestClass.innerClass.innerfun()
   //object实现匿名内部类
   //object 匿名类可以同时实现多个接口
   //button.setOnClickListener( object:OnClickListener { dosomething } )
   //java中内部类是不可以访问外部的非final成员变量的（变量）但kotlin可以实现匿名内部类访问外部的变量
    TestClass()




}

object OutClass{
   val outParm = "我是外部object类的参数"
   fun outfun(){
      System.out.println("我是外部object类的方法---${outParm}")
   }
}

class OutTestClass{
   var outTestParm = "我是测试外部类的参数"
   object innerClass{
      fun innerfun(){
         System.out.println("我是内部object类的方法")//不能访问outTestParm参数,匿名内部类中可以
      }

   }
}

interface interfaceTest {
    fun test()
}

class TestClass{
    var testName = "我是初始值"
    fun setSubClass(interfaceTest: interfaceTest){
        interfaceTest.test()
    }
    //因为kotlin中的类定义同时也是构造函数，这个时候是不能进行操作的，所以kotlin增加了一个新的关键字init用来处理类的初始化问题，init模块中的内容可以直接使用构造函数的参数。
    init {
        this.setSubClass(object:interfaceTest{
            override fun test(){
                 testName = "我的值被修改了"
                System.out.println("${testName}")
           }
        })
    }

}

companion object的使用

• companion object 的定义完全属于类的本身，所以 companion object 肯定是不能脱离类而定义在全局之中。它就像 Java 里的 static 变量，所以我们定义 companion object 变量的时候也一般会使用大写的命名方式。
• 同时，和 object 类似，可以给 companion object 命名，也可以不给名字，这个时候它会有个默认的名字： Companion ，而且，它只在类里面能定义一次：

package com.example.todayheadline.demo

fun main() {
    // companion object 的定义完全属于类的本身，所以肯定是不能脱离类，而定义在全局之中。它就像Java里的static变量
    System.out.println("${ CompanionObjectTest.TEST_URL}")
    CompanionObjectTest.method()
    //类名可作为接口参数传入
    setInterface(CompClass)
    //扩展类的成员变量 Companion：默认名  暂无法印证

}



//定义companion object
class CompanionObjectTest{
    companion object{
        val TEST_URL= "http://liuqingwen.me/blog/2017/06/20/object-vs-companion-object-in-kotlin/"
        fun method(){
            System.out.println("添加注解")
        }
    }
}

//类名作为接口参数
interface CompInterface{
    fun getTest()
}
class CompClass{
    companion object:CompInterface{
          override fun getTest() {
                System.out.println("接口方法")
           }
    }

}
fun setInterface(compInterface: CompInterface) = compInterface.getTest()
//扩展类的静态成员
class CompClass2{
    companion object{
        val TEST_URL= "http://liuqingwen.me"
    }

}

@JvmField和 @JvmStatic用法

• @JvmField消除了变量的getter与setter方法
• @JvmField修饰的变量不能是private属性的
• @JvmStatic只能在object类或者伴生对象companion object中使用，而@JvmField没有这些限制
• @JvmStatic一般用于修饰方法，使方法变成真正的静态方法；如果修饰变量不会消除变量的getter与setter方法，但会使getter与setter方法和变量都变成静态

总结

• 因为java调用kotlin的代码时，如果不对变量名或方法添加 @JvmField/ @JvmStatic， java代码需要写成 Class.Companion.method(),
• 若添加了@JvmStatic，则直接调用Class.method()就可以了
• 另外：定义静态变量还可以使用 const val， 不过他也得结合object/companion object使用