Unterschied zwischen einer Klasse und einem Objekt in Kotlin
Lesezeit: 6 Minuten
Knusprig234
Ich bin neu bei Kotlin und habe kürzlich eine einfache Datei von Java nach Kotlin konvertiert. Ich frage mich, warum der Android-Konverter meine Java-Klasse in ein Kotlin-Objekt geändert hat.
Java:
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;
}
}
Konvertierter 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
}
}
Warum war es nicht:
class MyClass {
... etc ...
}
Jede Hilfe wäre sehr dankbar, danke.
durchbohren7
Kotlins Dokumentation auf diesem ist ziemlich gut, also fühlen Sie sich frei, das zu lesen.
Die gewählte Antwort auf diese Frage hat eine schlechte Ausdrucksweise in ihrer Erklärung und könnte Menschen leicht irreführen. Zum Beispiel ist ein Objekt nicht “per se eine statische Klasse”, sondern es ist eine a static instance of a class that there is only one ofauch bekannt als Singleton.
Vielleicht lässt sich der Unterschied am besten zeigen, wenn man sich den dekompilierten Kotlin-Code in Java-Form ansieht.
Kotlin-Objekt und -Klasse:
object ExampleObject {
fun example() {
}
}
class ExampleClass {
fun example() {
}
}
Zur Nutzung der ExampleClassmüssen Sie eine Instanz davon erstellen: ExampleClass().example()aber mit einem Objekt erstellt Kotlin eine einzelne Instanz davon für Sie, und Sie rufen niemals seinen Konstruktor auf, sondern greifen einfach auf seine statische Instanz zu, indem Sie den Namen verwenden: ExampleObject.example().
Entsprechender Java-Code, den Kotlin generieren würde:
Kotlin kompiliert in Java-Bytecode, aber wenn wir den oben kompilierten Kotlin-Code in Java-Code umkehren, erhalten wir Folgendes:
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() {
}
}
Sie würden das Objekt in Kotlin folgendermaßen verwenden:
ExampleObject.example()
Was sich zum äquivalenten Java-Bytecode kompilieren würde für:
ExampleObject.INSTANCE.example()
Warum führt Kotlin ein objects?
Der primäre Anwendungsfall von object in Kotlin liegt daran, dass Kotlin versucht, Statik und Primitive abzuschaffen und uns eine rein objektorientierte Sprache hinterlässt. Kotlin verwendet immer noch static und Primitive unter der Haube, aber es hält Entwickler davon ab, diese Konzepte weiter zu verwenden. Stattdessen ersetzt Kotlin jetzt statische durch Singleton-Objektinstanzen. Wo Sie zuvor statische Felder in Java verwendet haben, erstellen Sie in Kotlin jetzt eine objectund fügen Sie dieses Feld in die ein object.
Interoperabilität mit Java:
Da Kotlin zu 100 % mit Java interoperabel ist, möchten Sie manchmal bestimmte APIs oder Felder auf eine Weise verfügbar machen, die für Java besser lesbar ist. Dazu können Sie die verwenden @JvmStatic Anmerkung. Durch Kommentieren eines Feldes oder einer Funktion in einer object mit @JvmStaticwird es in statische Felder kompiliert, die Java einfacher verwenden kann.
Begleitobjekte:
Eine letzte erwähnenswerte Sache ist companion objects. In Java haben Sie normalerweise Klassen mit statischem Inhalt, aber auch mit nicht statischem / Instanzinhalt. Kotlin ermöglicht es Ihnen, etwas Ähnliches mit Begleitobjekten zu tun, die sind objectist an a gebunden classwas bedeutet, dass eine Klasse auf die privaten Funktionen und Eigenschaften ihres Begleitobjekts zugreifen kann:
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)
}
}
Schöne Erklärung. Danke vielmals.
– Dänische Ansari
1. August 2019 um 5:28 Uhr
Ja, deshalb wird ein “Begleitobjekt” innerhalb einer Klasse als “Objekt” bezeichnet. Es ist eigentlich ein Singleton innerhalb einer Klasse.
– StdFisch
1. Juni 2021 um 15:02 Uhr
Überschrift
Ein Kotlin-Objekt ist wie eine Klasse, die nicht instanziiert werden kann, also muss es beim Namen aufgerufen werden. (per se eine statische Klasse)
Der Android-Konverter sah, dass Ihre Klasse nur eine statische Methode enthielt, und konvertierte sie daher in ein Kotlin-Objekt.
Unterschiedlich zwischen: Objekt || Klasse || Begleitobjekt || Datenklasse
1.Objekt
Eine Objektdeklaration wird träge initialisiert, wenn zum ersten Mal darauf zugegriffen wird.
Das Objekt verhält sich wie eine Singleton-Klasse
Nur eine Referenz für die gesamte App
Greifen Sie auf Mitglieder und Methoden zu, ohne eine Instanz zu erstellen
2.Klasse
Sie können mehrere Referenzen erstellen
Es muss eine Instanz für Zugriffsmitglieder und Methoden erstellt werden
3. Begleitobjekt
Ein Begleitobjekt wird initialisiert, wenn die entsprechende Klasse geladen wird
Im object MyClass{} Standardmäßig haben ganze Variablen eine einzige Referenz, aber in companion object Sie haben die Wahl, eine statische Methode oder eine statische Variable zu erstellen
Sie können eine Singleton-Klasse erstellen
4. Datenklasse
Klassen, die zum Halten von Daten/Status verwendet werden
Kotlins Datenklassen müssen Sie nicht den ganzen langwierigen Boilerplate-Code selbst schreiben/generieren
Der Compiler generiert automatisch einen Standard-Getter und -Setter für alle änderbaren Eigenschaften
Der Compiler leitet automatisch die Implementierung von Standardmethoden wie z equals(), hashCode() und toString()
Beispiele
//---------------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)
Ein Objekt ist ein Singleton. Sie müssen keine Instanz erstellen, um sie zu verwenden.
Eine Klasse muss instanziiert werden, um verwendet zu werden
So wie Sie in Java Math.sqrt(2) sagen können und keine Math-Instanz erstellen müssen, um sqrt zu verwenden, können Sie in Kotlin ein Objekt erstellen, das diese Methoden enthält, und sie sind effektiv statisch.
Der folgende Code zeigt den grundlegenden Unterschied zwischen einer Klasse und einem Objekt, wenn es um Kotlin geht:
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.
}
13350300cookie-checkUnterschied zwischen einer Klasse und einem Objekt in Kotlinyes
