Tutoriel de programmation Kotlin

Histoire de Kotlin

Voici des points de repère importants de l’histoire de Kotlin :

Année	Espaces
2016	Kotlin v1.0 a été lancé
2017	Annonce de Google sur le support de première classe de Kotlin dans Android
2018	Kotlin v1.2 est livré avec un module complémentaire de distribution de codes entre JVM et Javascénario
2019	Google a annoncé Kotlin comme son langage de programmation préféré pour Android Développeurs d'applications
2021	Le 20 septembre 2021, Kotlin v1.5.31 a été lancé.

Raisons d'utiliser Kotlin

Voici quelques raisons importantes pour lesquelles Kotlin est largement utilisé :

• Kotlin est un langage à typage statique très facile à lire et à écrire.
• Les programmes Kotlin ne nécessitent pas de points-virgules dans leur programme. Cela rend le code facile et plus lisible.
• Ce langage permet l'échange et l'utilisation d'informations provenant de Java de diverses manières. De plus, Java et le code Kotlin peut coexister dans le même projet.
• Le système de types de Kotlin vise à éliminer NullPointerException du code.
• Il vous faudra moins de temps pour écrire du nouveau code dans Kotlin. Il est encore plus facile de déployer du code Kotlin et de le maintenir à grande échelle.

Caractéristiques de Kotlin

Voici quelques fonctionnalités du Kotlin qui vous assureront du chemin de progression du langage de programmation.

Codage découpé :

Kotlin est un langage de programmation basé sur la POO où la ligne de code peut être réduite jusqu'à 40 %, ce qui fait de Kotlin un choix idéal pour le développement de logiciels ou de sites Web.

Open source:

Kotlin pour Android utilise JVM et combine les fonctionnalités des POO et de la programmation orientée fonctionnelle.

Compilation rapide :

il est facile de compiler le code lorsque vous travaillez avec Kotlin, ce qui entraîne de meilleures performances pour le développement Android, et cela expliquera également quel type de fonction de données peut être utilisé dans l'ensemble du code.

Fonctions d'extension :

Kotlin peut prendre en charge une variété de fonctions d'extension sans apporter aucune modification au code. cela contribue à rendre le code existant plus attrayant et plus magnifique pour les développeurs.

Par Exemple:

Fun String.removeFirstLastChar():
String = this.substring(1, this.length -1)

Ce code aidera à réduire le premier et le dernier caractère de la chaîne, nous pouvons l'appliquer comme :

Val string1 = "Today is cloudy."
Val string2 = string1.removeFirstLastChar()

Sécurité nulle :

Dans Kotlin, le système fait la distinction entre les références nulles et les références non nulles, comme le montre l'exemple Kotlin ci-dessous.

Par exemple, une variable String ne peut pas contenir null :

Var string1: String = "Today is Sunday"
String1 = null  // compilation error
To permit null, we can adjoin the nullable variable :
Var string2: String? = "Today is Sunday"
String2 = null
print(string2)

Interopérable :

Le code Kotlin peut être utilisé par Java et Java les codes peuvent être utilisés avec Kotlin. Donc, si vous avez des connaissances sur Oops programmation, il est facile de passer au développement de Kotlin. De plus, s'il existe des applications écrites en Java, ils peuvent alors être utilisés avec l'environnement de Kotlin.

Outils robustes :

J'aime Java, le code Kotlin peut également être écrit à l'aide de l'IDE ou de l'interface de ligne de commande. Il est facile de travailler avec l'EDI et les erreurs de syntaxe sont également considérablement réduites. Dans le même temps, lorsque vous travaillez avec une interface de ligne de commande, le code doit d’abord être compilé.

Fonte intelligente:

La diffusion intelligente contribue essentiellement à réduire les coûts d’application et à améliorer sa vitesse ou ses performances. Il fonctionne sur la gestion de l'efficacité du code à l'aide de conversion de type ou de valeurs immuables.

Par exemple, si la chaîne est identifiée, alors sa longueur et son nombre peuvent être trouvés à l'aide de la fonction Smart Cast :

Val string1: Any = "Today is Monday"
when(string1)
{
is String  -> string1.length
Is Int -> string1.inc()
}

Faible coût d’adoption :

Kotlin est préféré par les entreprises en raison de la perte de coût d'adoption. Plus important encore, il est facile à apprendre par les développeurs, surtout s'ils ont une formation en programmation.

Configuration de l'environnement Kotlin

Voici les étapes qui vous aident à configurer un environnement de travail en installant Kotlin.

Étape 1) Installez Java

Comme nous l'avons expliqué plus tôt, Kotlin est basé sur Java, vous devez donc installer Java d’abord lors de la planification de l’adoption de Kotlin. Référez-vous à notre Java Tutoriel d'installation.

Étape 2) Installez Java IDE

Heureusement, il y en a plusieurs Java IDE à choisir. Ici, nous avons donné des liens de téléchargement pour vous faciliter un peu les choses.

• Pour télécharger le Eclipse, cliquez ici.
• Pour télécharger le NetBeans, cliquez ici.
• Pour télécharger IntelliJ, cliquez ici.

Dans ce tutoriel Kotlin, nous utiliserons Eclipse.

Étape 3) Installez Kotlin

Pour installer Kotlin dans Eclipse, accédez à la section Aide dans Eclipse Et cliquez sur le Eclipse Option marché.

Maintenant, tapez le mot-clé Kotlin dans le champ de recherche. Cliquez sur l'option Go pour lister le plugin. Il vous donnera un lien du plug-in Kotlin, vous devez installer le plug-in à partir du lien donné.

Veuillez redémarrer le Eclipse IDE, une fois l'installation terminée. Vous pouvez trouver une icône de raccourci dans le coin supérieur droit de Eclipse IDE. C'est une méthode d'accès rapide.

Une autre façon d'accéder à Kotlin dans Eclipse IDE est, allez au Windows, Perspectives, Ouvrir Perspectives, puis choisir l'option Autres. Ici, vous pouvez consulter une liste des plugins installés ultérieurement, comme indiqué ci-dessous.

Une fois que vous avez vérifié l'installation de Kotlin, créons le premier programme Kotlin à l'étape suivante.

Étape 4) Premier programme Kotlin

Commencez par votre premier projet Kotlin. Dans le menu Fichier, choisissez l'option Nouveau, puis sélectionnez-en d'autres et démarrez avec un nouveau projet Kotlin dans la liste.

Vous devez maintenant définir un nom pour le projet et vous êtes prêt à travailler avec Kotlin.

Avec ces étapes simples, le téléchargement est facile Eclipse et Kotlin sur votre système et écrivez immédiatement votre premier programme Kotlin.

Architecture de Kotlin

Une architecture bien construite est importante pour qu'une application puisse faire évoluer ses fonctionnalités et répondre aux attentes de la base d'utilisateurs finaux. Kotlin possède sa propre architecture particulière et distinctive pour allouer la mémoire et obtenir des résultats de qualité pour les développeurs et les utilisateurs finaux.

Les coroutines et les classes de Kotlin architecturent le noyau de manière à produire moins de code passe-partout, à amplifier les performances et à renforcer l'efficacité. Il existe une variété de scénarios dans lesquels le compilateur Kotlin peut réagir différemment, en particulier lorsqu'il sélectionne différents types de langages.

Dans le diagramme d'architecture, il est clair que l'exécution du code se fait en trois étapes simples.

1. Dans la première étape, le fichier « .kt » ou kotlin est ajouté au compilateur.
2. Dans la deuxième étape, le compilateur Kotlin convertit le code en bytecode.
3. Dans la troisième étape, le bytecode est mis dans Java Machine virtuelle et exécuté par la JVM.

Lorsqu'un fichier codé en octets fonctionne sur JVM, ils allument la communication mutuelle entre eux, c'est pourquoi la fonctionnalité de Kotlin appelée interopérabilité pour la naissance de Java ook

La transpiration de Kotlin à JavaLe script se produit lorsque Kotlin cible JavaScénario.

When the JavaLa cible du script est choisie, tout code de Kotlin qui fait partie de la bibliothèque qui navigue avec Kotlin est ensuite renversé avec JavaScénario. Cependant, le Java Le kit de développement (JDK) ou toute bibliothèque Java utilisée est exclu.

Un fichier non-Kotlin n'est pas pris en compte lors d'une telle opération. Lors du ciblage JavaLe fichier de script .kt est converti en ES5.1 par le compilateur Kotlin pour générer un code cohérent pour JavaScript. Le compilateur Kotlin s'efforce d'obtenir une taille de sortie optimale, une interopérabilité avec le module existant, la même fonctionnalité que la bibliothèque standard et une sortie qui est JavaScript lisible.

Il ressort clairement de la discussion que les compilateurs Kotlin peuvent créer un code plus efficace, plus compétent et plus indépendant, ce qui aboutit à un produit logiciel très performant.

Variable Kotlin

Les variables sont utilisées pour stocker les données à manipuler et référencer dans le programme. Il s'agit fondamentalement d'une unité de stockage de données et d'étiquetage qui attend un alias explicatif afin que le programme soit simple à lire et à comprendre. En d’autres termes, nous pouvons dire que les variables sont les conteneurs permettant de collecter des informations.

Dans Kotlin, toutes les variables doivent être déclarées. Cependant, si une variable n’est pas déclarée, cela apparaît comme une erreur de syntaxe. De plus, la déclaration de la variable détermine le type de données que nous autorisons à stocker dans la variable. Dans Kotlin, les variables peuvent être définies à l'aide des mots-clés val et var. Voici la syntaxe de déclaration des variables dans Kotlin :

Var day = "Monday"
Var number = 3

Ici, nous avons déclaré la variable locale day dont la valeur est «Monday' et dont le type est String et une autre variable locale number dont la valeur est 3 et dont le type est Int car ici le littéral est du type entier qui vaut 3.

Les variables locales sont généralement déclarées et initialisées simultanément. Nous pouvons également effectuer certaines opérations lors de l'initialisation de la variable Kotlin.

Nous pouvons effectuer une opération sur la variable du même type de données, comme ici num1 et num2 sont tous deux du même type de données qui est Int, alors que day est du type de données chaîne. Ergo, cela affichera une erreur. Voici une autre technique pour définir des variables dans Kotlin.

var day : String = "GURU99"
var num : Int = 100

Voyons en quoi les mots-clés var et val sont différents les uns des autres.

Var :

Var est comme une variable générique utilisée dans n'importe quel langage de programmation qui peut être utilisée plusieurs fois dans un seul programme. De plus, vous pouvez modifier sa valeur à tout moment dans un programme. Par conséquent, elle est connue sous le nom de variable mutable.

Voici un exemple de variable mutable dans Kotlin :

var num1 = 10
Var num2 = 20
Num1 = 20
print(num1 + num2) // output : 40

Ici, la valeur de num1, qui est de 20, est écrasée par la valeur précédente de num1, qui est de 10. Par conséquent, la sortie de num1 + num2 est de 40 au lieu de 30.

Val :

Val est comme une variable constante, et vous ne pouvez pas modifier sa valeur ultérieurement dans le programme, qui ne peut pas non plus être attribuée plusieurs fois dans un seul programme et ne peut être utilisée qu'une seule fois dans un programme particulier. Ergo, on l’appelle une variable immuable.

Voici un exemple de programme Kotlin de variables immuables dans Kotlin :

Val num1 = 10
Var num2 = 20

Ici, la valeur de num1 qui est 10 ne peut pas être écrasée par la nouvelle valeur de num1 qui est 20, car elle est de type val qui est constante. Le résultat est donc 30 au lieu de 40.

Note: Dans Kotlin, les variables immuables sont préférées aux variables mutables.

Types de données dans Kotlin

Les types de données sont un ensemble de valeurs pertinentes et décrivent les opérations qui peuvent être effectuées sur celles-ci. Semblable à d'autres langages de programmation, Kotlin dispose également de son ensemble prédéfini de types de données tels que Int, Boolean, Char, Double, etc.

Dans Kotlin, chaque type de données est considéré comme un objet.

Maintenant, dans ce didacticiel de base de Kotlin, approfondissons les types de données prédéfinis utilisés dans Kotlin.

Numbers :

Kotlin propose un ensemble de types de données intégrés appelés nombres, qui sont sous-catégorisés en entiers et en virgule flottante. Numbers.

Entiers :

Les nombres entiers sont la catégorie de nombres qui comporte quatre types :

Type	Taille (bits)	Valeur min	Valeur max
Octet	8	- 128	127
Court	16	- 32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 - 1)
Long	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 - 1)

Virgule flottante Numbers :

Virgule flottante Numbers sont les nombres non entiers qui portent des valeurs décimales.

Float : Float est une valeur à virgule flottante simple précision de 32 bits.

Exemple : var : Flottant x = 3.25600

Double: Double est une valeur à virgule flottante double précision de 64 bits.

Exemple : var : Double y = 2456.345587

Booléens :

Le type de données booléens dans Kotlin est important pour représenter les valeurs logiques. Il n'y a que deux valeurs possibles en booléen qui sont vraies ou fausses.

Par Exemple: jour de val = vrai

Val jour2 = faux

Personnage :

Les personnages de Kotlin sont représentés à l'aide du mot-clé appelé char. En Kotlin, les guillemets simples représentent la déclaration de char. En Java, les caractères sont parfois utilisés comme nombres, ce qui n'est pas possible en Kotlin.

Par Exemple:

val onechar = 'x'
print(onechar) //  output : x
Val onedigit = '7'
print(onedigit) // output : 7

Conversion de type Kotlin ou conversion de type Kotlin

La conversion de type est une procédure de conversion d'un type de variable de données en une autre variable de type de données. C'est énormément, également connu sous le nom de Type Casting.

Éminemment, dans Java, un type implicite de conversion de type ou un type implicite de transtypage d'un type de données plus petit vers un type de données plus grand est pris en charge.

For Example : int abc = 15;
Long bcd = abc; // compiles successfully

Cependant, dans Kotlin, la conversion implicite d'un type de données plus petit en un type de données plus grand n'est pas du tout prise en charge, car le type de données int ne peut pas être converti implicitement en type de données long.

For Example : var abc = 15
Val bcd : Long = abc // error

Cependant, dans Kotlin, la conversion de type est effectuée explicitement. Voici les conseils des fonctions d'assistance qui guident la conversion d'une variable de type de données en une autre.

Il existe certaines fonctions d'assistance pré-possédées pour la conversion d'un type de données en un autre :

versInt()

toByte()

raccourcir()

versChar()

trop long()

flotter()

àDouble()

For Example : var abc = 15
Val bcd : Long = abc.toLong() // compiles successfully

Kotlin Operajeudi

OperaLes opérateurs sont des caractères ou symboles importants et spéciaux qui assurent les opérations sur les opérandes qui ont des variables et des valeurs. En Kotlin, il existe un ensemble d'opérateurs qui sont utilisés dans différentes opérations comme les opérations arithmétiques, les opérations d'affectation, les opérations de comparaison, etc.

Arithmétique Operatorseurs :

Les opérateurs arithmétiques sont utilisés pour l'addition, la soustraction, la multiplication, la division et le module.

Opérateur	Sens
+	Ajout (également utilisé pour la concaténation de chaînes)
-	Soustraction Operator
*	Multiplier Operator
/	Division Operator
%	Module Operator

Par Exemple:

var x = 10
var y = 20
var z = ( ( x + y ) * ( x + y ) ) / 2     

Ici, la sortie du code suivant est 45.

Comparaison Operatorseurs :

L'opérateur de comparaison est utilisé pour comparer deux valeurs, deux variables ou deux nombres. Il est utilisé avec le symbole supérieur à ( > ), inférieur au symbole ( < ) et égal au symbole ( ==), différent du symbole ( != ), supérieur à égal au symbole ( >= ), inférieur à égal à symbole(<= ). Le résultat est toujours vrai ou faux.

Par Exemple:

var x = 10
Var y =20
Var z = x < y // Output : true
Var w = x > y // Output : false
Var m = x == y // Output : false

Affectation Operatorseurs :

Affectation OperaLes opérateurs sont utilisés pour assigner les valeurs arithmétiques. Ils sont utilisés avec les symboles tels que +=, -=, *=, /=, %=.

Par Exemple:

var x = 10
var y = 20
var x + = y // Output : 30
Var y - = x // Output : 10
Var x * = y // Output : 200

Incrémentation et décrémentation Operatorseurs :

Les opérateurs d'incrémentation et de décrémentation sont utilisés pour incrémenter et décrémenter les valeurs de la variable ou du nombre. Il est utilisé à l'aide de symboles comme ++ et —.

Il existe deux types d'incrémentation et de décrémentation : pré-incrémentation ++a, post-incrémentation a++, pré-décrémentation –b, post-décrémentation b–.

Par Exemple:

var a = 10
var b = 20
var c = a++ // Output: 11
var d = b— //Output : 19     

Tableaux Kotlin

Un tableau est l'ensemble homogène de types de données et constitue l'un des types de données les plus fondamentaux utilisés pour stocker les mêmes types de données dans un emplacement mémoire contigu. Un tableau est important pour l'organisation des données dans n'importe quel langage de programmation, de sorte que plusieurs données stockées au même endroit soient faciles à rechercher ou à trier.

Dans Kotlin, les tableaux sont une collaboration mutable des mêmes types de données plutôt que d'être des types de données natifs.

Voici certaines propriétés d'un tableau dans Kotlin

• La taille du tableau ne peut pas être modifiée une fois déclarée.
• Les tableaux dans Kotlin sont mutables.
• Les tableaux sont stockés dans des emplacements de mémoire contigus.
• Un tableau est accessible à l’aide d’index comme a[1], a[2], et – cetera.
• L'index d'un tableau commence par zéro, soit a[0].

Dans Kotlin, un tableau peut être défini de deux manières différentes

En utilisant la fonction arrayOf() :

Dans Kotlin, il existe une utilisation majeure des fonctions de bibliothèque. L'une de ces fonctions de bibliothèque est la fonction arrayOf(), qui est utilisée pour définir un tableau en transmettant les valeurs des variables à la fonction.

Par Exemple: Déclaration de type implicite du tableau à l'aide de la fonction arrayOf()

val x = arrayOf(1,2,3,4,5,6,7,8,9)

Par Exemple: Tapez explicitement la déclaration du tableau à l’aide de la fonction arrayOf().

Val y = arrayOf<Int>(1,2,3,4,5,6,7,8,9)

En utilisant le constructeur de tableau :

Dans Kotlin, il existe une classe nommée Array. Par conséquent, il est possible d’utiliser un tableau du constructeur pour créer un tableau. Le tableau du constructeur contient deux paramètres principaux.

Qu'est-ce que l'index d'un tableau dans Kotlin ?

La fonction où un index de tableau est acceptable pour renvoyer la valeur initiale de l'index.

Par Exemple:

val abc = Array(7 , { i -> i*1})

Ici, la valeur du tableau est 7 et l'expression lambda est utilisée pour initialiser les valeurs de l'élément.

Il existe également différentes méthodes pour accéder et modifier les tableaux à l'aide de certaines fonctions. Par conséquent, il existe deux fonctions membres get() et set(), qui sont utilisées pour accéder aux objets du tableau de classes.

Par Exemple:

val x = arrayOf(10,20,30,40,50,60,70,80,90)
val y = x.get(0) // Output 10

Ici, la sortie est 10 puisque la valeur à l'index 0 du tableau est 10

Remarque : get() ne prend que des valeurs uniques

Par Exemple:

val x = arrayOf(10,20,30,40,50,60,70.80.90)
val y = x.set(2, 3) //

Sortie : 30 40

Ici, la sortie est 30 et 40 puisque la valeur à l'index 2 du tableau est 30 et à l'index 3 elle est 40.

Remarque : set() prend plusieurs valeurs d'un tableau.

Cordes Kotlin

Une chaîne est un type de données de base dans n'importe quel langage de programmation. Une chaîne n'est rien d'autre qu'une séquence de caractères. La classe String représente des chaînes de caractères. Dans Kotlin, toutes les chaînes sont des objets de la classe String, ce qui signifie que les chaînes littérales sont implémentées en tant qu'instances de la classe.

syntaxe:

 Val myString = "Hey there!"

Collection Kotlin

Une collection contient plusieurs objets d'un type similaire, et ces objets de la collection sont appelés éléments ou éléments. La collecte peut aider à stocker, récupérer, manipuler et regrouper des données.

Types de collections :

Collection immuable

Ce type de collection prend en charge des fonctionnalités en lecture seule. On ne peut pas modifier ses éléments.

Les méthodes comprennent:

• Liste – listOf() et listOf ()
• Ensemble – setOf()
• Carte – mapOf()

Collection mutable

Il prend en charge les fonctionnalités de lecture et d’écriture.

Les méthodes incluent

• Liste – mutableListOf(),arrayListOf() et ArrayList
• Ensemble – mutableSetOf(), hashSetOf()
• Carte – mutableMapOf(), hashMapOf() et HashMap

Fonctions Kotlin

Les fonctions dans n'importe quel langage de programmation sont un groupe d'instructions similaires désignées pour effectuer une tâche spécifique. Les fonctions permettent à un programme de le diviser en différents petits blocs de code. Cette division du code augmente la lisibilité du code, la réutilisabilité du code et rend un programme facile à gérer.

Comme Kotlin est connu comme un langage typé statiquement. Ici, le mot-clé 'fun' est utilisé pour déclarer une fonction. Dans Kotlin, il existe deux types de fonctions qui dépendent uniquement de leur disponibilité dans la bibliothèque standard ou de la définition de l'utilisateur. Ils sont:

• Fonction de bibliothèque standard
• Fonction définie par l'utilisateur

Discutons-en maintenant en détail avec des exemples de code Kotlin.

Fonction de bibliothèque standard

Ce sont des fonctions de bibliothèque intégrées qui peuvent être définies implicitement et disponibles pour utilisation.

Par exemple 2 :

fun main(args: Array<String>){  
var number = 9  
var result = Math.sqrt(number.toDouble())  
print("$result")  
}  

Sortie :

3.0

sqrt() est une fonction définie dans la bibliothèque qui renvoie la racine carrée d'un nombre.

La fonction print() imprime le message sur un flux de sortie standard.

Fonction définie par l'utilisateur

Comme leur nom l'indique, ces fonctions sont généralement créées par les utilisateurs et peuvent être utilisées pour une programmation avancée.

Ici, les fonctions sont déclarées à l'aide du mot-clé 'fun'.

Par exemple 3 :

fun functionName(){
//body of the code
}

Ici, nous appelons la fonction pour exécuter des codes à l'intérieur du corps functionName()

Exemples de fonctions Kotlin :

fun main(args: Array<String>){  
    sum()  
    print("code after sum")  
}  
fun sum(){  
    var num1 =8  
    var num2 = 9  
    println("sum = "+(num1+num2))  
}  

Sortie :

somme = 17

code après somme

Gestion des exceptions dans Kotlin

Une exception en programmation est définie comme un problème d'exécution qui se produit dans le programme, entraînant sa fin. Ce problème peut survenir en raison d'un espace mémoire réduit, d'un tableau déconnecté ou de conditions telles que la division par zéro. Pour réduire ces types de problèmes lors de l’exécution du code, la gestion des exceptions est utilisée.

La gestion des exceptions est définie comme la technique qui gère les problèmes d'exécution et maintient également le flux du programme pendant l'exécution.

Kotlin utilise l'expression « throw » pour lancer un objet d'exception. Ici, toutes les classes d'exception sont des descendantes de la classe Throwable.

Lancer MyException("lance une exception")

Il existe quatre types d'exceptions dans la gestion des exceptions. Ils sont:

• try – Ce bloc contient des instructions qui pourraient créer l'exception. Il est toujours suivi soit de catch, soit de final, soit des deux.
• catch – il intercepte une exception levée depuis le bloc try.
• enfin - Il vérifie toujours si l'exception est gérée ou non.
• throw – Il est utilisé pour lever explicitement une exception.

Essayez d'attraper :

Dans le bloc try-catch dans la gestion des exceptions, le bloc try enferme le code, qui peut lever une exception et le bloc catch intercepte l'expression et la gère.

Syntaxe du bloc try catch :

try{    
//code with exception    
}catch(e: SomeException){  
//code handling exception  
}    

Syntaxe de try avec enfin bloquer

try{    
//code with exception    
}finally{  
// code finally block  
}   

Enfin:

Dans Kolin, enfin block vérifie toujours si l'exception est gérée ou non, ce qui en fait une déclaration très importante de gestion des exceptions.

Par exemple 4 :

Dans cet extrait de code, l’exception se produit et elle est gérée.

fun main (args: Array<String>){  
    try {  	
        val data =  9/ 0  
        println(data)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("finally block executes")  
    }  
    println("write next code")  
}  

Sortie :

java.lang.ArithmeticException: / by zero
finally block executes
write next code

Projection :

Le bloc Throw lève une exception explicite. De plus, il est utilisé pour lancer des exceptions personnalisées.

syntaxe:

Throw SomeException()

Throw SomeException()

Exemple :

fun main(args: Array<String>) {
    try{
        println("Exception is not thrown yet")
        throw Exception("Everything is not well")
        println("Exception is thrown")
    }
    catch(e: Exception){
        println(e)

    }
    finally{
        println("You can't ignore me")
    }
}

Sortie :

Sécurité nulle de Kotlin

Les types de systèmes prenant en charge Kotlin font principalement la distinction entre les références pouvant contenir des références nullables et celles qui ne peuvent pas contenir de références nullables. Kotlin est un langage de sécurité nul visant à éliminer l'exception de pointeur nul ou la référence nulle du code, délibérément connue sous le nom de A. BillErreur de dollar.

La pierre d’achoppement la plus conventionnelle parmi tant d’autres langages de programmation est-ce qu'en accédant à un membre d'une référence nulle, il en résulte une NullPointerException, ce qui pourrait être dû à !! opérateur ou ce constructeur utilisé ailleurs et passé à un autre point du code. La propriété nullable nécessite une confirmation de la vérification nulle à chaque fois avant son utilisation.

Dans Kotlin, le système fait la distinction entre les références nulles et les références non nulles.

Par exemple, une variable String ne peut pas contenir null :

Par exemple 5 :

fun main(args: Array<String>){
    var x: String = "GURU99 is the only place where you will get maximum technical content!" // Not Null by default
    println("x is : $x")
    // You cannot assign null variable to not-nullable variables 
    // a=null // it will give compilation error
    var y: String? = "Thanks for visiting GURU99" 
// Nullable Variable
    println("y is : $y")
    y = null
    println("y is : $y")
}

Sortie :

POO Kotlin

L'approche de programmation orientée objet permet de diviser un extrait de code complexe en blocs de code plus petits en créant des objets. Ces objets partagent mutuellement deux caractéristiques : l’état et le comportement.

Voici quelques-uns des éléments de la POO dont nous allons discuter avec des exemples de code Kotlin :

• Classe et objets
• Constructeurs
• Droit des successions
• Classe abstraite

Cours à Kotlin

Avant de créer un objet, nous devons définir une classe également connue sous le nom de modèle de l'objet.

syntaxe:

class ClassName {
    // property
    // member function
    ... .. ...
}

Objets à Kotlin

Lors de la définition d'une classe, nous définissons uniquement les spécifications de l'objet, aucun autre paramètre comme la mémoire ou le stockage n'est alloué.

syntaxe:

var obj1 = ClassName()

Constructeurs à Kotlin

Un constructeur est un moyen d'initialiser les propriétés d'une classe. C'est une fonction membre appelée lorsqu'un objet est instancié. Mais à Kotlin, cela fonctionne différemment.

Il existe deux types de constructeurs dans Kotlin :

Constructeur principal : méthode optimisée pour initialiser une classe

syntaxe:

class myClass(valname: String,varid: Int) {  
    // class body  
}  

Constructeur secondaire : aide à ajouter une logique d'initialisation

Héritage Kotlin

L'héritage se produit lorsque certaines propriétés de la classe parent sont acquises par la classe enfant. L'héritage est autorisé lorsque deux classes ou plus ont les mêmes propriétés.

syntaxe:

open class ParentClass(primary_construct){
    // common code
  }class ChildClass(primary_construct): ParentClass(primary_construct_initializ){
    // ChildClass specific behaviours
  }

Cours abstrait à Kotlin

Une classe abstraite est une classe qui ne peut pas être instanciée, mais nous pouvons en hériter des sous-classes. Le mot-clé 'abstract' est utilisé pour déclarer une classe abstraite.

Par exemple 6 :

  open class humanbeings { 
    open fun Eat() { 
        println("All Human being Eat") 
    } 
} 
abstract class Animal : humanbeings() { 
    override abstract fun Eat() 
} 
class Cat: Animal(){ 
    override fun Eat() { 
        println("Cats also loves eating") 
    } 
} 
fun main(args: Array<String>){ 
    val lt = humanbeings() 
    lt.Eat() 
    val d = Cat() 
    d.Eat() 
} 

Sortie :

Le présent et l'avenir de Kotlin

Le présent:

• De nombreuses entreprises comme Netflix, Pinterest et Corda utilisent Kotlin pour créer de puissants Android applications.
• En une courte période d'un an, de 2016 à 2017, Kotlin est devenu très populaire grâce à ses fonctionnalités de programmation étonnantes.
• En 2017, Google a annoncé Kotlin comme langage de programmation officiel pour le développement Android.
• Vous pouvez remplacer rapidement Java code avec Kotlin car il est 100% interopérable avec Java Android.

L'avenir:

• Développement de jeux multiplateformes
• Développement d'applications mobiles multiplateformes
• Scripts côté service et microservices
• Apprentissage automatique & l'analyse des données

Résumé

• Kotlin est un langage de programmation proposé par JetBrains en 2010 pour les applications multiplateformes sous licence Apache 2.0.
• Le nom Kotlin est dérivé du nom de l'île Kotlin dans une correspondance similaire de Java d'après le nom d'une île appelée Java.
• En 2016, la première version v1.0 de Kotlin a été lancée
• Les programmes Kotlin ne nécessitent pas de points-virgules dans leur programme. Cela rend le code facile et plus lisible.
• Kotlin pour Android Developers est un langage de programmation basé sur la POO dans lequel la ligne de code peut être réduite jusqu'à 40 %, ce qui fait de Kotlin un choix idéal pour le développement de logiciels ou de sites Web.
• Dans Kotlin, toutes les variables doivent être déclarées à l'aide des mots-clés var et val.
• Semblable à d'autres langages de programmation, Kotlin dispose également de son ensemble prédéfini de types de données tels que Int, Boolean, Char, Double, etc.
• Dans Kotlin, il existe un ensemble d'opérateurs utilisés dans différentes opérations telles que les opérations arithmétiques, les opérations d'affectation, les opérations de comparaison, etc.
• Dans Kotlin, les tableaux sont une collaboration mutable des mêmes types de données plutôt que d'être des types de données natifs.
• Dans Kotlin, les tableaux sont définis à l'aide de deux méthodes : ArrayOF() et Constructors.
• Kotlin est un langage de sécurité nul qui permet de supprimer l'exception de pointeur nul ou la référence nulle du code, délibérément appelée A. BillErreur de dollar.