一、 object关键字

object 关键字可以表达两种含义：一种是对象表达式,另一种是 对象声明。

1、对象表达式

继承一个匿名对象

val textView = findViewById<TextView>(R.id.tv)
textView.setOnClickListener(object : OnClickListener {
        override fun onClick(p0: View?) {
            Toast.makeText(this@TestActivity, "点击事件生效", Toast.LENGTH_LONG)
        }
 
})

上面代码其实就是我们经常要给 view 设置的点击事件，OnClickListener 事件是一个匿名类的对象，用object来修饰。

2、对象声明

用object 修饰的类为静态类，里面的方法和变量都为静态的。

2.1 直接声明类

object DemoManager {
    private val TAG = "DemoManager"
        
    fun a() {
        Log.e(TAG,"此时 object 表示 直接声明类")
    }
    
}

2.2 声明静态内部类

类内部的对象声明，没有被inner 修饰的内部类都是静态的

class DemoManager{
    object MyObject {
        fun a() {
            Log.e(TAG,"此时 object 表示 声明静态内部类")
        }
    }
}

如果需要调用 a()方法

kotlin中调用

fun init() {
    MyObject.a()
}

java中调用

 MyObject.INSTANCE.a();

二、companion object

companion object 修饰为伴生对象,伴生对象在类中只能存在一个，类似于java中的静态方法 Java 中使用类访问静态成员，静态方法。

companion object {
    private val TAG = "DemoManager"
 
    fun b() {
        Log.e(TAG,"此时 companion objec t表示 伴生对象")
    }
}

kotlin 中调用

fun init(){
       b()
}

java 中调用

DemoManager.Companion.b();

companion object 相关的内容可以查阅 Kotlin中常量和静态方法 这篇文章，在这里不多在具体描述。

三、在companion object中如何调用外部的成员变量

3.1 为什么companion object 中调用不到外部成员变量

class DemoManager {
    private val MY_TAG = "DemoManager"
   
    fun init(){
       b()
   }
 
    companion object {
        fun b() {
            Log.e(MY_TAG,"此时 companion objec t表示 伴生对象")
        }
    }
}

在上面代码中MY_TAG 是不会被调用到的。

原理很简单：

在java中我们写一个静态方法，如果需要调用成员变量，是无法调用到的

private String TAG = "MainActivity";
  
public static void init(){
        Log.e(TAG,"init() ");
}

只有将 TAG 修改为静态成员变量才能调用到

private static String TAG = "MainActivity";
  
public static void init(){
        Log.e(TAG,"init() ");
}

由此可以看出来，java中静态方法调用成员变量，要求成员变量必须是静态的， 在kotlin 中也是一样，所以当companion object 中调用非静态的成员变量也是调用不到的。

3.2 怎样解决才能调用到呢？

companion object {
    private val MY_TAG = "DemoManager"
    fun b() {
        Log.e(MY_TAG,"此时 companion objec t表示 伴生对象")
    }
}

将所引用的成员变量也修饰静态的，这样就可以引用到了。

================分割线===================

综合例子

import android.util.Log

object DemoManager {
    private val TAG = "DemoManager"

    fun a() {
        Log.e(TAG,"此时 object 表示 直接声明类")
    }

}

class DemoManager1{
    //这个值,object内访问不到,相当于不可访问外部类参数的内部类
    private val TAG_OUTER = "DemoManager1"

    fun outerFun(){
        Log.e(TAG_OUTER,"我是外部类的方法")
    }

    //不可访问外部类属性和方法的,静态内部类
    object MyObject {
        const val TAG = "DemoManager1"
        fun a() {
            //todo object修饰的静态内部类,不能访问外部的属性和方法
//            Log.e(TAG_OUTER,"此时 object 表示 声明静态内部类")//TAG_OUTER引用不到
//            outerFun()//这个方法不能直接用
            Log.e(TAG,"此时 object 表示 声明静态内部类")
        }
    }

    //TODO inner修饰的内部类,可以访问外部类的属性
    inner class MyInnerClass{
        fun b() {
            Log.e(TAG_OUTER,"此时 object 表示 声明静态内部类")
            outerFun()
        }
    }

    //伴生类
    companion object {
        private val TAG = "DemoManager"

        fun companionObjectFun() {
            Log.e(TAG,"此时 companion objec t表示 伴生对象")
            Log.e(MyObject.TAG,"此时 companion objec t表示 伴生对象")

            MyObject.a()

            //不可以调用外部类的非静态方法
            //outerFun()
        }

        @JvmStatic//给Java中好点出来,省略写Companion,kotlin中没有变化
        fun staticFun(){
            Log.e(TAG,"伴生类中的静态方法,可以只额吉点出来,不用中间加一个Companion")
        }
    }

}

调用差别：