Java Kotlin中类和对象之间的差异

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

爪哇：

为什么不是：

class MyClass {
    ... etc ...
}

---

非常感谢您的帮助。

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

android转换器发现您的类只包含一个静态方法，所以它将其转换为Kotlin对象

---

请在此处阅读更多信息：

您还可以定义无需对象声明的函数。只是在.kt文件中 例如：

fun GenerateChecksumCrc16(bytes: ByteArray): Int {
    ...
}

这个函数与声明is.kt文件的包相关。

---

您可以在此处阅读更多有关它的信息

对象是单态对象。使用它不需要创建实例

类需要实例化才能使用

与Java中的Math.sqrt（2）相同，使用sqrt不需要创建数学实例，在Kotlin中可以创建一个对象来保存这些方法，它们实际上是静态的

这里有一些信息：

IntelliJ显然非常聪明，可以检测到您需要一个对象，因为您只有静态java方法。

关于这一点非常好，请随意阅读

为这个问题选择的答案在解释上有些措词不当，很容易误导人们。例如，对象本身不是“静态类”，而是只有一个类的

静态实例，否则称为单例

也许显示差异的最佳方式是查看Java格式的反编译Kotlin代码

Kotlin对象和类：

object ExampleObject {
  fun example() {
  }
}

class ExampleClass {
  fun example() {
  }
}

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

Kotlin将生成的等效Java代码：

object ExampleObject {
  fun example() {
  }
}

class ExampleClass {
  fun example() {
  }
}

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() {
   }
}

您可以按以下方式使用Kotl中的对象：

ExampleObject.example()

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

ExampleObject.INSTANCE.example()

为什么Kotlin引入
对象
s？

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

与Java的互操作性：

object ExampleObject {
  fun example() {
  }
}

class ExampleClass {
  fun example() {
  }
}

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

伴生对象：

object ExampleObject {
  fun example() {
  }
}

class ExampleClass {
  fun example() {
  }
}

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

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)
  }
}

基于@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.
}

class-ExampleClass（）{
有趣的例子（）{
println（“我在班上。”）
}
}
对象示例对象{
有趣的例子（）{
println（“我在对象中。”）
}
}
趣味主线（args:Array）{
val exampleClass=exampleClass（）//需要实例化一个类。
exampleClass.example（）//运行对象的实例。
ExampleObject.example（）//可以将对象视为单例对象，不需要任何实例化。
}
不同于：对象| |类| |伴生对象| |数据类

//---------------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)

1.反对

当第一次访问对象声明时，它会被惰性地初始化
对象的行为类似于单例类
整个应用程序只有一个参考
访问成员、方法而不创建实例

2.课堂

可以创建多个引用
需要为access成员、方法创建实例

3.伴生物体

当加载相应的类时，将初始化伴随对象
默认情况下，在
对象MyClass{}
中，整个变量只有一个引用，但在
伴生对象
中，您可以选择创建静态方法或创建静态变量
您可以创建singleton类

4.数据类

用于保存数据/状态的类
Kotlin的数据类，您不需要自己编写/生成所有冗长的样板代码
编译器会自动为所有可变属性生成默认的getter和setter
编译器自动派生标准方法的实现，如
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)

等一下，但是如果我的类
Human
有