Kotlin - Guide rapide
Kotlin est un nouveau langage de programmation open source comme Java, JavaScript, etc. C'est un langage de haut niveau fortement typé statiquement qui combine les parties fonctionnelle et technique dans un même endroit. Actuellement, Kotlin cible Java et JavaScript. Il fonctionne sur JVM.
Kotlin est influencé par d'autres langages de programmation tels que Java, Scala, Groovy, Gosu, etc. . Kotlin fournit l'interopérabilité, la sécurité du code et la clarté aux développeurs du monde entier.
Avantages et inconvénients
Voici quelques-uns des avantages de l'utilisation de Kotlin pour le développement de votre application.
Easy Language- Kotlin est un langage fonctionnel et très facile à apprendre. La syntaxe est assez similaire à Java, c'est pourquoi il est très facile à retenir. Kotlin est plus expressif, ce qui rend votre code plus lisible et compréhensible.
Concise- Kotlin est basé sur JVM et c'est un langage fonctionnel. Ainsi, il réduit beaucoup de code de plaque de chaudière utilisé dans d'autres langages de programmation.
Runtime and Performance - De meilleures performances et un temps d'exécution réduit.
Interoperability - Kotlin est suffisamment mature pour construire une application interopérable de manière moins complexe.
Brand New- Kotlin est un tout nouveau langage qui donne aux développeurs un nouveau départ. Ce n'est pas un remplacement de Java, bien qu'il soit développé sur JVM. Il est accepté comme la première langue officielle du développement Android. Kotlin peut être défini comme - Kotlin = JAVA + nouvelles fonctionnalités supplémentaires mises à jour.
Voici quelques-uns des inconvénients de Kotlin.
Namespace declaration- Kotlin permet aux développeurs de déclarer les fonctions au plus haut niveau. Cependant, chaque fois que la même fonction est déclarée à de nombreux endroits de votre application, il est difficile de comprendre quelle fonction est appelée.
No Static Declaration - Kotlin n'a pas de modificateur de gestion statique habituel comme Java, ce qui peut poser des problèmes au développeur Java conventionnel.
Cependant, si vous souhaitez toujours utiliser Kotlin hors ligne dans votre système local, vous devez exécuter les étapes suivantes pour configurer votre espace de travail local.
Step 1 - Installation de Java 8.
Kotlin fonctionne sur JVM, par conséquent. il est vraiment nécessaire d'utiliser JDK 8 pour votre développement Kotlin local. Veuillez vous référer au site officiel d' Oracle pour télécharger et installer JDK 8 ou une version ci-dessus. Vous devrez peut-être définir la variable d'environnement pour JAVA afin qu'elle puisse fonctionner correctement. Pour vérifier votre installation dans le système d'exploitation Windows, appuyez sur «java –version» dans l'invite de commande et en sortie, il vous montrera la version java installée sur votre système.
Step 2 - Installation IDE.
Il existe un certain nombre d'IDE disponibles sur Internet. Vous pouvez utiliser n'importe lequel de votre choix. Vous pouvez trouver le lien de téléchargement de différents IDE dans le tableau suivant.
| Nom IDE | Lien d'installation |
|---|---|
| NetBeans | https://netbeans.org/downloads/ |
| Éclipse | https://www.eclipse.org/downloads/ |
| Intellij | https://www.jetbrains.com/idea/download/#section = windows |
Il est toujours recommandé d'utiliser la version récente du logiciel pour en extraire le maximum de fonctionnalités.
Step 3 - Configuration d'Eclipse.
Ouvrez Eclipse et allez sur «Eclipse Market Place». Vous trouverez l'écran suivant.
Recherchez Kotlin dans la zone de recherche et installez-le dans votre système local. Cela peut prendre un certain temps en fonction de la vitesse d'Internet. Vous devrez peut-être redémarrer votre Eclipse, une fois qu'il est installé avec succès.
Step 4 - Projet Kotlin.
Une fois Eclipse redémarré et Kotlin installé, vous pourrez créer un projet Kotlin à la volée. Aller àFile → New → Others et sélectionnez «Projet Kotlin» dans la liste.
Une fois la configuration du projet terminée, vous pouvez créer un fichier Kotlin dans le dossier «SRC». Faites un clic gauche sur le dossier «Src» et appuyez sur «nouveau». Vous obtiendrez une option pour le fichier Kotlin, sinon vous devrez peut-être rechercher parmi les «autres». Une fois le nouveau fichier créé, le répertoire de votre projet ressemblera à ce qui suit.
Votre environnement de développement est maintenant prêt. Allez-y et ajoutez le morceau de code suivant dans le fichier «Hello.kt».
fun main(args: Array<String>) {
println("Hello, World!")
}Exécutez-le en tant qu'application Kotlin et voyez la sortie dans la console, comme indiqué dans la capture d'écran suivante. Pour une meilleure compréhension et disponibilité, nous utiliserons notre outil de codage au sol.
Hello, World!Kotlin est un langage de programmation et possède sa propre architecture pour allouer de la mémoire et produire une sortie de qualité à l'utilisateur final. Voici les différents scénarios dans lesquels le compilateur Kotlin fonctionnera différemment, chaque fois qu'il cible différents autres types de langages tels que Java et JavaScript.
Le compilateur Kotlin crée un code d'octet et ce code d'octet peut s'exécuter sur la JVM, ce qui est exactement égal au code d'octet généré par Java .classfichier. Chaque fois qu'un fichier codé sur deux octets s'exécute sur la JVM, ils peuvent communiquer entre eux et c'est ainsi qu'une fonctionnalité interopérable est établie dans Kotlin pour Java.
Chaque fois que Kotlin cible JavaScript, le compilateur Kotlin convertit le .ktfichier dans ES5.1 et génère un code compatible pour JavaScript. Le compilateur Kotlin est capable de créer des codes compatibles de base de plate-forme via LLVM.
Dans ce chapitre, nous découvrirons les types de données de base disponibles dans le langage de programmation Kotlin.
Nombres
La représentation des nombres dans Kotlin est assez similaire à Java, cependant, Kotlin ne permet pas la conversion interne de différents types de données. Le tableau suivant répertorie différentes longueurs variables pour différents nombres.
| Type | Taille |
|---|---|
| Double | 64 |
| Flotte | 32 |
| Longue | 64 |
| Int | 32 |
| Court | 16 |
| Octet | 8 |
Dans l'exemple suivant, nous verrons comment Kotlin fonctionne avec différents types de données. Veuillez saisir l'ensemble de codes suivant dans notre base de codage.
fun main(args: Array<String>) {
val a: Int = 10000
val d: Double = 100.00
val f: Float = 100.00f
val l: Long = 1000000004
val s: Short = 10
val b: Byte = 1
println("Your Int Value is "+a);
println("Your Double Value is "+d);
println("Your Float Value is "+f);
println("Your Long Value is "+l);
println("Your Short Value is "+s);
println("Your Byte Value is "+b);
}Lorsque vous exécutez le morceau de code ci-dessus dans le sol de codage, il générera la sortie suivante dans la console Web.
Your Int Value is 10000
Your Double Value is 100.0
Your Float Value is 100.0
Your Long Value is 1000000004
Your Short Value is 10
Your Byte Value is 1Personnages
Kotlin représente le personnage en utilisant char. Le caractère doit être déclaré dans un guillemet simple comme‘c’. Veuillez entrer le code suivant dans notre base de codage et voir comment Kotlin interprète la variable de caractère. La variable caractère ne peut pas être déclarée comme une variable numérique. La variable Kotlin peut être déclarée de deux manières - l'une en utilisant“var” et un autre utilisant “val”.
fun main(args: Array<String>) {
val letter: Char // defining a variable
letter = 'A' // Assigning a value to it
println("$letter")
}Le morceau de code ci-dessus produira la sortie suivante dans la fenêtre de sortie du navigateur.
ABooléen
Boolean est très simple comme les autres langages de programmation. Nous n'avons que deux valeurs pour Boolean - true ou false. Dans l'exemple suivant, nous verrons comment Kotlin interprète Boolean.
fun main(args: Array<String>) {
val letter: Boolean // defining a variable
letter = true // Assinging a value to it
println("Your character value is "+"$letter")
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
Your character value is trueCordes
Les chaînes sont des tableaux de caractères. Comme Java, ils sont de nature immuable. Nous avons deux types de cordes disponibles dans Kotlin - l'un s'appelleraw String et un autre s'appelle escaped String. Dans l'exemple suivant, nous utiliserons ces chaînes.
fun main(args: Array<String>) {
var rawString :String = "I am Raw String!"
val escapedString : String = "I am escaped String!\n"
println("Hello!"+escapedString)
println("Hey!!"+rawString)
}L'exemple ci-dessus de String échappé permet de fournir un espace de ligne supplémentaire après la première instruction d'impression. Voici la sortie dans le navigateur.
Hello!I am escaped String!
Hey!!I am Raw String!Tableaux
Les tableaux sont une collection de données homogènes. Comme Java, Kotlin prend en charge des tableaux de différents types de données. Dans l'exemple suivant, nous utiliserons différents tableaux.
fun main(args: Array<String>) {
val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
println("Hey!! I am array Example"+numbers[2])
}Le morceau de code ci-dessus donne la sortie suivante. L'indexation du tableau est similaire à d'autres langages de programmation. Ici, nous recherchons un deuxième index, dont la valeur est «3».
Hey!! I am array Example3Les collections
La collecte est une partie très importante de la structure des données, ce qui facilite le développement du logiciel pour les ingénieurs. Kotlin a deux types de collection - l'un estimmutable collection (ce qui signifie des listes, des cartes et des ensembles qui ne peuvent pas être modifiés) et un autre est mutable collection(ce type de collection est modifiable). Il est très important de garder à l'esprit le type de collection utilisé dans votre application, car le système Kotlin ne représente aucune différence spécifique entre eux.
fun main(args: Array<String>) {
val numbers: MutableList<Int> = mutableListOf(1, 2, 3) //mutable List
val readOnlyView: List<Int> = numbers // immutable list
println("my mutable list--"+numbers) // prints "[1, 2, 3]"
numbers.add(4)
println("my mutable list after addition --"+numbers) // prints "[1, 2, 3, 4]"
println(readOnlyView)
readOnlyView.clear() // ⇒ does not compile
// gives error
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur. Cela donne une erreur lorsque nous essayons d'effacer la liste mutable de la collection.
main.kt:9:18: error: unresolved reference: clear
readOnlyView.clear() // -> does not compile
^Dans la collection, Kotlin fournit des méthodes utiles telles que first(), last(), filter(), etc. Toutes ces méthodes sont auto-descriptives et faciles à mettre en œuvre. De plus, Kotlin suit la même structure telle que Java lors de l'implémentation de la collection. Vous êtes libre d'implémenter n'importe quelle collection de votre choix telle que Map et Set.
Dans l'exemple suivant, nous avons implémenté Map et Set à l'aide de différentes méthodes intégrées.
fun main(args: Array<String>) {
val items = listOf(1, 2, 3, 4)
println("First Element of our list----"+items.first())
println("Last Element of our list----"+items.last())
println("Even Numbers of our List----"+items.
filter { it % 2 = = 0 }) // returns [2, 4]
val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
println(readWriteMap["foo"]) // prints "1"
val strings = hashSetOf("a", "b", "c", "c")
println("My Set Values are"+strings)
}Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.
First Element of our list----1
Last Element of our list----4
Even Numbers of our List----[2, 4]
1
My Set Values are[a, b, c]Gammes
Ranges est une autre caractéristique unique de Kotlin. Comme Haskell, il fournit un opérateur qui vous aide à parcourir une plage. En interne, il est implémenté en utilisantrangeTo() et sa forme d'opérateur est (..).
Dans l'exemple suivant, nous verrons comment Kotlin interprète cet opérateur de plage.
fun main(args: Array<String>) {
val i:Int = 2
for (j in 1..4)
print(j) // prints "1234"
if (i in 1..10) { // equivalent of 1 < = i && i < = 10
println("we found your number --"+i)
}
}Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.
1234we found your number --2Dans le chapitre précédent, nous avons découvert les différents types de types de données disponibles dans le système Kotlin. Dans ce chapitre, nous discuterons des différents types de mécanismes de contrôle de flux disponibles dans le Kotlin.
Sinon
Kotlin est un langage fonctionnel donc comme tous les langages fonctionnels de Kotlin “if”est une expression, ce n'est pas un mot-clé. L'expression“if”renverra une valeur chaque fois que nécessaire. Comme tout autre langage de programmation,“if-else”block est utilisé comme opérateur de contrôle conditionnel initial. Dans l'exemple suivant, nous comparerons deux variables et fournirons la sortie requise en conséquence.
fun main(args: Array<String>) {
val a:Int = 5
val b:Int = 2
var max: Int
if (a > b) {
max = a
} else {
max = b
}
print("Maximum of a or b is " +max)
// As expression
// val max = if (a > b) a else b
}Le morceau de code ci-dessus produit le résultat suivant dans le navigateur. Notre exemple contient également une autre ligne de code, qui décrit comment utiliser“If” déclaration comme une expression.
Maximum of a or b is 5Utilisation de quand
Si vous êtes familier avec d'autres langages de programmation, alors vous avez peut-être entendu parler du terme instruction switch, qui est essentiellement un opérateur conditionnel lorsque plusieurs conditions peuvent être appliquées à une variable particulière. “when”L'opérateur compare la valeur de la variable aux conditions de la branche. S'il satisfait la condition de branchement, il exécutera l'instruction à l'intérieur de cette portée. Dans l'exemple suivant, nous en apprendrons plus sur «quand» à Kotlin.
fun main(args: Array<String>) {
val x:Int = 5
when (x) {
1 -> print("x = = 1")
2 -> print("x = = 2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.
x is neither 1 nor 2Dans l'exemple ci-dessus, le compilateur Kotlin correspond à la valeur de xavec les branches données. S'il ne correspond à aucune des branches, il exécutera la partie else. Pratiquement, quand est équivalent à multiple if block. Kotlin offre une autre flexibilité au développeur, où le développeur peut fournir plusieurs contrôles dans la même ligne en fournissant «,» à l'intérieur des contrôles. Modifions l'exemple ci-dessus comme suit.
fun main(args: Array<String>) {
val x:Int = 5
when (x) {
1,2 -> print(" Value of X either 1,2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}Exécutez la même chose dans le navigateur, ce qui donnera la sortie suivante dans le navigateur.
x is neither 1 nor 2Pour la boucle
Loop est une telle invention qui offre la flexibilité nécessaire pour parcourir tout type de structure de données. Comme d'autres langages de programmation, Kotlin fournit également de nombreux types de méthodologie de bouclage, cependant, parmi eux“For”est la plus réussie. L'implémentation et l'utilisation de la boucle For sont conceptuellement similaires à Java for loop. L'exemple suivant montre comment nous pouvons utiliser la même chose dans des exemples réels.
fun main(args: Array<String>) {
val items = listOf(1, 2, 3, 4)
for (i in items) println("values of the array"+i)
}Dans le morceau de code ci-dessus, nous avons déclaré une liste nommée «éléments» et en utilisant la boucle for, nous parcourons cette liste définie et imprimons sa valeur dans le navigateur. Voici la sortie.
values of the array1
values of the array2
values of the array3
values of the array4Voici un autre exemple de code, où nous utilisons une fonction de bibliothèque pour rendre notre travail de développement plus facile que jamais.
fun main(args: Array<String>) {
val items = listOf(1, 22, 83, 4)
for ((index, value) in items.withIndex()) {
println("the element at $index is $value")
}
}Une fois que nous compilons et exécutons le morceau de code ci-dessus dans notre base de codage, il produira la sortie suivante dans le navigateur.
the element at 0 is 1
the element at 1 is 22
the element at 2 is 83
the element at 3 is 4Boucle While et Boucle Do-While
While et Do-While fonctionnent exactement de la même manière que dans d'autres langages de programmation. La seule différence entre ces deux boucles est que, en cas de boucle Do-while, la condition sera testée à la fin de la boucle. L'exemple suivant montre l'utilisation duWhile loop.
fun main(args: Array<String>) {
var x:Int = 0
println("Example of While Loop--")
while(x< = 10) {
println(x)
x++
}
}Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.
Example of While Loop--
0
1
2
3
4
5
6
7
8
9
10Kotlin a également une autre boucle appelée boucle Do-While, où le corps de la boucle sera exécuté une fois, alors seulement la condition sera vérifiée. L'exemple suivant montre l'utilisation duDo-while loop.
fun main(args: Array<String>) {
var x:Int = 0
do {
x = x + 10
println("I am inside Do block---"+x)
} while(x <= 50)
}Le morceau de code ci-dessus produit la sortie suivante dans le navigateur. Dans le code ci-dessus, le compilateur Kotlin exécutera le bloc DO, puis il effectuera la vérification des conditions pendant le bloc.
I am inside Do block---10
I am inside Do block---20
I am inside Do block---30
I am inside Do block---40
I am inside Do block---50
I am inside Do block---60Utilisation du retour, pause, continue
Si vous connaissez un langage de programmation, vous devez avoir une idée des différents mots-clés qui nous aident à implémenter un bon flux de contrôle dans l'application. Voici les différents mots clés qui peuvent être utilisés pour contrôler les boucles ou tout autre type de flux de contrôle.
Return- Return est un mot-clé qui renvoie une valeur à la fonction appelante à partir de la fonction appelée. Dans l'exemple suivant, nous implémenterons ce scénario en utilisant notre base de codage Kotlin.
fun main(args: Array<String>) {
var x:Int = 10
println("The value of X is--"+doubleMe(x))
}
fun doubleMe(x:Int):Int {
return 2*x;
}Dans le morceau de code ci-dessus, nous appelons une autre fonction et multiplions l'entrée par 2, et renvoyons la valeur résultante à la fonction appelée qui est notre fonction principale. Kotlin définit la fonction d'une manière différente que nous examinerons dans un chapitre suivant. Pour l'instant, il suffit de comprendre que le code ci-dessus générera la sortie suivante dans le navigateur.
The value of X is--20Continue & Break- Continuer et interrompre sont la partie la plus vitale d'un problème logique. Le mot-clé «break» met fin au flux du contrôleur si une condition a échoué et «continue» fait le contraire. Toute cette opération se fait avec une visibilité immédiate. Kotlin est plus intelligent que les autres langages de programmation, dans lesquels le développeur peut appliquer plusieurs étiquettes comme visibilité. Le morceau de code suivant montre comment nous implémentons cette étiquette dans Kotlin.
fun main(args: Array<String>) {
println("Example of Break and Continue")
myLabel@ for(x in 1..10) { // appling the custom label
if(x = = 5) {
println("I am inside if block with value"+x+"\n-- hence it will close the operation")
break@myLabel //specifing the label
} else {
println("I am inside else block with value"+x)
continue@myLabel
}
}
}Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.
Example of Break and Continue
I am inside else block with value1
I am inside else block with value2
I am inside else block with value3
I am inside else block with value4
I am inside if block with value5
-- hence it will close the operationComme vous pouvez le voir, le contrôleur continue la boucle, jusqu'à ce que et à moins que la valeur de x vaut 5. Une fois que la valeur de x atteint 5, il commence à exécuter le bloc if et une fois que l'instruction break est atteinte, tout le flux de contrôle met fin à l'exécution du programme.
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.pointClasse 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.comClasse 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 produira 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.comClasse 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 à l'aide du 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 ClassAlias 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>>Dans ce chapitre, nous allons découvrir les constructeurs dans Kotlin. Kotlin a deux types de constructeur - l'un est leprimary constructor et l'autre est le secondary constructor. Une classe Kotlin peut avoir un constructeur principal et un ou plusieurs constructeurs secondaires. Le constructeur Java initialise les variables membres, cependant, dans Kotlin, le constructeur principal initialise la classe, tandis que le constructeur secondaire aide à inclure une logique supplémentaire lors de l'initialisation de la même chose. Le constructeur principal peut être déclaré au niveau de l'en-tête de classe, comme illustré dans l'exemple suivant.
class Person(val firstName: String, var age: Int) {
// class body
}Dans l'exemple ci-dessus, nous avons déclaré le constructeur principal à l'intérieur de la parenthèse. Parmi les deux champs, le prénom est en lecture seule car il est déclaré comme «val», tandis que l'âge du champ peut être modifié. Dans l'exemple suivant, nous utiliserons le constructeur principal.
fun main(args: Array<String>) {
val person1 = Person("TutorialsPoint.com", 15)
println("First Name = ${person1.firstName}") println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}Le morceau de code ci-dessus initialisera automatiquement les deux variables et fournira la sortie suivante dans le navigateur.
First Name = TutorialsPoint.com
Age = 15Comme mentionné précédemment, Kotlin permet de créer un ou plusieurs constructeurs secondaires pour votre classe. Ce constructeur secondaire est créé à l'aide du mot-clé «constructor». Il est requis chaque fois que vous souhaitez créer plusieurs constructeurs dans Kotlin ou chaque fois que vous souhaitez inclure plus de logique dans le constructeur principal et vous ne pouvez pas le faire car le constructeur principal peut être appelé par une autre classe. Jetez un œil à l'exemple suivant, dans lequel nous avons créé un constructeur secondaire et utilisons l'exemple ci-dessus pour l'implémenter.
fun main(args: Array<String>) {
val HUman = HUman("TutorialsPoint.com", 25)
print("${HUman.message}"+"${HUman.firstName}"+
"Welcome to the example of Secondary constructor, Your Age is-${HUman.age}")
}
class HUman(val firstName: String, var age: Int) {
val message:String = "Hey!!!"
constructor(name : String , age :Int ,message :String):this(name,age) {
}
}Note - N'importe quel nombre de constructeurs secondaires peut être créé, cependant, tous ces constructeurs doivent appeler le constructeur principal directement ou indirectement.
Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
Hey!!! TutorialsPoint.comWelcome to the example of Secondary constructor, Your Age is- 25Dans ce chapitre, nous en apprendrons davantage sur l'héritage. Par définition, nous savons tous que l'héritage signifie l'accumulation de certaines propriétés de la classe mère dans la classe enfant. Dans Kotlin, la classe de base est nommée «Any», qui est la super classe de la classe par défaut «any» déclarée dans Kotlin. Comme tous les autres OOPS, Kotlin fournit également cette fonctionnalité en utilisant un mot-clé appelé“:”.
Tout dans Kotlin est par défaut final, par conséquent, nous devons utiliser le mot-clé «open» devant la déclaration de classe pour permettre l'héritage. Jetez un œil à l'exemple suivant d'héritage.
import java.util.Arrays
open class ABC {
fun think () {
print("Hey!! i am thiking ")
}
}
class BCD: ABC(){ // inheritence happend using default constructor
}
fun main(args: Array<String>) {
var a = BCD()
a.think()
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
Hey!! i am thikingMaintenant, que faire si nous voulons remplacer la méthode think () dans la classe enfant. Ensuite, nous devons considérer l'exemple suivant où nous créons deux classes et remplaçons l'une de ses fonctions dans la classe enfant.
import java.util.Arrays
open class ABC {
open fun think () {
print("Hey!! i am thinking ")
}
}
class BCD: ABC() { // inheritance happens using default constructor
override fun think() {
print("I Am from Child")
}
}
fun main(args: Array<String>) {
var a = BCD()
a.think()
}Le morceau de code ci-dessus appellera la méthode héritée de la classe enfant et produira la sortie suivante dans le navigateur. Comme Java, Kotlin n'autorise pas non plus les héritages multiples.
I Am from ChildDans ce chapitre, nous en apprendrons davantage sur l'interface de Kotlin. Dans Kotlin, l'interface fonctionne exactement de la même manière que Java 8, ce qui signifie qu'elle peut contenir une implémentation de méthode ainsi qu'une déclaration de méthodes abstraites. Une interface peut être implémentée par une classe afin d'utiliser sa fonctionnalité définie. Nous avons déjà présenté un exemple avec une interface dans le chapitre 6 - section «classe interne anonyme». Dans ce chapitre, nous en apprendrons plus à ce sujet. Le mot-clé «interface» est utilisé pour définir une interface dans Kotlin comme indiqué dans le morceau de code suivant.
interface ExampleInterface {
var myVar: String // abstract property
fun absMethod() // abstract method
fun sayHello() = "Hello there" // method with default implementation
}Dans l'exemple ci-dessus, nous avons créé une interface nommée «ExampleInterface» et à l'intérieur, nous avons quelques propriétés et méthodes abstraites toutes ensemble. Regardez la fonction nommée «sayHello ()», qui est une méthode implémentée.
Dans l'exemple suivant, nous implémenterons l'interface ci-dessus dans une classe.
interface ExampleInterface {
var myVar: Int // abstract property
fun absMethod():String // abstract method
fun hello() {
println("Hello there, Welcome to TutorialsPoint.Com!")
}
}
class InterfaceImp : ExampleInterface {
override var myVar: Int = 25
override fun absMethod() = "Happy Learning "
}
fun main(args: Array<String>) {
val obj = InterfaceImp()
println("My Variable Value is = ${obj.myVar}")
print("Calling hello(): ")
obj.hello()
print("Message from the Website-- ")
println(obj.absMethod())
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
My Variable Value is = 25
Calling hello(): Hello there, Welcome to TutorialsPoint.Com!
Message from the Website-- Happy LearningComme mentionné précédemment, Kotlin ne prend pas en charge les héritages multiples, cependant, la même chose peut être obtenue en implémentant plus de deux interfaces à la fois.
Dans l'exemple suivant, nous allons créer deux interfaces et plus tard, nous implémenterons les deux interfaces dans une classe.
interface A {
fun printMe() {
println(" method of interface A")
}
}
interface B {
fun printMeToo() {
println("I am another Method from interface B")
}
}
// implements two interfaces A and B
class multipleInterfaceExample: A, B
fun main(args: Array<String>) {
val obj = multipleInterfaceExample()
obj.printMe()
obj.printMeToo()
}Dans l'exemple ci-dessus, nous avons créé deux exemples d'interfaces A, B et dans la classe nommée «multipleInterfaceExample», nous avons implémenté deux interfaces déclarées précédemment. Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
method of interface A
I am another Method from interface BDans ce chapitre, nous découvrirons les différents modificateurs disponibles en langage Kotlin. Access modifierest utilisé pour restreindre l'utilisation des variables, méthodes et classes utilisées dans l'application. Comme tout autre langage de programmation POO, ce modificateur est applicable à plusieurs endroits, comme dans l'en-tête de classe ou la déclaration de méthode. Il y a quatre modificateurs d'accès disponibles dans Kotlin.
Privé
Les classes, méthodes et packages peuvent être déclarés avec un modificateur privé. Une fois que quelque chose est déclaré comme privé, il sera alors accessible dans sa portée immédiate. Par exemple, un package privé peut être accessible dans ce fichier spécifique. Une classe ou une interface privée ne peut être accessible que par ses données membres, etc.
private class privateExample {
private val i = 1
private val doSomething() {
}
}Dans l'exemple ci-dessus, la classe “privateExample” et la variable i ne peut être accessible que dans le même fichier Kotlin, où elle est mentionnée car elles sont toutes déclarées comme privées dans le bloc de déclaration.
Protégé
Protected est un autre modificateur d'accès pour Kotlin, qui n'est actuellement pas disponible pour la déclaration de niveau supérieur, car aucun package ne peut être protégé. Une classe ou une interface protégée n'est visible que par sa sous-classe.
class A() {
protected val i = 1
}
class B : A() {
fun getValue() : Int {
return i
}
}Dans l'exemple ci-dessus, la variable “i” est déclaré comme protégé, par conséquent, il n'est visible que par sa sous-classe.
Interne
Internal est un modificateur nouvellement ajouté introduit dans Kotlin. Si quelque chose est marqué comme interne, alors ce champ spécifique sera dans le champ interne. Un package interne n'est visible qu'à l'intérieur du module sous lequel il est implémenté. Une interface de classe interne n'est visible que par une autre classe présente dans le même package ou le module. Dans l'exemple suivant, nous verrons comment implémenter une méthode interne.
class internalExample {
internal val i = 1
internal fun doSomething() {
}
}Dans l'exemple ci-dessus, la méthode nommée «doSomething» et la variable sont mentionnées comme internes, par conséquent, ces deux champs ne peuvent être accessibles qu'à l'intérieur du package sous lequel il est déclaré.
Publique
Le modificateur public est accessible de n'importe où dans l'espace de travail du projet. Si aucun modificateur d'accès n'est spécifié, il sera par défaut dans la portée publique. Dans tous nos exemples précédents, nous n'avons mentionné aucun modificateur, par conséquent, tous sont dans la portée publique. Voici un exemple pour en savoir plus sur la façon de déclarer une variable ou une méthode publique.
class publicExample {
val i = 1
fun doSomething() {
}
}Dans l'exemple ci-dessus, nous n'avons mentionné aucun modificateur, donc toutes ces méthodes et variables sont par défaut publiques.
Dans ce chapitre, nous allons découvrir une autre nouvelle fonctionnalité de Kotlin appelée «Extension». En utilisant l'extension, nous pourrons ajouter ou supprimer certaines fonctionnalités de méthode même sans les hériter ou les modifier. Les extensions sont résolues statistiquement. Il ne modifie pas réellement la classe existante, mais il crée une fonction appelable qui peut être appelée avec une opération de point.
Extension de fonction
En extension de fonction, Kotlin permet de définir une méthode en dehors de la classe principale. Dans l'exemple suivant, nous verrons comment l'extension est implémentée au niveau fonctionnel.
class Alien {
var skills : String = "null"
fun printMySkills() {
print(skills)
}
}
fun main(args: Array<String>) {
var a1 = Alien()
a1.skills = "JAVA"
//a1.printMySkills()
var a2 = Alien()
a2.skills = "SQL"
//a2.printMySkills()
var a3 = Alien()
a3.skills = a1.addMySkills(a2)
a3.printMySkills()
}
fun Alien.addMySkills(a:Alien):String{
var a4 = Alien()
a4.skills = this.skills + " " +a.skills
return a4.skills
}Dans l'exemple ci-dessus, nous n'avons aucune méthode à l'intérieur de la classe «Alien» nommée «addMySkills ()», cependant, nous implémentons toujours la même méthode ailleurs en dehors de la classe. C'est la magie de l'extension.
Le morceau de code ci-dessus générera la sortie suivante dans le navigateur.
JAVA SQLExtension d'objet
Kotlin fournit un autre mécanisme pour implémenter la fonctionnalité statique de Java. Ceci peut être réalisé en utilisant le mot-clé «objet compagnon». En utilisant ce mécanisme, nous pouvons créer un objet d'une classe dans une méthode de fabrique et plus tard, nous pouvons simplement appeler cette méthode en utilisant la référence du nom de la classe. Dans l'exemple suivant, nous allons créer un «objet compagnon».
fun main(args: Array<String>) {
println("Heyyy!!!"+A.show())
}
class A {
companion object {
fun show():String {
return("You are learning Kotlin from TutorialsPoint.com")
}
}
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
Heyyy!!! You are learning Kotlin from TutorialsPoint.comL'exemple ci-dessus semble statique en Java, cependant, en temps réel, nous créons un objet en tant que variable membre de cette même classe. C'est pourquoi il est également inclus dans la propriété d'extension et peut également être appelé comme extension d'objet. Vous étendez essentiellement l'objet de la même classe pour utiliser certaines des fonctions membres.
Dans ce chapitre, nous en apprendrons plus sur les classes de données du langage de programmation Kotlin. Une classe peut être marquée comme une classe de données chaque fois qu'elle est marquée comme «données». Ce type de classe peut être utilisé pour séparer les données de base. En dehors de cela, il ne fournit aucune autre fonctionnalité.
Toutes les classes de données doivent avoir un constructeur principal et tout le constructeur principal doit avoir au moins un paramètre. Chaque fois qu'une classe est marquée comme donnée, nous pouvons utiliser une partie de la fonction intégrée de cette classe de données comme «toString ()», «hashCode ()», etc. Toute classe de données ne peut pas avoir de modificateur comme abstract et open ou internal. La classe de données peut également être étendue à d'autres classes. Dans l'exemple suivant, nous allons créer une classe de données.
fun main(args: Array<String>) {
val book: Book = Book("Kotlin", "TutorialPoint.com", 5)
println("Name of the Book is--"+book.name) // "Kotlin"
println("Puclisher Name--"+book.publisher) // "TutorialPoint.com"
println("Review of the book is--"+book.reviewScore) // 5
book.reviewScore = 7
println("Printing all the info all together--"+book.toString())
//using inbuilt function of the data class
println("Example of the hashCode function--"+book.hashCode())
}
data class Book(val name: String, val publisher: String, var reviewScore: Int)Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur, où nous avons créé une classe de données pour contenir certaines des données, et à partir de la fonction principale, nous avons accédé à tous ses membres de données.
Name of the Book is--"Kotlin"
Puclisher Name--"TutorialPoint.com"
Review of the book is--5
Printing all the info all together--(name-Kotlin, publisher-TutorialPoint.com, reviewScore-7)
Example of the hashCode function---1753517245Dans ce chapitre, nous allons découvrir un autre type de classe appelé classe «Sealed». Ce type de classe est utilisé pour représenter une hiérarchie de classes restreinte. Sealed permet aux développeurs de conserver un type de données d'un type prédéfini. Pour créer une classe scellée, nous devons utiliser le mot-clé «scellé» comme modificateur de cette classe. Une classe scellée peut avoir sa propre sous-classe mais toutes ces sous-classes doivent être déclarées dans le même fichier Kotlin avec la classe scellée. Dans l'exemple suivant, nous verrons comment utiliser une classe scellée.
sealed class MyExample {
class OP1 : MyExample() // MyExmaple class can be of two types only
class OP2 : MyExample()
}
fun main(args: Array<String>) {
val obj: MyExample = MyExample.OP2()
val output = when (obj) { // defining the object of the class depending on the inuputs
is MyExample.OP1 -> "Option One has been chosen"
is MyExample.OP2 -> "option Two has been chosen"
}
println(output)
}Dans l'exemple ci-dessus, nous avons une classe scellée nommée "MyExample", qui peut être de deux types seulement - l'un est "OP1" et l'autre est "OP2". Dans la classe principale, nous créons un objet dans notre classe et assignons son type au moment de l'exécution. Maintenant, comme cette classe «MyExample» est scellée, nous pouvons appliquer la clause «when» lors de l'exécution pour implémenter la sortie finale.
En classe scellée, nous n'avons pas besoin d'utiliser une instruction «else» inutile pour complexifier le code. Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
option Two has been chosenComme Java, Kotlin fournit un ordre supérieur de typage de variables appelé génériques. Dans ce chapitre, nous apprendrons comment Kotlin implémente les génériques et comment, en tant que développeur, nous pouvons utiliser les fonctionnalités fournies dans la bibliothèque de génériques. En ce qui concerne la mise en œuvre, les génériques sont assez similaires à Java, mais le développeur Kotlin a introduit deux nouveaux mots-clés“out” et “in” pour rendre les codes Kotlin plus lisibles et plus faciles pour le développeur.
Dans Kotlin, une classe et un type sont des concepts totalement différents. Comme dans l'exemple, List est une classe dans Kotlin, alors que List <String> est un type dans Kotlin. L'exemple suivant montre comment les génériques sont implémentés dans Kotlin.
fun main(args: Array<String>) {
val integer: Int = 1
val number: Number = integer
print(number)
}Dans le code ci-dessus, nous avons déclaré un «entier» et plus tard, nous avons attribué cette variable à une variable numérique. Cela est possible parce que «Int» est une sous-classe de la classe Number, par conséquent la conversion de type se produit automatiquement à l'exécution et produit la sortie comme «1».
Apprenons quelque chose de plus sur les génériques à Kotlin. Il est préférable d'opter pour un type de données générique chaque fois que nous ne sommes pas sûrs du type de données que nous allons utiliser dans l'application. Généralement, dans Kotlin, les génériques sont définis par<T>où «T» signifie modèle, qui peut être déterminé dynamiquement par le compilateur Kotlin. Dans l'exemple suivant, nous verrons comment utiliser des types de données génériques dans le langage de programmation Kotlin.
fun main(args: Array<String>) {
var objet = genericsExample<String>("JAVA")
var objet1 = genericsExample<Int>(10)
}
class genericsExample<T>(input:T) {
init {
println("I am getting called with the value "+input)
}
}Dans le morceau de code ci-dessus, nous créons une classe avec un type de retour générique, qui est représenté par <T>. Jetez un œil à la méthode main, où nous avons défini dynamiquement sa valeur lors de l'exécution en prouvant le type de valeur, tout en créant l'objet de cette classe. C'est ainsi que les génériques sont interprétés par le compilateur Kotlin. Nous obtiendrons la sortie suivante dans le navigateur, une fois que nous aurons exécuté ce code dans notre base de codage.
I am getting called with the value JAVA
I am getting called with the value 10Lorsque nous voulons attribuer le type générique à l'un de ses super-types, nous devons utiliser le mot-clé «out», et lorsque nous voulons attribuer le type générique à l'un de ses sous-types, nous devons utiliser «in» mot-clé. Dans l'exemple suivant, nous utiliserons le mot-clé «out». De même, vous pouvez essayer d'utiliser le mot-clé «in».
fun main(args: Array<String>) {
var objet1 = genericsExample<Int>(10)
var object2 = genericsExample<Double>(10.00)
println(objet1)
println(object2)
}
class genericsExample<out T>(input:T) {
init {
println("I am getting called with the value "+input)
}
}Le code ci-dessus donnera la sortie suivante dans le navigateur.
I am getting called with the value 10
I am getting called with the value 10.0
genericsExample@28d93b30
genericsExample@1b6d3586Kotlin soutient “delegation” modèle de conception en introduisant un nouveau mot-clé “by”. En utilisant ce mot-clé ou méthodologie de délégation, Kotlin permet à la classe dérivée d'accéder à toutes les méthodes publiques implémentées d'une interface via un objet spécifique. L'exemple suivant montre comment cela se produit dans Kotlin.
interface Base {
fun printMe() //abstract method
}
class BaseImpl(val x: Int) : Base {
override fun printMe() { println(x) } //implementation of the method
}
class Derived(b: Base) : Base by b // delegating the public method on the object b
fun main(args: Array<String>) {
val b = BaseImpl(10)
Derived(b).printMe() // prints 10 :: accessing the printMe() method
}Dans l'exemple, nous avons une interface «Base» avec sa méthode abstraite nommée «printme ()». Dans la classe BaseImpl, nous implémentons ce «printme ()» et plus tard à partir d'une autre classe, nous utilisons cette implémentation en utilisant le mot-clé «by».
Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
10Délégation de propriété
Dans la section précédente, nous avons découvert le modèle de conception de délégation en utilisant le mot-clé «par». Dans cette section, nous en apprendrons davantage sur la délégation de propriétés à l'aide de certaines méthodes standard mentionnées dans la bibliothèque Kotlin.
La délégation signifie passer la responsabilité à une autre classe ou méthode. Lorsqu'une propriété est déjà déclarée à certains endroits, nous devons réutiliser le même code pour les initialiser. Dans les exemples suivants, nous utiliserons une méthodologie de délégation standard fournie par Kotlin et une fonction de bibliothèque standard tout en implémentant la délégation dans nos exemples.
Utilisation de Lazy ()
Lazy est une fonction lambda qui prend une propriété comme entrée et en retour donne une instance de Lazy<T>, où <T> est essentiellement le type des propriétés qu'il utilise. Jetons un œil à ce qui suit pour comprendre comment cela fonctionne.
val myVar: String by lazy {
"Hello"
}
fun main(args: Array<String>) {
println(myVar +" My dear friend")
}Dans le morceau de code ci-dessus, nous passons une variable «myVar» à la fonction Lazy, qui en retour assigne la valeur à son objet et la renvoie à la fonction principale. Voici la sortie dans le navigateur.
Hello My dear friendDelegetion.Observable ()
Observable () prend deux arguments pour initialiser l'objet et renvoie le même à la fonction appelée. Dans l'exemple suivant, nous verrons comment utiliser la méthode Observable () pour implémenter la délégation.
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("Welcome to Tutorialspoint.com") {
prop, old, new ->
println("$old -> $new")
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "first"
user.name = "second"
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
first -> secondEn général, la syntaxe est l'expression après la délégation du mot-clé «by». leget() et set() méthodes de la variable p sera déléguée à son getValue() et setValue() méthodes définies dans la classe Delegate.
class Example {
var p: String by Delegate()
}Pour le morceau de code ci-dessus, voici la classe de délégué que nous devons générer pour affecter la valeur dans la variable p.
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
}
}Pendant la lecture, la méthode getValue () sera appelée et lors de la définition de la variable, la méthode setValue () sera appelée.
Kotlin est un langage typé statiquement, par conséquent, les fonctions y jouent un grand rôle. Nous sommes assez familiers avec la fonction, car nous utilisons la fonction dans tous les exemples. La fonction est déclarée avec le mot-clé «fun». Comme toute autre POO, il a également besoin d'un type de retour et d'une liste d'arguments d'option.
Dans l'exemple suivant, nous définissons une fonction appelée MyFunction et à partir de la fonction principale, nous appelons cette fonction et passons un argument.
fun main(args: Array<String>) {
println(MyFunction("tutorialsPoint.com"))
}
fun MyFunction(x: String): String {
var c:String = "Hey!! Welcome To ---"
return (c+x)
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
Hey!! Welcome To ---tutorialsPoint.comLa fonction doit être déclarée comme suit -
fun <nameOfFunction>(<argument>:<argumentType>):<ReturnType>Voici quelques-uns des différents types de fonctions disponibles dans Kotlin.
Fonction Lambda
Lambda est une fonction de haut niveau qui réduit considérablement le code de la plaque de la chaudière tout en déclarant une fonction et en la définissant. Kotlin vous permet de définir votre propre lambda. Dans Kotlin, vous pouvez déclarer votre lambda et transmettre ce lambda à une fonction.
Jetez un œil à l'exemple suivant.
fun main(args: Array<String>) {
val mylambda :(String)->Unit = {s:String->print(s)}
val v:String = "TutorialsPoint.com"
mylambda(v)
}Dans le code ci-dessus, nous avons créé notre propre lambda connu sous le nom de «mylambda» et nous avons passé une variable à ce lambda, qui est de type String et contient une valeur «TutorialsPoint.com».
Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
TutorialsPoint.comFonction en ligne
L'exemple ci-dessus montre la base de l'expression lambda que nous pouvons utiliser dans l'application Kotlin. Maintenant, nous pouvons passer un lambda à une autre fonction pour obtenir notre sortie, ce qui fait de la fonction appelante une fonction en ligne.
Jetez un œil à l'exemple suivant.
fun main(args: Array<String>) {
val mylambda:(String)->Unit = {s:String->print(s)}
val v:String = "TutorialsPoint.com"
myFun(v,mylambda) //passing lambda as a parameter of another function
}
fun myFun(a :String, action: (String)->Unit) { //passing lambda
print("Heyyy!!!")
action(a)// call to lambda function
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur. En utilisant la fonction en ligne, nous avons passé un lambda comme paramètre. Toute autre fonction peut être transformée en fonction en ligne à l'aide du mot-clé «inline».
Heyyy!!!TutorialsPoint.comKotlin contient de nombreuses fonctionnalités d'autres langages de programmation. Il vous permet de déclarer plusieurs variables à la fois. Cette technique est appelée déclaration de destruction.
Voici la syntaxe de base de la déclaration de déstructuration.
val (name, age) = personDans la syntaxe ci-dessus, nous avons créé un objet et défini tous ensemble dans une seule instruction. Plus tard, nous pouvons les utiliser comme suit.
println(name)
println(age)Voyons maintenant comment nous pouvons utiliser la même chose dans notre application réelle. Prenons l'exemple suivant où nous créons une classe Student avec certains attributs et plus tard, nous les utiliserons pour imprimer les valeurs d'objet.
fun main(args: Array<String>) {
val s = Student("TutorialsPoint.com","Kotlin")
val (name,subject) = s
println("You are learning "+subject+" from "+name)
}
data class Student( val a :String,val b: String ){
var name:String = a
var subject:String = b
}Le morceau de code ci-dessus donnera la sortie suivante dans le navigateur.
You are learning Kotlin from TutorialsPoint.comLa gestion des exceptions est une partie très importante d'un langage de programmation. Cette technique empêche notre application de générer une sortie erronée lors de l'exécution. Dans ce chapitre, nous allons apprendre à gérer les exceptions d'exécution dans Kotlin. Les exceptions de Kotlin sont assez similaires aux exceptions de Java. Toutes les exceptions sont des descendants de la classe «Throwable». L'exemple suivant montre comment utiliser la technique de gestion des exceptions dans Kotlin.
fun main(args: Array<String>) {
try {
val myVar:Int = 12;
val v:String = "Tutorialspoint.com";
v.toInt();
} catch(e:Exception) {
e.printStackTrace();
} finally {
println("Exception Handeling in Kotlin");
}
}Dans le morceau de code ci-dessus, nous avons déclaré une chaîne et plus tard lié cette chaîne à l'entier, qui est en fait une exception d'exécution. Par conséquent, nous obtiendrons la sortie suivante dans le navigateur.
val myVar:Int = 12;
Exception Handeling in KotlinNote - Comme Java, Kotlin exécute également le bloc finally après avoir exécuté le bloc catch.