Share
Kotlin est un langage de programmation moderne qui compile en bytecode Java. C'est gratuit et open source, et promet de rendre le codage pour Android encore plus amusant.
Dans l'article précédent, vous avez appris les utilisations avancées de fonctions telles que les fonctions d'extension, les fermetures, les fonctions d'ordre supérieur et les fonctions en ligne dans Kotlin..
Dans cet article, vous aurez une introduction à la programmation orientée objet dans Kotlin en apprenant les classes: constructeurs et propriétés, transtypage et autres fonctionnalités avancées que Kotlin facilite..
Une classe est une unité de programme qui regroupe des fonctions et des données pour effectuer certaines tâches connexes. Nous déclarons une classe à Kotlin en utilisant le classe mot clé similaire à Java.
livre de classe
Le code précédent est la déclaration de classe la plus simple. Nous venons de créer une classe vide appelée Livre. Nous pouvons toujours instancier cette classe même si elle ne contient pas de corps utilisant son constructeur par défaut.
val book = livre ()
Comme vous pouvez le constater dans le code ci-dessus, nous n’avons pas utilisé le Nouveau mot clé pour instancier cette classe, comme d'habitude dans d'autres langages de programmation. Nouveau n'est pas un mot clé en kotlin. Cela rend notre code source concis lors de la création d'une instance de classe. Mais sachez que l’instanciation d’une classe Kotlin en Java nécessitera la Nouveau mot-clé.
// Dans un fichier Java Book book = new Book ()
Voyons comment ajouter un constructeur et des propriétés à notre classe. Mais tout d’abord, voyons une classe typique en Java:
/ * Java * / public class Book private String title; private Long isbn; livre public (Titre de chaîne, Long isbn) this.title = title; this.isbn = isbn; public String getTitle () return title; public void setTitle (Titre de la chaîne) this.title = title; public Long getIsbn () return isbn; public void setIsbn (Long isbn) this.isbn = isbn;
En regardant notre Livre classe de modèle ci-dessus, nous avons les éléments suivants:
Accentsconagua
Titre et isbn Voyons maintenant comment écrire le code précédent dans Kotlin à la place:
/ * Kotlin * / class Livre var titre: String var isbn: Constructeur long (titre: String, isbn: Long) this.title = titre this.isbn = isbn
Une jolie classe bien rangée! Nous avons maintenant réduit le nombre de lignes de code de 20 à 9 seulement. constructeur() la fonction s'appelle un constructeur secondaire à Kotlin. Ce constructeur est équivalent au constructeur Java que nous avons appelé lors de l'instanciation d'une classe..
Dans Kotlin, il n’existe pas de concept de domaine comme vous le savez peut-être; au lieu de cela, il utilise le concept de "propriétés". Par exemple, nous avons deux propriétés mutables (lecture-écriture) déclarées avec le var mot-clé: Titre et isbn dans le Livre classe. (Si vous avez besoin d'un rappel sur les variables de Kotlin, veuillez visiter le premier article de cette série: Variables, Types de base et Tableaux).
Une chose étonnante est que les getters et les setters de ces propriétés sont générés automatiquement par le compilateur Kotlin. Notez que nous n’avons spécifié aucun modificateur de visibilité pour ces propriétés; elles sont donc publiques par défaut. En d'autres termes, ils peuvent être accessibles de n'importe où.
Regardons une autre version de la même classe dans Kotlin:
class Book constructeur (titre: String, isbn: Long) var titre: String var isbn: Long init this.title = titre this.isbn = isbn
Dans ce code, nous avons supprimé le constructeur secondaire. Au lieu de cela, nous avons déclaré un constructeur dans l’en-tête de classe appelé constructeur primaire. Un constructeur primaire n’a pas d’endroit pour mettre un bloc de code, nous utilisons donc le init modificateur pour initialiser les paramètres entrants du constructeur principal. Notez que le init le bloc de code est exécuté immédiatement lorsque l'instance de classe est créée.
Comme vous pouvez le constater, notre code comporte encore beaucoup de passe-partout. Réduisons-le davantage:
class Book constructeur (titre de la var: String, var isbn: Long)
Notre Livre la classe est maintenant juste une ligne de code. C'est vraiment cool! Notez que dans la liste des paramètres du constructeur principal, nous avons défini nos propriétés mutables: Titre et isbn directement à l'intérieur du constructeur principal avec le var mot-clé.
Nous pouvons également ajouter des valeurs par défaut à l'une des propriétés de la classe directement à l'intérieur du constructeur..
Constructeur de class book (var title: String = "valeur par défaut", var isbn: Long)
En fait, nous pouvons aussi omettre le constructeur mot-clé, mais seulement s'il n'a pas de modificateur de visibilité (Publique, privé, ou protégé) ou des annotations.
class Book (titre de la var: String = "valeur par défaut", var isbn: Long)
Une classe très soignée, je dois dire!
Nous pouvons maintenant créer une instance de classe comme ceci:
val book = Book ("Un chant de glace et de feu", 9780007477159) val book2 = Book (1234) // utilise la valeur par défaut de la propriété titleEn Kotlin, nous pouvons obtenir une propriété par l'objet de classe livre, suivi d'un séparateur de points ., puis le nom de la propriété Titre. Ce style concis d'accès aux propriétés s'appelle syntaxe d'accès à la propriété. En d'autres termes, nous n'avons pas besoin d'appeler la méthode getter de la propriété pour accéder ni d'appeler le configurateur pour définir une propriété dans Kotlin, comme nous le faisons en Java..
println (book.title) // "Un chant de glace et de feu"
Parce que le isbn la propriété est déclarée avec le var mot-clé (lecture-écriture), nous pouvons également modifier la valeur de la propriété à l'aide de l'opérateur d'affectation =.
book.isbn = 1234 println (book.isbn) // 1234
Voyons un autre exemple:
class Book (titre var: String, val isbn: Long) val book = Livre ("Un chant de glace et de feu", 9780007477159) book.isbn = 1234 // erreur: propriété en lecture book.title = "Les choses se sont effondrées "// titre réaffecté avec valeurIci, nous avons mis à jour le isbn paramètre doit être immuable (lecture seule) à la place en utilisant le val mot-clé. Nous avons instancié une instance de classe livre et réaffecté le Titre propriété la valeur "Things Fall Apart". Notez que lorsque nous avons essayé de réaffecter le isbn valeur de la propriété à 1234, le compilateur s'est plaint. En effet, la propriété est immuable, ayant été définie avec le paramètre val mot-clé.
Sachez qu’en déclarant un paramètre avec le var modificateur dans le constructeur principal, le compilateur Kotlin (dans les coulisses) nous a aidés à générer à la fois les accesseurs de propriétés: getter et setter. Si tu utilises val, il ne générera que le getter.
/ * Kotlin * / class Book (titre var: String, val isbn: Long)
Cela signifie que les appelants Java peuvent simplement obtenir ou définir le champ de propriété en appelant respectivement la méthode setter ou la méthode getter de la propriété. Rappelez-vous, cela dépend du modificateur utilisé pour définir la propriété Kotlin: var ou val.
/ * Java * / Livre = nouveau livre ("Un chant de glace et de feu", 9780385474542) println (book.getTitle ()) // "Un chant de glace et de feu" book.setTitle ("Les choses tombent en ruines") // définit une nouvelle valeur println (book.getTitle ()) // "Les choses se défont" book.getIsbn () // 9780385474542 book.setIsbn (4545454) // ne compile pasDans cette section, je vais vous montrer comment créer des accesseurs personnalisés (getters et setters) pour une propriété située à Kotlin si vous le souhaitez. La création d'un configurateur personnalisé peut être utile si vous souhaitez valider ou vérifier une valeur avant qu'elle ne soit définie sur une propriété de classe. Et un getter de propriété personnalisé peut être utile lorsque vous souhaitez modifier ou modifier la valeur qui doit être renvoyée..
Parce que nous voulons créer notre propre getter ou setter personnalisé pour une propriété, nous devons définir cette propriété dans le corps de la classe plutôt que dans l'en-tête du constructeur..
class Book (val isbn: Long) var title = "valeur par défaut"
C'est pourquoi nous avons déplacé le mutable (lecture-écriture) Titre propriété dans le corps de la classe et lui a donné une valeur par défaut (sinon elle ne compilerait pas).
class Book (val isbn: Long) var title = "valeur par défaut" set (valeur) if (! value.isNotEmpty ()) renvoie IllegalArgumentException ("Le titre ne doit pas être vide") field = valueVous pouvez voir que nous avons défini notre propre méthode de définition set (valeur) pour le Titre juste en dessous de la définition de la propriété - notez que vous ne pouvez pas le modifier ensemble() signature de la méthode parce que c'est ce que le compilateur attend comme fonction de définition de propriété personnalisée.
Le paramètre valeur passé au ensemble method représente la valeur réelle attribuée à la propriété par les utilisateurs. Vous pouvez modifier le nom du paramètre si vous le souhaitez, mais valeur est de loin préféré. Nous avons validé le valeur en vérifiant si la valeur est vide. Si vide, arrêtez l'exécution et lancez une exception; sinon, réaffectez la valeur à un paramètre spécial. champ variable.
Cette spéciale champ champ variable à l'intérieur du ensemble method est un alias du champ de sauvegarde de la propriété. Un champ de sauvegarde est simplement un champ utilisé par les propriétés lorsque vous souhaitez modifier ou utiliser les données de ce champ. contrairement à valeur, vous ne pouvez pas renommer cette spéciale champ variable.
Il est très facile de créer un getter personnalisé pour une propriété à Kotlin.
class Book (val isbn: Long) var title = "valeur par défaut" //… méthode set get () return field.toUpperCase ()
À l'intérieur de obtenir méthode, nous retournons simplement un modifié champ-dans notre cas, nous avons retourné le titre du livre en majuscule.
val book = Book (9780007477159) book.title = "Un chant de glace et de feu" println (book.title) // "Un chant de glace et de feu" println (book.isbn) // 9780007477159
Notez que chaque fois que nous définissons une valeur sur Titre propriété, ses ensemble le bloc de méthode est exécuté - il en va de même pour le obtenir méthode à chaque fois que nous le récupérons.
Si vous souhaitez en savoir plus sur les fonctions membres d'une classe Kotlin (type de fonction définie dans une classe, un objet ou une interface), visitez l'article Plus amusant avec des fonctions de cette série..
Comme je l'ai mentionné précédemment, nous avons deux types de constructeurs dans Kotlin: primaire et secondaire. Nous avons la liberté de combiner les deux en une seule classe, comme vous pouvez le voir dans l'exemple ci-dessous:
class Car (nom de la valeur: String, val numéro de la plaque: String) var nouveau: Boolean = constructeur vrai (nom: String, plateNo: String, nouveau: Boolean): this (nom, numéro de la plaque) this.new = new
Notez que nous ne pouvons pas déclarer les propriétés à l'intérieur d'un constructeur secondaire, comme nous l'avons fait pour le constructeur principal. Si nous voulons faire cela, nous devons le déclarer à l'intérieur du corps de la classe, puis l'initialiser dans le constructeur secondaire..
Dans le code ci-dessus, nous définissons la valeur par défaut du Nouveau propriété pour la classe Voiture (rappelles toi, Nouveau n’est pas un mot-clé dans Kotlin) -nous pouvons ensuite utiliser le constructeur secondaire pour le changer si nous le souhaitons. En Kotlin, chaque constructeur secondaire doit appeler le constructeur principal ou un autre constructeur secondaire qui appelle le constructeur principal. Nous utilisons le ce mot clé pour y parvenir.
Notez également que nous pouvons avoir plusieurs constructeurs secondaires dans une classe.
class Car (nom de la chaîne: String, plaque plateNo: String) var nouveau: Boolean? = null var color: String = "" constructeur (nom: String, plateNo: String, nouveau: Booléen): this (nom, plaqueNo) this.new = nouveau constructeur (nom: String, plaqueNo: String, nouveau: Booléen , color: String): this (nom, plaqueNo, nouvelle) this.colour = color
Si une classe étend une super-classe, alors nous pouvons utiliser le super mot clé (similaire à Java) pour appeler le constructeur de la superclasse (nous discuterons de l'héritage dans Kotlin dans un prochain article).
// appelle directement le constructeur principal val car1 = Car ("Peugeot 504", "XYZ234") // appelle directement la 1ère sec. constructeur val car2 = Voiture ("Peugeot 504", "XYZ234", false) // appelle directement la dernière sec. constructeur val car3 = Voiture ("Peugeot 504", "XYZ234", faux, "gris") Comme je l’ai dit plus tôt, pour inclure explicitement un modificateur de visibilité à un constructeur dans une classe, nous devons inclure le constructeur mot-clé-par défaut, les constructeurs sont publics.
classe Car private constructeur (nom de la valeur: String, valeur de la plaqueNom: String) //…
Ici, nous avons rendu le constructeur privé. Cela signifie que les utilisateurs ne peuvent pas instancier un objet à l'aide de son constructeur directement. Cela peut être utile si vous souhaitez que les utilisateurs appellent une autre méthode (une méthode fabrique) pour créer indirectement des objets..
En Kotlin, le type le plus haut dans la hiérarchie des types est appelé Tout. Ceci est équivalent à Java Objet type. Cela signifie que toutes les classes de Kotlin héritent explicitement de la Tout type, y compris Chaîne, Int, Double, etc. le Tout type contient trois méthodes: équivaut à, toString, et hashcode.
Nous pouvons également utiliser le Rien class in Kotlin in fonctions qui retournent toujours une exception, autrement dit, pour les fonctions qui ne se terminent pas normalement. Quand une fonction revient Rien, alors nous savons qu'il va lancer une exception. Aucun type équivalent de ce type n'existe en Java.
fun throwException (): Nothing throw Exception ("Message d'exception)Cela peut s'avérer utile lorsque vous testez le comportement de gestion des erreurs dans vos tests unitaires..
Les modificateurs de visibilité nous aident à limiter l'accessibilité de notre API au public. Nous pouvons fournir différents modificateurs de visibilité à nos classes, interfaces, objets, méthodes ou propriétés. Kotlin nous fournit quatre modificateurs de visibilité:
C'est la valeur par défaut, et n'importe quelle classe, fonction, propriété, interface ou objet ayant ce modificateur est accessible de n'importe où..
Une fonction, une interface ou une classe de niveau supérieur déclarée comme privé peut être consulté que dans le même fichier.
Toute fonction ou propriété déclarée privé à l'intérieur d'une classe, d'un objet ou d'une interface ne peut être visible que par les autres membres de cette classe, de cet objet ou de cette interface.
compte de classe montant de la valeur privée: double = 0,0
le protégé Le modificateur ne peut être appliqué qu'aux propriétés ou fonctions d'une classe, d'un objet ou d'une interface. Il ne peut pas être appliqué à des fonctions, des classes ou des interfaces de niveau supérieur. Les propriétés ou fonctions associées à ce modificateur ne sont accessibles que dans la classe qui le définit et dans toute sous-classe..
Dans un projet comportant un module (module Gradle ou Maven), une classe, un objet, une interface ou une fonction spécifiée avec le paramètre interne modificateur déclaré à l'intérieur de ce module est uniquement accessible à partir de ce module.
Compte de classe interne montant de la valeur: double = 0,0
Casting signifie prendre un objet d'un autre type et le convertir en un autre type d'objet. Par exemple, en Java, nous utilisons le exemple de opérateur pour déterminer si un type d'objet particulier est d'un autre type avant de le lancer.
/ * Java * / if (instance de forme de cercle) cercle de cercle = forme (cercle); circle.calCircumference (3.5);
Comme vous pouvez le constater, nous avons vérifié si forme l'instance est Cercle, et puis nous devons jeter explicitement le forme référence à un Cercle tapez afin que nous puissions appeler des méthodes du cercle type.
Une autre chose impressionnante à propos de Kotlin est l’intelligence de son compilateur en matière de casting. Voyons maintenant une version en Kotlin.
/ * Kotlin * / if (forme est Circle) shape.calCircumference (3.5)
Génial! Le compilateur est malin de savoir que le si le bloc ne sera exécuté que si le forme objet est une instance de Cercle-donc le mécanisme de casting est fait sous le capot pour nous. Nous pouvons maintenant appeler facilement des propriétés ou des fonctions du Cercle tapez à l'intérieur du si bloc.
if (forme est Circle && shape.hasRadius ()) println ("Le rayon du cercle est shape.radius")Ici, la dernière condition après la && dans le si en-tête ne sera appelé que lorsque la première condition est vrai. Si la forme n'est pas un Cercle, alors la dernière condition ne sera pas évaluée.
Nous pouvons utiliser le comme opérateur (ou casting dangereux opérateur) pour convertir explicitement une référence d'un type vers un autre type dans Kotlin.
val cercle = forme cercle cercle.calCirconférence (4)
Si l'opération de diffusion explicite est illégale, notez qu'un ClassCastException sera jeté. Pour éviter qu'une exception ne soit levée lors du lancement, nous pouvons utiliser le coulée sécuritaire opérateur (ou opérateur de distribution nullable) comme?.
val cercle: Cercle? = forme comme? Cercle
le comme? L’opérateur essaiera de lancer le type voulu et renvoie nul si la valeur ne peut pas être convertie au lieu de lancer une exception. N'oubliez pas qu'un mécanisme similaire a été présenté dans la section Nullabilité de Nullability, Loops, and Conditions post de cette série. Lire là-bas pour un recyclage.
Les objets dans Kotlin sont plus similaires aux objets JavaScript qu'aux objets Java. Notez qu'un objet dans Kotlin n'est pas une instance d'une classe spécifique!
Les objets sont très similaires aux classes. Voici certaines des caractéristiques des objets dans Kotlin:
init bloc.Voyons maintenant comment créer un objet.
objet Singleton fun myFunc (): Unit // faire quelque chose
Nous plaçons le objet mot-clé avant le nom de l'objet que nous voulons créer. En fait, nous créons des singletons lorsque nous créons des objets dans Kotlin en utilisant le objet Construire, car une seule instance d'un objet existe. Vous en apprendrez plus à ce sujet lorsque nous discuterons de l'interopérabilité des objets avec Java..
Un singleton est un modèle de conception logicielle qui garantit qu'une classe n'a qu'une instance et qu'un point d'accès global est fourni par cette classe. Chaque fois que plusieurs classes ou clients demandent la classe, ils obtiennent la même instance de la classe. Vous pouvez consulter mon article sur le motif singleton en Java pour en savoir plus.
Vous pouvez accéder à l'objet ou au singleton n'importe où dans votre projet, tant que vous importez son package..
Singleton.myFunc ()
Si vous êtes un codeur Java, voici comment nous créons généralement des singletons:
Classe publique Singleton privé statique Singleton INSTANCE = null; // d'autres variables d'instance peuvent être ici private Singleton () ; singleton public statique synchronisé getInstance () if (INSTANCE == null) INSTANCE = new Singleton (); return (INSTANCE); // d'autres méthodes d'instance peuvent suivre
Comme vous pouvez le voir, en utilisant le Kotlin objet construire rend concis et plus facile pour créer des singletons.
Les objets de Kotlin peuvent également être utilisés pour créer des constantes. Généralement en Java, nous créons des constantes dans une classe en en faisant un champ final statique public comme ceci:
public final class APIConstants public statique final String baseUrl = "http://www.myapi.com/"; APIConstants privé ()
Ce code en Java peut être converti en Kotlin plus succinctement comme ceci:
package, objet com.chike.kotlin.constants APIConstants val baseUrl: String = "http://www.myapi.com/"
Ici nous avons déclaré la constante APIConstants avec une propriété baseUrl dans un paquet com.chike.kotlin.constants. Sous le capot, un membre final statique privé Java baseUrl est créé pour nous et initialisé avec l'URL de chaîne.
Pour utiliser cette constante dans un autre package de Kotlin, importez-le simplement..
importer com.chike.kotlin.constants.APIConstants APIConstants.baseUrl
Kotlin convertit un objet en une classe Java finale sous le capot. Cette classe a un champ statique privé EXEMPLE qui contient une seule instance (un singleton) de la classe. Le code suivant montre comment les utilisateurs peuvent simplement appeler un objet Kotlin à partir de Java..
/ * Java * / Singleton.INSTANCE.myFunc ()
Ici, une classe Java appelée Singleton a été généré avec un membre final statique public EXEMPLE, y compris une fonction finale publique myFunc ().
Pour que la fonction ou la propriété de l’objet dans Kotlin soit un membre statique de la classe Java générée, nous utilisons @JvmStatic annotation. Voici comment l'utiliser:
objet Singleton @JvmStatic fun myFunc (): Unit // faire quelque chose
En appliquant le @JvmStatic annotation à myFunc (), le compilateur l'a transformé en une fonction statique.
Désormais, les appelants Java peuvent l'appeler comme un appel de membre statique normal. Notez qu'en utilisant le EXEMPLE champ statique pour appeler les membres fonctionnera toujours.
/ * Java * / Singleton.myFunc ()
Maintenant que nous avons compris quels objets se trouvent dans Kotlin, passons à un autre type d'objets appelés objets compagnons..
Comme Kotlin ne prend pas en charge les classes, méthodes ou propriétés statiques comme celles de Java, l’équipe de Kotlin nous a proposé une alternative plus puissante appelée objets de compagnie. Un objet compagnon est essentiellement un objet appartenant à une classe. Cette classe est appelée classe compagnon de l'objet. Cela signifie également que les caractéristiques que j'ai mentionnées pour les objets s'appliquent également aux objets compagnons.
Semblable aux méthodes statiques en Java, un objet compagnon n'est pas associé à une instance de classe, mais à la classe elle-même, par exemple, une méthode fabrique, qui a pour tâche de créer une instance de classe..
classe Person constructeur privé (var firstName: String, var lastName: String) objet compagnon fun create (prénom: String, lastName: String): Person = Person (prénom, lastName)
Ici, nous avons fait le constructeur privé-Cela signifie que les utilisateurs extérieurs à la classe ne peuvent pas créer directement d'instance. Dans notre bloc d'objet compagnon, nous avons une fonction créer(), qui crée un La personne objet et le renvoie.
un compagnon L'instanciation d'objet est paresseuse. En d'autres termes, il ne sera instancié que si cela est nécessaire pour la première fois. L'instanciation d'un un compagnon objet se produit quand une instance de la un compagnon la classe est créée ou la un compagnon les membres d'objet sont accédés.
Voyons comment appeler une fonction d'objet compagnon dans Kotlin.
val person = Person.create ("Cersei", "Lannister") println (person.firstName) // affiche "Cersei"Comme vous pouvez le constater, cela revient à invoquer une méthode statique en Java normalement. En d'autres termes, nous appelons simplement la classe, puis le membre. Notez qu'en dehors des fonctions, nous pouvons également avoir des propriétés dans notre objet compagnon.
classe Personne constructeur privé (var firstName: String, var lastName: String) init count ++ objet compagnon var count: Int = 0 fun create (prénom: String, lastName: chaîne): Person = Person (prénom, dernier nom) init println ("objet compagnon créé")Notez également que le un compagnon class a un accès illimité à toutes les propriétés et fonctions déclarées dans son objet compagnon, alors qu'un objet compagnon ne peut pas accéder aux membres de la classe. Nous pouvons avoir un init bloc de code à l'intérieur d'un un compagnon object-this est appelé immédiatement lorsque l'objet compagnon est créé.
Person.create ("Arya", "Stark") Person.create ("Daenerys", "Targaryen") println (Person.count)Le résultat de l'exécution du code ci-dessus sera:
Objet compagnon personne créé 2
Rappelez-vous, une seule instance d'une classe un compagnon objet peut jamais exister.
Nous sommes également libres de donner un nom à notre objet compagnon.
//… objet compagnon Usine nombre de var .: Int = 0 création amusante (prénom: chaîne, nom: chaîne): personne = personne (prénom, nom) //…
Ici, nous lui avons donné un nom appelé Usine. On peut alors l'appeler ainsi à Kotlin:
Person.Factory.create ("Petyr", "Baelish")Ce style est prolixe, il est donc préférable d’adhérer à la méthode précédente. Mais cela peut s'avérer utile lorsque vous appelez une fonction ou une propriété d'objet compagnon à partir de Java..
Comme je l'ai dit précédemment, les objets compagnons peuvent, comme les objets, inclure des propriétés ou des fonctions, implémenter des interfaces et même étendre une classe..
interface PersonFactory fun create (firstName: String, lastName: String): Person constructeur privé de la classe person (var firstName: String, var lastName: String) objet compagnon: PersonFactory override fun create (prénom Nom: String : Personne return Person (prenom, prenom)
Ici, nous avons une interface PersonFactory avec un seul créer() une fonction. En regardant notre nouveau modifié un compagnon object, il implémente maintenant cette interface (vous en apprendrez plus sur les interfaces et l'héritage dans Kotlin dans un post ultérieur).
Sous le capot, les objets compagnons sont compilés de la même manière que les objets Kotlin. Dans notre cas, deux classes sont générées pour nous: une dernière La personne classe et une classe finale statique interne Personne $ Compagnon.
le La personne classe contient un membre statique final appelé Un compagnon-ce champ statique est un objet de la Personne $ Compagnon classe intérieure. le Personne $ Compagnon la classe interne a aussi ses propres membres, et l’un d’eux est une fonction finale publique appelée créer().
Notez que nous n’avons pas donné de nom à notre objet compagnon. La classe interne statique générée était donc Un compagnon. Si nous lui avions donné un nom, le nom généré serait le nom que nous lui avons donné à Kotlin.
/ * Java * / Person personne = Person.Companion.create ("Jon", "Neige"); Ici, l’objet compagnon de Kotlin n’a pas de nom, nous utilisons donc le nom Un compagnon fourni par le compilateur pour les appelants Java pour l'appeler.
le @JvmStatic une annotation appliquée sur un membre d'objet compagnon fonctionne de la même manière que pour un objet normal.
De la même manière que les fonctions d'extension peuvent étendre les fonctionnalités d'une classe, nous pouvons également étendre les fonctionnalités d'un objet compagnon. (Si vous souhaitez un rappel des fonctions d'extension dans Kotlin, consultez le didacticiel sur les fonctions avancées de cette série.).
class ClassA objet compagnon amusant ClassA.Companion.extFunc () //… do implementation ClassA.extFunc ()
Ici, nous avons défini une fonction d'extension extFunc () sur l'objet compagnon ClassA.Companion. En d'autres termes, extfunc () est une extension de l'objet compagnon. Ensuite, nous pouvons appeler l'extension comme s'il s'agissait d'une fonction membre (ce n'est pas!) De l'objet compagnon.
Dans les coulisses, le compilateur créera une fonction utilitaire statique extFunc (). L'objet récepteur en tant qu'argument de cette fonction utilitaire est ClassA $ Companion.
Dans ce tutoriel, vous avez découvert les classes et les objets de base de Kotlin. Nous avons couvert les sujets suivants concernant les cours:
En outre, vous avez appris comment les objets et les objets compagnon de Kotlin peuvent facilement remplacer vos méthodes statiques, constantes et singletons que vous codez en Java. Mais ce n'est pas tout! Il reste encore beaucoup à apprendre sur les cours à Kot
