[译] Kotlin中关于Companion Object的那些事

时间 2019-11-06

标签 kotlin 关于 companion object 那些繁體版

原文原文链接

翻译说明:java

原标题: A few facts about Companion objects算法

原文地址: blog.kotlin-academy.com/a-few-facts…](blog.kotlin-academy.com/a-few-facts…)设计模式

原文做者: David Blanc数组

Kotlin给Java开发者带来最大改变之一就是废弃了static修饰符。与Java不一样的是在Kotlin的类中不容许你声明静态成员或方法。相反，你必须向类中添加Companion对象来包装这些静态引用: 差别看起来彷佛很小，可是它有一些明显的不一样。数据结构

首先，companion伴生对象是个实际对象的单例实例。你实际上能够在你的类中声明一个单例，而且能够像companion伴生对象那样去使用它。这就意味着在实际开发中，你不只仅只能使用一个静态对象来管理你全部的静态属性! companion这个关键字实际上只是一个快捷方式，容许你经过类名访问该对象的内容(若是伴生对象存在一个特定的类中，而且只是用到其中的方法或属性名称，那么伴生对象的类名能够省略不写)。就编译而言，下面的testCompanion（）方法中的三行都是有效的语句。app

class TopLevelClass {

    companion object {
        fun doSomeStuff() {
            ...
        }
    }

    object FakeCompanion {
        fun doOtherStuff() {
            ...
        }
    }
}

fun testCompanion() {
    TopLevelClass.doSomeStuff()
    TopLevelClass.Companion.doSomeStuff()
    TopLevelClass.FakeCompanion.doOtherStuff()
}
复制代码

为了兼容的公平性，companion关键字还提供了更多选项，尤为是与Java互操做性相关选项。果您尝试在Java类中编写相同的测试代码，调用方式可能会略有不一样：ide

public void testCompanion() {
    TopLevelClass.Companion.doSomeStuff();
    TopLevelClass.FakeCompanion.INSTANCE.doOtherStuff();
}
复制代码

区别在于: Companion做为Java代码中静态成员开放(实际上它是一个对象实例，可是因为它的名称是以大写的C开头，因此有点存在误导性)，而FakeCompanion引用了咱们的第二个单例对象的类名。在第二个方法调用中，咱们须要使用它的INSTANCE属性来实际访问Java中的实例(你能够打开IntelliJ IDEA或AndroidStudio中的"Show Kotlin Bytecode"菜单栏，并点击里面"Decompile"按钮来查看反编译后对应的Java代码)函数

在这两种状况下(不论是Kotlin仍是Java)，使用伴生对象Companion类比FakeCompanion类那种调用语法更加简短。此外，因为Kotlin提供一些注解，可让编译器生成一些简短的调用方式，以便于在Java代码中依然能够像在Kotlin中那样简短形式调用。post

@JvmField注解，例如告诉编译器不要生成getter和setter,而是生成Java中成员。在伴生对象的做用域内使用该注解标记某个成员，它产生的反作用是标记这个成员不在伴生对象内部做用域，而是做为一个Java最外层类的静态成员存在。从Kotlin的角度来看，这没有什么太大区别，可是若是你看一下反编译的字节代码，你就会注意到伴生对象以及他的成员都声明和最外层类的静态成员处于同一级别。性能

另外一个有用的注解 @JvmStatic.这个注解容许你调用伴生对象中声明的方法就像是调用外层的类的静态方法同样。可是须要注意的是：在这种状况下，方法不会和上面的成员同样移出伴生对象的内部做用域。由于编译器只是向外层类中添加一个额外的静态方法，而后在该方法内部又委托给伴生对象。

一块儿来看一下这个简单的Kotlin类例子:

class MyClass {
    companion object {
        @JvmStatic
        fun aStaticFunction() {}
    }
}
复制代码

这是相应编译后的Java简化版代码:

public class MyClass {
    public static final MyClass.Companion Companion = new MyClass.Companion();
    fun aStaticFunction() {//外层类中添加一个额外的静态方法
        Companion.aStaticFunction();//方法内部又委托给伴生对象的aStaticFunction方法
    }
    public static final class Companion {
         public final void aStaticFunction() {}
    }
}
复制代码

这里存在一个很是细微的差异，但在某些特殊的状况下可能会出问题。例如，考虑一下Dagger中的module(模块)。当定义一个Dagger模块时，你可使用静态方法去提高性能，可是若是你选择这样作，若是您的模块包含静态方法之外的任何内容，则编译将失败。因为Kotlin在类中既包含静态方法，也保留了静态伴生对象，所以没法以这种方式编写仅仅包含静态方法的Kotlin类。

可是不要那么快放弃! 这并不意味着你不能这样作，只是它须要一个稍微不一样的处理方式：在这种特殊的状况下，你可使用Kotlin单例(使用object对象表达式而不是class类)替换含有静态方法的Java类并在每一个方法上使用@JvmStatic注解。以下例所示：在这种状况下，生成的字节代码再也不显示任何伴生对象，静态方法会附加到类中。

@Module
object MyModule {

    @Provides
    @Singleton
    @JvmStatic
    fun provideSomething(anObject: MyObject): MyInterface {
        return myObject
    }
}
复制代码

这又让你再一次明白了伴生对象仅仅是单例对象的一个特例。但它至少代表与许多人的认知是相反的，你不必定须要一个伴生对象来维护静态方法或静态变量。你甚至根本不须要一个对象来维护，只要考虑顶层函数或常量：它们将做为静态成员被包含在一个自动生成的类中(默认状况下，例如MyFileKt会做为MyFile.kt文件生成的类名，通常生成类名以Kt为后缀结尾)

咱们有点偏离这篇文章的主题了，因此让咱们继续回到伴生对象上来。如今你已经了解了伴生对象实质就是对象，也应该意识到它开放了更多的可能性，例如继承和多态。

这意味着你的伴生对象并非没有类型或父类的匿名对象。它不只能够拥有父类，并且它甚至能够实现接口以及含有对象名。它不须要被称为companion。这就是为何你能够这样写一个Parcelable类：

class ParcelableClass() : Parcelable {

    constructor(parcel: Parcel) : this()

    override fun writeToParcel(parcel: Parcel, flags: Int) {}

    override fun describeContents() = 0

    companion object CREATOR : Parcelable.Creator<ParcelableClass> {
        override fun createFromParcel(parcel: Parcel): ParcelableClass = ParcelableClass(parcel)

        override fun newArray(size: Int): Array<ParcelableClass?> = arrayOfNulls(size)
    }
}
复制代码

这里, 伴生对象名为CREATOR，它实现了Android中的Parcelable.Creator接口，容许遵照Parcelable约定，同时保持比使用@JvmField注释在伴随对象内添加Creator对象更直观。Kotlin中引入了@Parcelize注解，以便于能够得到全部样板代码，可是在这不是重点...

为了使它变得更简洁，若是你的伴生对象能够实现接口，它甚至可使用Kotlin中的代理来执行此操做：

class MyObject {
    companion object : Runnable by MyRunnable()
}
复制代码

这将容许您同时向多个对象中添加静态方法！请注意，伴生对象在这种状况下甚至不须要做用域体，由于它是由代理提供的。

最后但一样重要的是，你能够为伴生对象定义扩展函数! 这就意味着你能够在现有的类中添加静态方法或静态属性，以下例所示:

class MyObject {

    companion object

    fun useCompanionExtension() {
        someExtension()
    }

}

fun MyObject.Companion.someExtension() {}//定义扩展函数
复制代码

这样作有什么意义？我真的不知道。虽然Marcin Moskala建议使用此操做将静态工厂方法以Companion的扩展函数的形式添加到类中。

总而言之，伴生对象不只仅是为了给缺乏static修饰符的使用场景提供解决方案:

它们是真正的Kotlin对象，包括名称和类型，以及一些额外的功能。
他们甚至能够不用于仅仅为了提供静态成员或方法场景。能够有更多其余选择，好比他们能够用做单例对象或替代顶层函数的功能。

与大多数场景同样，Kotlin意味着在你设计过程须要有一点点转变，但与Java相比，它并无真正限制你的选择。若是有的话，也会经过提供一些新的、更简洁的方式让你去使用它。

欢迎关注Kotlin开发者联盟，这里有最新Kotlin技术文章，每周会不按期翻译一篇Kotlin国外技术文章。若是你也喜欢Kotlin，欢迎加入咱们~~~

Kotlin系列文章，欢迎查看:

Kotlin邂逅设计模式系列:

当Kotlin完美邂逅设计模式之单例模式(一)

数据结构与算法系列:

每周一算法之二分查找(Kotlin描述)

Kotlin 原创系列：

Effective Kotlin翻译系列

翻译系列：

实战系列: