Kotlin-Object

一、 object关键字

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

1、对象表达式

继承一个匿名对象

binding.tvTitle.setOnClickListener(object : View.OnClickListener {
            override fun onClick(v: View?) {
                Toast.makeText(this@MainActivity, "继承一个匿名对象", Toast.LENGTH_SHORT);
            }
        })

2、对象声明

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

2.1 直接声明类
 private const val TAG: String = "DEMO_TAG"
    
    fun log(): Unit {
        Log.i(TAG, "log: ")
    }
2.2 声明静态内部类
class DemoManager{
    object MyObject {
        fun a() {
            Log.e(TAG,"此时 object 表示 直接声明类")
        }
    }
}

如果需要调用 a()方法

  • kotlin中调用 直接类名.函数名
fun init() {
    MyObject.a()
}
  • java中调用 固定表达式 类名.INSTANCE.函数名
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中如何调用外部的成员变量

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表示 伴生对象")
    }
}

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

四、常量和静态方法

常量

Java中:
   class StaticDemoActivity {
         public static final String LOAN_TYPE = "loanType";
         public static final String LOAN_TITLE = "loanTitle";
    }

Kotlin中:
 class StaticDemoActivity {
      companion object StaticParams{
            val  LOAN_TYPE = "loanType"
            val  LOAN_TITLE = "loanTitle"
    }
}

 或者
  class StaticDemoActivity {
      companion object {   // 名字可以不要的 
         const val LOAN_TYPE = "loanType"
         const val LOAN_TITLE = "loanTitle"
    }
}

注:const 关键字用来修饰常量,且只能修饰 val,不能修饰var, companion object 的名字可以省略,可以使用 Companion来指代

引用常量(这里的引用只针对于java引用kotlin代码)

TestEntity类引用StaticDemoActivity中的常量

   class TestEntity {
        public TestEntity () {
            String title = StaticDemoActivity.Companion.getLOAN_TITLE();
    }
  }

  或者

  class TestEntity {
        public TestEntity () {
            String title = StaticDemoActivity.StaticParams.getLOAN_TITLE();
        }
  }

  或者

  class TestEntity {
        public TestEntity () {
            String title = StaticDemoActivity.LOAN_TITLE;
            String type= StaticDemoActivity.LOAN_TYPE;
        }
  }

静态方法

  • Java代码:
      class StaticDemoActivity {
          public static void test(){
                、、、
          } 
      }

  • Kotlin中:
      class StaticDemoActivity {
          public static void test(){
                、、、
          } 
      }

引用静态方法(这里的引用只针对于java引用kotlin代码)

TestEntity类引用StaticDemoActivity中的静态方法

    class TestEntity {
          public TestEntity () {
                StaticDemoActivity.Companion.test();
          }
    }

或者

    class TestEntity {
          public TestEntity () {
             StaticDemoActivity.StaticParams.test();
          }
    }

companion object {}中用来修饰 静态常量,或者静态方法,单例等等

推荐阅读更多精彩内容