Kotlin - Classe et objet

Dans ce chapitre, nous allons apprendre les bases de la programmation orientée objet (POO) à l'aide de Kotlin. Nous apprendrons la classe et son objet et comment jouer avec cet objet. Par définition de la POO, une classe est un modèle d'une entité d'exécution et l'objet est son état, qui comprend à la fois son comportement et son état. Dans Kotlin, la déclaration de classe se compose d'un en-tête de classe et d'un corps de classe entouré d'accolades, similaire à Java.

Class myClass { // class Header 

   // class Body
}

Comme Java, Kotlin permet également de créer plusieurs objets d'une classe et vous êtes libre d'inclure ses membres de classe et ses fonctions. Nous pouvons contrôler la visibilité des variables des membres de la classe en utilisant différents mots-clés que nous apprendrons dans le Chapitre 10 - Contrôle de la visibilité. Dans l'exemple suivant, nous allons créer une classe et son objet à travers lesquels nous accéderons à différents membres de données de cette classe.

class myClass {
   // property (data member)
   private var name: String = "Tutorials.point"
   
   // member function
   fun printMe() {
      print("You are at the best Learning website Named-"+name)
   }
}
fun main(args: Array<String>) {
   val obj = myClass() // create obj object of myClass class
   obj.printMe()
}

Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur, où nous appelons printMe () de myClass en utilisant son propre objet.

You are at the best Learning website Named- Tutorials.point

Classe imbriquée

Par définition, lorsqu'une classe a été créée dans une autre classe, elle est appelée en tant que classe imbriquée. Dans Kotlin, la classe imbriquée est par défaut statique, par conséquent, elle peut être accédée sans créer aucun objet de cette classe. Dans l'exemple suivant, nous verrons comment Kotlin interprète notre classe imbriquée.

fun main(args: Array<String>) {
   val demo = Outer.Nested().foo() // calling nested class method
   print(demo)
}
class Outer {
   class Nested {
      fun foo() = "Welcome to The TutorialsPoint.com"
   }
}

Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.

Welcome to The TutorialsPoint.com

Classe intérieure

Lorsqu'une classe imbriquée est marquée comme «interne», elle sera appelée comme classe interne. Une classe interne est accessible par le membre de données de la classe externe. Dans l'exemple suivant, nous allons accéder au membre de données de la classe externe.

fun main(args: Array<String>) {
   val demo = Outer().Nested().foo() // calling nested class method
   print(demo)
}
class Outer {
   private val welcomeMessage: String = "Welcome to the TutorialsPoint.com"
   inner class Nested {
      fun foo() = welcomeMessage
   }
}

Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur, où nous appelons la classe imbriquée en utilisant le constructeur par défaut fourni par les compilateurs Kotlin au moment de la compilation.

Welcome to the TutorialsPoint.com

Classe intérieure anonyme

La classe interne anonyme est un très bon concept qui facilite la vie d'un programmeur. Chaque fois que nous implémentons une interface, le concept de bloc interne anonyme entre en scène. Le concept de création d'un objet d'interface à l'aide d'une référence d'objet d'exécution est connu sous le nom de classe anonyme. Dans l'exemple suivant, nous allons créer une interface et nous allons créer un objet de cette interface en utilisant le mécanisme de classe Anonymous Inner.

fun main(args: Array<String>) {
   var programmer :Human = object:Human // creating an instance of the interface {
      override fun think() { // overriding the think method
         print("I am an example of Anonymous Inner Class ")
      }
   }
   programmer.think()
}
interface Human {
   fun think()
}

Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.

I am an example of Anonymous Inner Class

Alias ​​de type

Les alias de type sont une propriété du compilateur Kotlin. Il offre la flexibilité de créer un nouveau nom d'un type existant, il ne crée pas un nouveau type. Si le nom du type est trop long, vous pouvez facilement introduire un nom plus court et l'utiliser pour une utilisation future. Les alias de type sont vraiment utiles pour les types complexes. Dans la dernière version, Kotlin a révoqué la prise en charge des alias de type, cependant, si vous utilisez une ancienne version de Kotlin, vous l'avez peut-être utilisée comme suit -

typealias NodeSet = Set<Network.Node>
typealias FileTable<K> = MutableMap<K, MutableList<File>>