[toc]

对象声明

  object修饰的类与普通类的区别是里边包含一个单例。我也不知道为什么都叫对象声明。

源码解析

object UserManager {
    var age = 1
    fun saveUser()
}

// 反编译出的Java代码
public final class UserManager {
   public static final UserManager INSTANCE;

   public final void saveUser() {
   }

   private UserManager() {
   }

   static {
      UserManager var0 = new UserManager();
      INSTANCE = var0;
   }
}

类对象声明及类成员调用

fun main(args: Array<String>) {
    val p1 = UserManager
    val p2 = UserManager
    println("p1==p2--> ".plus(p1 == p2))
    p1.apply {
        println(this)
        age++
    }
    p2.apply {
        println(this)
        println(age)
    }
}

打印结果可以看出是同一个对象

p1==p2--> true
com.kotlin.login_apiresult.object.UserManager@6f94fa3e
com.kotlin.login_apiresult.object.UserManager@6f94fa3e
2

伴生对象（companion object）

简单理解就是kotlin不支持static，companion object可以模仿static效果

直接看源码解析

class App {
    companion object {
        fun getAppContext() {}
    }
}

// 反编译出的Java代码
public final class App {
   public static final App.Companion Companion = new App.Companion((DefaultConstructorMarker)null);

   public static final class Companion {
      public final void getAppContext() {
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

声明：

class NumberTest {
    companion object Obj {  
        var flag = false

        fun plus(num1: Int, num2: Int): Int {
            return num1 + num2
        }
    }
}

调用

fun main(args: Array<String>) {

    println(NumberTest.plus(1, 2))  // 3
    println(NumberTest.flag)  // false

}

静态常量（用的挺多）

在伴生对象中，我们可能需要声明一个常量，目的是等同于 Java 中的静态常量。有两种方式，一种是上面所提到的使用 @JvmField 注解，另一种则是使用 const 关键字修饰。这两种声明方式都等同于 Java 中 static final 所修饰的变量。如下代码：

companion object {
      const val m = 2

      @JvmField
      val n = 3
}

// java 代码中调用：
System.out.println(NumberTest.m);
System.out.println(NumberTest.n);

扩展属性(很少用)

var NumberTest.Companion.number
    get() = 3
    set(value) {
        // set 方法并没有 field 可以用来存储 value
        this.plus(value, 2)
    }

val NumberTest.Companion.str
    get() = "这是一个扩展属性"

单例(用的挺多)

class Person{
    val age = 1
    companion object{
        val instance by lazy {
            Person()
        }
    }
}

对象表达式

我也不知道为啥叫对象表达式，用的最多的地方就是匿名内部类，不过有了高阶函数感觉用的地方也不多

private val callBack = object : CallBack {

    override fun onSuccess() {}

    override fun onFailure() {}
}

// 通过对象表达式实现点击事件回调
btn.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View) {
        TODO("Not yet implemented")
    }
})