[英]Difference between a class and object in Kotlin
我是 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 ...
}
任何帮助将不胜感激,谢谢。
为这个问题选择的答案在解释上有一些不好的措辞,很容易误导人们。 例如,一个对象本身并不是“静态类”,而是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
?
Kotlin 中object
的主要用例是因为 Kotlin 试图取消静态和原语,给我们留下一种纯粹的面向对象语言。 Kotlin 仍然在幕后使用static
和原语,但它不鼓励开发人员再使用这些概念。 相反,现在 Kotlin 用单例对象实例替换了静态。 以前在 Java 中使用静态字段的地方,在 Kotlin 中,您现在将创建一个object
,并将该字段放入object
。
与 Java 的互操作性:
由于 Kotlin 与 Java 100% 可互操作,因此有时您会希望以更便于 Java 阅读的方式公开某些 API 或字段。 为此,您可以使用@JvmStatic
注释。 通过注释字段或一个函数object
与@JvmStatic
,它将编译到静态字段的Java可以使用更方便。
伴生对象:
值得一提的最后一件事是companion object
。 在 Java 中,您的类通常包含一些静态内容,但也包含一些非静态/实例内容。 科特林允许你做伴侣的对象,这是类似的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)
}
}
Kotlin 对象就像一个无法实例化的类,因此必须按名称调用它。 (一个静态类本身)
android 转换器看到您的类仅包含一个静态方法,因此将其转换为 Kotlin 对象。
在此处阅读更多相关信息: http : //petersommerhoff.com/dev/kotlin/kotlin-for-java-devs/#objects
一个对象是一个单例。 您无需创建实例即可使用它。
需要实例化一个类才能使用
就像在 Java 中你可以说 Math.sqrt(2) 一样,你不需要创建一个 Math 实例来使用 sqrt,在 Kotlin 中你可以创建一个对象来保存这些方法,它们实际上是静态的。
这里有一些信息:
https://kotlinlang.org/docs/reference/object-declarations.html
IntelliJ 显然足够聪明,可以检测到您需要一个对象,因为您只有静态 Java 方法。
之间的区别:对象|| 类|| 伴生对象|| 数据类
object MyClass{}
,整个变量具有单一引用,但在companion object
您可以选择创建静态方法或创建静态变量equals()
、 hashCode()
和toString()
例子
//---------------1- object ----------------------
object MyClass1 {
fun checkData {
// ...
}
}
MyClass1.checkData() // call method
//----------------2- class ---------------------
class MyClass2 {
fun checkData {
// ...
}
}
var myClass = MyClass2()
myClass.checkData() // call method
//----------------3- companion object ---------------------
class MyClass3 {
companion object {
fun myStaticMethod() {
// ...
}
}
fun myInstanceMethod() {
// ...
}
}
MyClass3.myStaticMethod() // call companion object member
var myClass = MyClass3()
myClass.myInstanceMethod() // call simple method using reference
//----------------4- data class ---------------------
data class MyClass4(val name: String, val rId: Int)
您也可以在没有对象声明的情况下定义函数。 只是在 .kt 文件中例如:
fun GenerateChecksumCrc16(bytes: ByteArray): Int {
...
}
这个函数与声明 .kt 文件的包有关。 你可以在这里阅读更多关于它的信息https://kotlinlang.org/docs/reference/packages.html
基于@speirce7 的回答:
以下代码显示了 Kotlin 中类和对象之间的基本区别:
class ExampleClass(){
fun example(){
println("I am in the class.")
}
}
object ExampleObject{
fun example(){
println("I am in the object.")
}
}
fun main(args: Array<String>){
val exampleClass = ExampleClass() // A class needs to be instantiated.
exampleClass.example() // Running the instance of the object.
ExampleObject.example() // An object can be thought of as a Singleton and doesn't need any instantiation.
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.