# 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"

> [color=#E35DDA]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
}

> [color=#E35DDA]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++
}