Le livre «Head First. Kotlin »

Salut, habrozhiteli! Nous avons un livre publié pour étudier Kotlin en utilisant la technique Head First, qui va au-delà de la syntaxe et des instructions pour résoudre des problèmes spécifiques. Ce livre vous donnera tout ce dont vous avez besoin - des bases du langage aux méthodes avancées. Et vous pouvez pratiquer la programmation orientée objet et fonctionnelle.

Un extrait "Data Classes" est présenté sous la coupe.

Travailler avec des données

Personne ne veut perdre de temps et refaire ce qui a déjà été fait. La plupart des applications utilisent des classes pour stocker des données. Pour simplifier le travail, les créateurs de Kotlin ont proposé le concept d'une classe de données. Dans ce chapitre, vous apprendrez comment les classes de données vous aident à écrire du code plus élégant et concis dont vous ne pouviez que rêver auparavant. Nous allons examiner les fonctions d'assistance des classes de données et apprendre à décomposer un objet de données en composants. Dans le même temps, nous vous expliquerons comment les valeurs des paramètres par défaut rendent le code plus flexible et vous présenterons également Any, l'ancêtre de toutes les superclasses.

L'opérateur == appelle une fonction appelée égal

Comme vous le savez déjà, l'opérateur == peut être utilisé pour vérifier l'égalité. Chaque fois que l'instruction == est exécutée, une fonction appelée égal est appelée. Chaque objet contient une fonction égale et l'implémentation de cette fonction détermine le comportement de l'opérateur ==.

Par défaut, la fonction égal pour vérifier l'égalité vérifie si deux variables font référence au même objet.

Pour comprendre comment cela fonctionne, imaginez deux variables Wolf nommées w1 et w2. Si w1 et w2 contiennent des références à un objet Wolf, lors de leur comparaison avec l'opérateur ==, le résultat est vrai:


Mais si w1 et w2 contiennent des références à des objets Wolf différents, leur comparaison avec l'opérateur == donne le résultat faux, même si les objets contiennent les mêmes valeurs de propriété.


Comme mentionné précédemment, la fonction equals est automatiquement incluse dans chaque objet que vous créez. Mais d'où vient cette fonction?

est égal à hérite de la superclasse Any

Chaque objet contient une fonction appelée égal car sa classe hérite d'une fonction d'une classe nommée Any. La classe Any est l'ancêtre de toutes les classes: la superclasse résultante de tout. Chaque classe que vous définissez est une sous-classe de Any, et vous n'avez pas besoin de le signaler dans le programme. Ainsi, si vous écrivez un code de classe appelé myClass, qui ressemble à ceci:

class MyClass { ... } 

Le compilateur le convertira automatiquement au format suivant:

Chaque classe est une sous-classe de Any et hérite de son comportement. Chaque classe est une sous-classe de Any, et vous n'avez pas à le signaler dans le programme.

L'importance de tout héritage

Inclure Any en tant que superclasse résultante présente deux avantages importants:

• Il garantit que chaque classe hérite d'un comportement commun. La classe Any définit un comportement important dont dépend le fonctionnement du système. Et puisque chaque classe est une sous-classe de Any, ce comportement est hérité par tous les objets que vous créez. Ainsi, la classe Any définit une fonction appelée égal, et par conséquent, cette fonction est automatiquement héritée par tous les objets.
• Cela signifie que le polymorphisme peut être utilisé avec n'importe quel objet. Chaque classe est une sous-classe de Any, donc tout objet que vous créez a la classe Any comme super-type final. Cela signifie que vous pouvez créer une fonction avec des paramètres Any ou un type de retour Any qui fonctionnera avec des objets de tout type. Cela signifie également que vous pouvez créer des tableaux polymorphes pour stocker des objets de tout type avec du code de la forme suivante:

 val myArray = arrayOf(Car(), Guitar(), Giraffe()) 

Le compilateur remarque que chaque objet du tableau a un prototype commun de Any et crée donc un tableau de type Array.

Le comportement général hérité de la classe Any mérite un examen plus approfondi.

Comportement commun hérité de Any

La classe Any définit plusieurs fonctions héritées par chaque classe. Voici des exemples de fonctions de base et de leur comportement:

• égal (tout: Tout): booléen
  Vérifie si deux objets sont considérés comme «égaux». Par défaut, la fonction renvoie true si elle est utilisée pour vérifier un objet, ou false - pour différents objets. Dans les coulisses, la fonction d'égalité est appelée chaque fois que l'opérateur == est utilisé dans le programme.

 val w1 = Wolf() val w1 = Wolf() val w2 = Wolf() val w2 = w1 println(w1.equals(w2)) println(w1.equals(w2)) false (equals  false, true (equals  true,   w1  w2   w1  w2        .)      —   ,   w1 == w2. 

• hashCode (): Int
  Renvoie un code de hachage pour un objet. Les codes de hachage sont souvent utilisés par certaines structures de données pour stocker et récupérer efficacement les valeurs.

 val w = Wolf() println(w.hashCode()) 

523429237 (valeur du code de hachage w)

• toString (): String
  Renvoie un message String représentant l'objet. Par défaut, le message contient le nom de la classe et un numéro, ce qui ne nous intéresse généralement pas.

 val w = Wolf() println(w.toString()) 

Wolf @ 1f32e575

Par défaut, la fonction equals vérifie si deux objets sont le même objet réel.

La fonction equals détermine le comportement de l'opérateur ==.

La classe Any fournit une implémentation par défaut pour toutes les fonctions répertoriées, et ces implémentations sont héritées par toutes les classes. Cependant, vous pouvez remplacer ces implémentations pour modifier le comportement par défaut de toutes les fonctions répertoriées.

Vérification simple de l'équivalence de deux objets

Dans certaines situations, vous devez modifier l'implémentation de la fonction equals pour modifier le comportement de l'opérateur ==.

Supposons que vous ayez une classe de recette qui vous permet de créer des objets pour stocker des recettes. Dans une telle situation, vous considérerez probablement deux objets Recette égaux (ou équivalents) s'ils contiennent une description de la même recette. Disons que la classe Recipe est définie avec deux propriétés - title et isVegetarian:

 class Recipe(val title: String, val isVegetarian: Boolean) { } 

L'opérateur == retournera true s'il est utilisé pour comparer deux objets Recipe avec les mêmes propriétés, title et isVegetarian:

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) 

Bien que vous puissiez changer le comportement de l'opérateur == en écrivant du code supplémentaire pour remplacer la fonction equals, les développeurs de Kotlin ont fourni une solution plus pratique: ils ont créé le concept d'une classe de données. Voyons ce que sont ces classes et comment elles sont créées.

La classe de données vous permet de créer des objets de données.

Une classe de données est une classe de création d'objets pour le stockage de données. Il comprend des outils utiles pour travailler avec des données - par exemple, une nouvelle implémentation de la fonction equals, qui vérifie si deux objets de données contiennent les mêmes valeurs de propriété. Si deux objets contiennent les mêmes données, ils peuvent être considérés comme égaux.

Pour définir une classe de données, faites précéder la définition de données habituelle avec le mot-clé data. Le code suivant convertit la classe de recette créée précédemment en une classe de données:

 data class Recipe(val title: String, val isVegetarian: Boolean) { } 

Le préfixe de données convertit une classe régulière en classe de données.

Comment créer des objets basés sur une classe de données

Les objets de classe de données sont créés de la même manière que les objets de classe standard: en appelant le constructeur de cette classe. Par exemple, le code suivant crée un nouvel objet de données de recette et l'affecte à une nouvelle variable nommée r1:

 val r1 = Recipe("Chicken Bhuna", false) 

Les classes de données remplacent automatiquement leurs fonctions égales pour modifier le comportement de l'opérateur == afin que l'égalité des objets soit vérifiée en fonction des valeurs de propriété de chaque objet. Si, par exemple, vous créez deux objets Recette avec les mêmes valeurs de propriété, la comparaison des deux objets avec l'opérateur == donnera le résultat vrai, car les mêmes données y sont stockées:

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) //r1 == r2  true 

r1 et r2 sont considérés comme «égaux» car deux objets Recette contiennent les mêmes données.

En plus de la nouvelle implémentation de la fonction equals héritée de la superclasse Any, les classes de données
remplacer également les fonctions hashCode et toString. Voyons comment ces fonctions sont implémentées.

Les objets de classe redéfinissent leur comportement hérité

Pour travailler avec des données, une classe de données a besoin d'objets, elle fournit donc automatiquement les implémentations suivantes pour les fonctions equals, hashCode et toString héritées de la superclasse Any:

La fonction equals compare les valeurs des propriétés

Lors de la définition d'une classe de données, sa fonction égale (et donc l'opérateur ==) renvoie toujours true si les liens pointent vers le même objet. Mais elle renvoie également true si les objets ont les mêmes valeurs de propriété définies dans le constructeur:

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) println(r1.equals(r2)) true 

Les objets de données sont considérés comme égaux si leurs propriétés contiennent la même valeur.

Pour des objets égaux, les mêmes valeurs hashCode sont retournées

Si deux objets de données sont considérés comme égaux (en d'autres termes, ils ont les mêmes valeurs de propriété), la fonction hashCode renvoie la même valeur pour ces objets:

 val r1 = Recipe("Chicken Bhuna", false) val r2 = Recipe("Chicken Bhuna", false) println(r1.hashCode()) println(r2.hashCode()) 

241131113
241131113

toString renvoie les valeurs de toutes les propriétés

Enfin, la fonction toString ne renvoie plus le nom de la classe, suivi d'un nombre, mais renvoie une chaîne utile avec les valeurs de toutes les propriétés définies dans le constructeur de la classe de données:

 val r1 = Recipe("Chicken Bhuna", false) println(r1.toString()) Recipe(title=Chicken Bhuna, isVegetarian=false) 

En plus de remplacer les fonctions héritées de la superclasse Any, la classe de données fournit également des outils supplémentaires qui permettent un travail plus efficace avec les données, par exemple, la possibilité de copier des objets de données. Voyons comment fonctionnent ces outils.

Copie d'objets de données avec la fonction de copie

Si vous devez créer une copie de l'objet de données en modifiant certaines de ses propriétés, mais en laissant les autres propriétés dans leur état d'origine, utilisez la fonction de copie. Pour ce faire, la fonction est appelée pour l'objet que vous souhaitez copier et les noms de toutes les propriétés modifiables avec de nouvelles valeurs lui sont transmis.

Supposons que vous ayez un objet Recipe nommé r1, qui est défini dans le code comme ceci:

 val r1 = Recipe("Thai Curry", false) 

Si vous souhaitez créer une copie de l'objet Recipe, en remplaçant la valeur de la propriété isVegetarian par true, cela se fait comme suit:


Essentiellement, cela signifie «créer une copie de l'objet r1, changer la valeur de sa propriété isVegetarian sur true et affecter un nouvel objet à une variable nommée r2». Cela crée une nouvelle copie de l'objet et l'objet d'origine reste inchangé.

En plus de la fonction de copie, les classes de données fournissent également un ensemble de fonctions pour diviser un objet de données en un ensemble de valeurs de ses propriétés - ce processus est appelé déstructuration. Voyons comment cela se fait.

Les classes de données définissent les fonctions componentN ...

Lors de la définition d'une classe de données, le compilateur ajoute automatiquement à la classe un ensemble de fonctions qui peuvent être utilisées comme mécanisme alternatif pour accéder aux valeurs des propriétés des objets. Ces fonctions sont connues sous le nom général des fonctions componentN, où N est le nombre de propriétés à récupérer (dans l'ordre de déclaration).

Pour voir comment fonctionnent les fonctions componentN, supposons que vous ayez l'objet Recipe suivant:

 val r = Recipe("Chicken Bhuna", false) 

Si vous souhaitez obtenir la valeur de la première propriété de l'objet (propriété title), vous pouvez appeler la fonction component1 () de l'objet pour cela:

 val title = r.component1() 

component1 () renvoie la référence contenue dans la première propriété définie dans le constructeur de la classe de données.

La fonction fait la même chose que le code suivant:

 val title = r.title 

Le code avec la fonction est plus universel. Pourquoi les fonctions ComponentN sont-elles si utiles dans les classes de données?

... conçu pour restructurer les objets de données

Les fonctions génériques de componentN sont utiles principalement parce qu'elles fournissent un moyen simple et pratique de diviser un objet de données en valeurs de propriété ou de le détruire.

Supposons que vous souhaitiez prendre les valeurs des propriétés d'un objet Recette et affecter la valeur de chacune de ses propriétés à une variable distincte. Au lieu de code

 val title = r.title val vegetarian = r.isVegetarian 

avec le traitement séquentiel de chaque propriété, vous pouvez utiliser le code suivant:

 val (title, vegetarian) = r 

Attribue un titre à la première propriété r et végétarien à la deuxième propriété.

Ce code signifie "créer deux variables, titre et végétarien, et attribuer la valeur de l'une des r propriétés de chaque variable." Il fait la même chose que le prochain fragment

 val title = r.component1() val vegetarian = r.component2() 

mais il s'avère plus compact.

L'opérateur === vérifie toujours si deux variables se réfèrent au même objet.

Si vous souhaitez vérifier si deux variables font référence au même objet quel que soit leur type, utilisez l'opérateur === au lieu de ==. L'opérateur === donne le résultat vrai si (et seulement si) lorsque deux variables contiennent une référence à un objet réel. Si vous avez deux variables, x et y, et l'expression suivante:

 x === y 

donne le résultat vrai, alors vous savez que les variables x et y doivent faire référence au même objet.

Contrairement à l'opérateur ==, le comportement de l'opérateur === est indépendant de la fonction égal. L'opérateur === se comporte toujours de la même manière quel que soit le type de classe.

Maintenant que vous avez appris à créer et à utiliser des classes de données, créez un projet pour le code de recette.

Création d'un projet de recettes

Créez un nouveau projet Kotlin pour la JVM et nommez-le «Recettes». Ensuite, créez un nouveau
Fichier Kotlin nommé Recipes.kt: sélectionnez le dossier src, ouvrez le menu Fichier et sélectionnez la commande
Nouveau → Fichier / classe Kotlin. Saisissez le nom de fichier «Recettes» et sélectionnez l'option Fichier dans le groupe Type.

Nous ajoutons une nouvelle classe de données au projet appelé Recette et créons des objets de données Recette. Voici le code. Mettez à jour votre version de Recipes.kt et alignez-la avec la nôtre:

 data class Recipe(val title: String, val isVegetarian: Boolean) (  {} ,        .) fun main(args: Array<String>) { val r1 = Recipe("Thai Curry", false) val r2 = Recipe("Thai Curry", false) val r3 = r1.copy(title = "Chicken Bhuna") (  r1    title) println("r1 hash code: ${r1.hashCode()}") println("r2 hash code: ${r2.hashCode()}") println("r3 hash code: ${r3.hashCode()}") println("r1 toString: ${r1.toString()}") println("r1 == r2? ${r1 == r2}") println("r1 === r2? ${r1 === r2}") println("r1 == r3? ${r1 == r3}") val (title, vegetarian) = r1 ( r1) println("title is $title and vegetarian is $vegetarian") } 

Lorsque vous exécutez votre code, le texte suivant apparaît dans la fenêtre de sortie de l'EDI:

 r1 hash code: -135497891 r2 hash code: -135497891 r3 hash code: 241131113 r1 toString: Recipe(title=Thai Curry, isVegetarian=false) r1 == r2? true r1 === r2? false r1 == r3? false title is Thai Curry and vegetarian is false 

»Plus d'informations sur le livre sont disponibles sur le site Web de l'éditeur
» Contenu
» Extrait

25% de réduction sur le coupon pour Khabrozhitel - Kotlin

Lors du paiement de la version papier du livre, un livre électronique est envoyé par e-mail.