Voir le flux RSS

tails

[Kotlin] Déclarations/Types/Inférence de types

Noter ce billet
par , 05/09/2017 à 12h04 (122 Affichages)
Déclarations

Comme vous l'avez probablement constaté dans les billets précédents, en Kotlin lors d'une déclaration de variable (val ou var) on précise dans l'ordre :
  1. son immutabilité (val ou var ?) : pour rappel, val désigne une valeur fixée, donc immuable. Alors que var désigne une variable donc muable
  2. son nom : comme en Java, soumis à des restrictions et de plus limité par l'existence de mots-clés propres à Kotlin
  3. son type : nous allons y venir très vite


(Bien sûr dans le cas où l'on utilise pas l'inférence de type, point sur lequel je reviendrais vite fait plus tard dans ce billet).

Ainsi l'on peut écrire :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
var loopCount:Int = 5
val student55 = Student(firstName = "John", lastName = "Doe", age = 36) // Petit spoiler sur la création de classes :p
Les Types

Le type logique : Boolean

Tout d'abord, première remarque, le type Boolean prend une majuscule en Kotlin. Cela sera aussi le cas avec les autres types de Java -qui étaient primitifs en Java et ne le sont plus en Kotlin : le fameux "tout est objet"- qui prenaient une minuscule : Int, Float, Double, Long, Short, Byte.

Rien de nouveau à part cela : true/false sont les deux valeurs possibles, et les opérateurs &&/||/! fonctionnent de la même manière qu'en Java. Vous ne devriez pas être embêté par l'utilisation des Boolean.

Les types numériques

Int, Short, Byte, Long, Float, Double : presque comme en Java, hormis la majuscule.

Déjà, commençons par un détail subtil : la conversion automatique en Wrapper ou primitif par le compilateur Kotlin. En effet, Kotlin essaiera dans la mesure du possible, pour des raisons de performances, de convertir la valeur en type purement primitif, et non en Wrapper. Mais dans certains cas cela sera impossible, par exemple pour l'utilisation de Générics.

Ensuite, la taille mémoire est la même qu'en Java pour chacun des types. (Vérifiez d'ailleurs par vous-même).

Les littéraux sont semblables à Java : 12 est un Int, 12L est une Long, 123_456_789 est autorisé.

Détail très important, si ce n'est le plus important de cette section : il n'y a aucune conversion automatique entre les différents types ! (Aucune coercition ni promotion).

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
val a:Int = 120L.toInt() // ok
// val b:Int = 120L // =>  erreur de compilation !!!
val c:Long = 120 // fonctionne grâce à l'inférence de type !
// val d:Long = a // =>  erreur de compilation !!!
Enfin, les opérateurs de manipulation de bits de Java sont remplacés par des fonctions en Kotlin:
  • shl : équivalent de << (shift left)
  • shr : équivalent de >> (shift right)
  • ushr: équivalent de >>> (unshift right)
  • and()/or()/xor() : équivalents respectifs de &/|/^
  • inv() : inversion de bits


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
val x = (1 shl 2) and 0x000FF000

Les type "Littéraires"

*)Le type Char : pas de difficulté particulière, si ce n'est que convertir un Char vers Int et inversement n'est pas automatique

*)Le type String
Tout d'abord il y a une nouvelle façon de déclarer une String, qui convient au format multilignes :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
"""
Mon
texte
multi lignes
"""
Attention ! Ce format n'échappe pas les caractères spéciaux !
En revanche, si la chaîne est agrémentée d'indentations pour une meilleure mise en forme, voici comment y remédier :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
println("""|Voici
        |une simple
        |façon de traiter
        |une chaine multi lignes.
    """.trimMargin())
Enfin, une fonctionnalité très utile, les templates : elles fonctionnent d'ailleurs aussi bien avec le format standard que le format multi-lignes.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
val name = "Cora"
val age = 10

println("$name a $age an(s)")
Ou encore, adaptons le pluriel de l'âge :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
val name = "Cora"
val age = 10

println("$name a $age an${if (age > 1) "s" else ""}")
Le type range

Qui n'a jamais trouvé laid de devoir sans cesse écrire un code de ce genre en Java ?

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
if (c >= 0 && c <= 10)  { // instructions }
ou encore

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
for (int i=0; i<=10; i++) { // instructions }
C'est là qu'en Kotlin on peut faire intervenir le type Range (Intervalle) :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
if (c in 0..10) { // instructions } // teste si c est supérieur et égal à 0 et inférieur et égal à 10
De même

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
(0..10).forEach { i -> // instructions impliquant i }
Ce code fait intervenir une lambda (fonction anonyme), que nous aurons l'occasion d'étudier ultérieurement.

N'oublions pas le mot-clé when :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
when(x_avion) {
   in 0..10, in 20..30 -> "L'attérissage est râté" // teste si x_avion est ou bien dans 0..10 ou dans 20..30
   in 11..19 -> "L'attérissage est réussi"
   else -> "Vous êtes sûr que l'on joue au même jeu ?"
}
Inférence de types

Vous en avez déjà vu dans les billets précédents, j'ai beaucoup tendance à m'en servir

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
val x = 120 // le compilateur a déduit que x est un Int
val x:Long = 120 // en revanche, le compilateur a déduit que le littéral 120 est à convertir en Long, et comme c'est possible, ça passe.
L'inférence de type désigne toutes les situations où l'on ne déclare pas le type mais que le compilateur parvient à déduire du contexte.
Je n'ai pas encore abordé les fonctions/méthodes, mais ça fonctionne aussi dans ce cas :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
fun Hello() = "Hello, World !"
équivaut à
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
fun Hello():String {
    return "Hello, World !"
}
Dans le premier cas le compilateur a juste déduit que le type de retour est String grâce à l'expression à droite de la déclaration de fonction.

Sachez également que les Closures/Lambdas - qui n'ont pas été abordées - peuvent aussi utiliser l'inférence de type.

Ouf ! Cela fait beaucoup d'informations dans ce billet, même si je n'ai évoqué que des bases.
J'espère que vous avez pris du plaisir à lire ce billet

Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog Viadeo Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog Twitter Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog Google Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog Facebook Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog Digg Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog Delicious Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog MySpace Envoyer le billet « [Kotlin] Déclarations/Types/Inférence de types » dans le blog Yahoo

Mis à jour 08/09/2017 à 14h24 par tails (Ajout du type Range)

Catégories
Java

Commentaires