Quelle est la différence entre un objet et une classe de données dans Kotlin?

object

object est la manière de Kotlin de créer un singleton (une classe d'instance) qui est instancié par le compilateur.

data class

Une classe de données est comme une classe habituelle mais avec quelques avantages / restrictions ( Source ).

Avantages

• equals() / hashCode()
• toString()
• componentN()
• copy()

Ceux-ci sont créés à partir des propriétés spécifiées dans le constructeur principal.

Restrictions

• Le constructeur principal doit avoir au moins un paramètre;
• Tous les paramètres du constructeur principal doivent être marqués comme val ou var;
• ne peut être abstrait, ouvert, scellé ou intérieur;
• (avant 1.1) ne peut implémenter que des interfaces.

L' object de Kotlin est similaire à une classe en Java, où toutes les méthodes et variables sont statiques.

class User {
    public final String name;
    public final String age;

    public User(String name, String age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object other) {
        //Kotlin-generated equality check
    }

    @Override
    public long hashCode() {
        //Kotlin's hashcode
    }

    @Override 
    public String toString() {
        return "User(name=" + name + ",age=" + age + ")";
    }

    //other generated methods
}

dans Kotlin est similaire à ce qui suit en Java:

data class User(val name: String, val age: String)

Exemple d'utilisation:

//Kotlin
User.printName(User.name)

//Java
User.printName(User.name);

Un object n'est cependant pas exactement le même que la comparaison Java que j'ai donnée. Il peut hériter d'interfaces et de classes, et l'objet lui-même est instancié en tant qu'instance singleton. Si vous @JvmStatic méthodes à l'intérieur d'un objet avec @JvmStatic , elles deviendront de véritables membres statiques.

L'objet de Kotlin

La classe de data dans Kotlin est juste une syntaxe plus simple pour une classe qui n'a pas de logique (ou minimale) et contient certaines valeurs. Kotlin génère pour vous les fonctions equals() , hashCode() et toString() dans une classe de données, ainsi que d'autres fonctions d'assistance.

class User {
    public static String name = "";
    public static String printName(name: String) {
        return "Hello " + name + "!";
    }
}

dans Kotlin ressemblera à quelque chose comme ceci en Java:

object User {
    val name = ""
    fun printName(name: String) = "Hello, $name!"
}

Documentation sur les classes de données de Kotlin

En bref, object est utilisé, si vous voulez créer un singleton, un objet unique pour la classe et la classe de données est une classe qui a equals , hashCode , toString généré automatiquement.

Premièrement, il n'y a pas de classe d'objets , la fonctionnalité à laquelle vous faites référence est appelée déclaration d'objet .

Déclaration d'objet

C'est une fonctionnalité de Kotlin qui vous permet d'implémenter un singleton . La déclaration d'objet combine une déclaration de classe et une déclaration d'une seule instance de la classe dans une seule instruction.

class PersonClass(val name: String, val age: Int) // regular class
data class PersonDataClass(val name: String, val age: Int) // data class

Tout comme une classe, une déclaration d'objet peut contenir des déclarations de propriétés, de méthodes, de blocs d'initialisation, etc. La seule chose qui leur est interdite sont les constructeurs (primaires ou secondaires).

Les déclarations d'objets sont créées immédiatement au point de la définition, et non par des appels de constructeur à partir d'autres endroits du code.

Remarque: le mot-clé object peut également être utilisé pour les objets compagnons et les expressions d'objets .

Classe de données

Il est très courant de créer des classes dont l'objectif principal est de contenir des données. Si vous voulez que votre classe soit un support pratique pour vos données, vous devez remplacer les méthodes d'objet universel:

• toString() - représentation sous forme de chaîne
• equals() - égalité d'objet
• hashCode() - conteneurs de hachage

Cependant, en ajoutant les données de modificateur à votre classe, les méthodes nécessaires sont automatiquement ajoutées pour vous. De plus, les méthodes suivantes sont également générées:

• componentN() correspondant aux propriétés dans leur ordre de déclaration
• copy()

// Let's assume that class Person is defined somewhere else
object Payroll {
    val employees = arrayListOf<Person>()

    fun calculateSalary() {
        for (person in employees) {
            // ...
        }
    }
}

// calling methods and properties
>>> Payroll.employees.add(Person("John", 23)) // calling a property
>>> Payroll.calculateSalary() // calling a method

En résumé, si vous avez besoin d'un conteneur pour les données, vous devez utiliser une classe de données, ce qui signifie ajouter les données du modificateur à votre classe. Cela générera les méthodes suivantes pour vous: toString() , equals() , hashCode() , componentN() et copy() , vous évitant ainsi d'écrire du code standard. D'un autre côté, si vous devez créer un singleton, vous utilisez la fonction de déclaration d'objet.