2021-02-18 | Android | Kotlin

tags: kotlin android gobelins

Visibilité

Permet de définir la portée d'une variable / classe

• public : visible partout
• private : visible dans la classe / le fichier
• protected : visible par les classes filles
• internal : visible dans le module

Variables

Définition

• Variable immuables : contante non modifiable définit par val
• Varibales mutables : variable modifiable définit par var

// Variable immuable
val aInt: Int = 14 // 14
aInt = 20 // Val cannot be reassigned

// Variable mutable
var aInt2: Int = 2 // 2
aInt2 = 14 // 14

Typage

Le typage n'est pas obligatoire : inférence de type. Mais attention, kotlin est quand même un langage typé !

val myInt = 12 // 12
var myString = "hophop" // hophop
myString = "hopla" // hopla
myString = 42 // The integer literal does not conform to the expected type String
val str: String = 56 // The integer literal does not conform to the expected type String

Nullable

Par défaut, une variable n'est pas nullable. Mais on peut déclarer une variable null en ajoutant un point d'interrogation. En ajoutant ceci, la variable peut être null ou pas.

val nulStr: String = null // Null can not be a value of a non-null type String
var nullableStr: String? = null // null
nullableStr = "bonjour" // bonjour

Puisqu'une variable peut être null, il faut ajouter des tests pour voir si la variable est null lorsqu'on veut faire une action dessus.

var myString: String? = null
myString.length // Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
myString?.length // null

String interpolation

Voici une méthode pour concaténer une chaine de caractères avec des variables :

val name = "Dumbo"
val age = 42
val ville = "Paris"

// Concaténation simple
var myStr: String = "Hello, je m'appelle $name, j'ai $age and, et j'habite à $ville"

// Concaténation avec des formules
var mySecondStr = "Mon nom est long comme ça : ${name.length}"

Fontions

La déclaration d'une fonction est constitué de 6 élémednts :

• La visibilité
• Le mot clé fun
• Le nom de la fonction
• Les paramètres
• Le type de retour
• Le code

Voici un exmeple :

private fun sayHello(name: String): String {
    return "Hello $name"
} 

// Expression simplifiée s'il n'y a qu'une instruction
private fun sayHello(name: String): String = return "Hello $name"

Une fonction retourne un type Unit par défaut

Argument optionnel

On peut donner une valeur optionnelle à un argument d'une fonction. Voici un exemple :

fun sum(a: Float = 12f, b: Float) = a.plus(b)
val result = sum(b = 50f)

Contrôle de flow

If / else

Voici quelques exemples :

val a = 2
val b = 4
if(a > b) {
    // code
} else if(a > b) {
    // code
} else {
    // code
}

When (ou Switch)

Le When est l'équivalent du switch. Voici un exemple :

val a = 2

// Simple
when(a) {
    0 -> // code
    2 -> // code
    else -> // code
}

// Avec plusieurs valeurs
when(a) {
    0,1,2 -> // code
    3,4,5 -> // code
    else -> // code
}

// Avec des comparaisons
when {
    a > 0 -> // code
    a < 0 -> // code
    else -> // code
}

// Avec des plages de valeurs
when {
    a in 0..10 -> // code
    a in 10..25 -> // code
    a > 25 -> // code
    else -> // code
}

Le else n'est pas obligatoire si tout les cas sont couverts

Boucle for

Voici un exemple d'utilisation de la boucle for :

// Incrémentation simple par défaut = 1
for(i in 0 until 10) {
    println("Valeur de i : $i")
}

// Itération d'une max à une min -> décrémentation de 1
for(i in 10 downTo 0) {
    println("Valeur de i : $i")
}

// En modifiant le pas
for(i in 0 until 10 step 2) {
    println("Valeur de i : $i")
}

// Sur une plage de valeurs
for(i in 0..10) {
    println("Valeur de i : $i")
}

While

Voici un exemple d'utilisation de la bucle while :

var index = 0

// Sur une plage de valeurs
while(index in 0..10) {
    // code
    index++
}

// Avec une valeur maximum
while(index < 100) {
    // code
    index++
}