Kotlin 中类和对象的区别

Question

我是 Kotlin 的新手，最近将一个简单的文件从 Java 转换为 Kotlin。我想知道为什么 Android 转换器将我的 java 类更改为 Kotlin 对象。

爪哇：

 public class MyClass {
    static public int GenerateChecksumCrc16(byte bytes[]) {

        int crc = 0xFFFF;
        int temp;
        int crc_byte;

        for (byte aByte : bytes) {

            crc_byte = aByte;

            for (int bit_index = 0; bit_index < 8; bit_index++) {

                temp = ((crc >> 15)) ^ ((crc_byte >> 7));

                crc <<= 1;
                crc &= 0xFFFF;

                if (temp > 0) {
                    crc ^= 0x1021;
                    crc &= 0xFFFF;
                }

                crc_byte <<= 1;
                crc_byte &= 0xFF;

            }
        }

        return crc;
    }
}

转换后的 Kotlin：

 object MyClass {
    fun GenerateChecksumCrc16(bytes: ByteArray): Int {

        var crc = 0xFFFF
        var temp: Int
        var crc_byte: Int

        for (aByte in bytes) {

            crc_byte = aByte.toInt()

            for (bit_index in 0..7) {

                temp = crc shr 15 xor (crc_byte shr 7)

                crc = crc shl 1
                crc = crc and 0xFFFF

                if (temp > 0) {
                    crc = crc xor 0x1021
                    crc = crc and 0xFFFF
                }

                crc_byte = crc_byte shl 1
                crc_byte = crc_byte and 0xFF

            }
        }

        return crc
    }
}

为什么不是：

 class MyClass {
    ... etc ...
}

任何帮助将不胜感激谢谢。

原文由 Crunchy234 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

Kotlin 对象就像一个无法实例化的类，因此必须通过名称来调用它。 （本身就是一个静态类）

android 转换器看到你的类只包含一个静态方法，所以它把它转换成一个 Kotlin 对象。

在这里阅读更多相关信息：http: //petersommerhoff.com/dev/kotlin/kotlin-for-java-devs/#objects

原文由 Headline 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

Kotlin 关于此的文档 非常好，请随意阅读。

为这个问题选择的答案在解释中有一些糟糕的措辞，很容易误导人们。例如，对象不是“静态类本身”，而是 a static instance of a class that there is only one of ，也称为单例。

也许显示差异的最好方法是查看 Java 形式的反编译 Kotlin 代码。

Kotlin 对象和类：

 object ExampleObject {
  fun example() {
  }
}

class ExampleClass {
  fun example() {
  }
}

为了使用 ExampleClass ，您需要创建它的一个实例： ExampleClass().example() ，但是对于一个对象，Kotlin 会为您创建它的一个实例，而您不需要曾经调用它的构造函数，而只是使用名称访问它的静态实例： ExampleObject.example() 。

Kotlin 会生成等效的 Java 代码：

Kotlin 编译为 Java 字节码，但如果我们将上面编译的 Kotlin 代码反向编译为 Java 代码，我们将得到：

 public final class ExampleObject {
   public static final ExampleObject INSTANCE = new ExampleObject();

   private ExampleObject() { }

   public final void example() {
   }
}

public final class ExampleClass {
   public final void example() {
   }
}

您可以通过以下方式在 Kotlin 中使用该对象：

 ExampleObject.example()

这将编译为等效的 Java 字节码：

 ExampleObject.INSTANCE.example()

为什么 Kotlin 引入 object s？

object 在 Kotlin 中的主要用例是因为 Kotlin 试图消除静态和原语，为我们留下一种纯面向对象的语言。 Kotlin 仍然使用 static 和引擎盖下的原语，但它不鼓励开发人员再使用这些概念。相反，现在 Kotlin 将 static 替换为单例对象实例。以前在 Java 中使用静态字段的地方，在 Kotlin 中，您现在将创建一个 object ，并将该字段放在 object 中。

与 Java 的互操作性：

因为 Kotlin 与 Java 是 100% 互操作的，所以有时您会希望以一种更便于 Java 阅读的方式公开某些 API 或字段。为此，您可以使用 @JvmStatic 注释。通过使用 @JvmStatic 注释 object 中的字段或函数，它将编译为 Java 可以更轻松使用的静态字段。

伴生对象：

最后一件事值得一提的是 companion object s。在 Java 中，您的类通常有一些静态内容，但也有一些非静态/实例内容。 Kotlin 允许您对伴随对象执行类似的操作，它们是 object 绑定到 class ，这意味着类可以访问它的伴随对象的私有函数和属性：

 class ExampleClass {
  companion object {
    // Things that would be static in Java would go here in Kotlin
    private const val str = "asdf"
  }

  fun example() {
    // I can access private variables in my companion object
    println(str)
  }
}

原文由 spierce7 发布，翻译遵循 CC BY-SA 4.0 许可协议