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使用