Guide de démarrage rapide pour Android en Kotlin

Ce guide rapide sur Kotlin récapitule les sujets abordés dans le cours sur les Principes de base d'Android en Kotlin sous la forme d'extraits de code.

En savoir plus

  • Pour en savoir plus, consultez la documentation sur le langage Kotlin.
  • Consultez la page Kotlin Koans pour vous entraîner sur des extraits supplémentaires. Remarque : Vous accéderez à un site externe, kotlinlang.org, développé par JetBrains.

Module 1

Programmes Kotlin

Le plus petit programme main() pour l'impression de texte

fun main() {
    println("Hello, world!")
}

Imprimer une ligne de texte

println("This is the text to print!")

Commentaires intégrés

// This is a comment line.
// This is another comment.

Variables

// Assign once, cannot change.
val age = "5"
val name = "Rover"

// Assign and change as needed.
var roll = 6
var rolledValue: Int = 4

Imprimer des variables avec des modèles de chaînes

println("You are already ${age}!")
println("You are already ${age} days old, ${name}!")

Types de données

Int       // Whole positive and negative numbers and zero
String    // Piece of text between quotes
IntRange  // Setting a range such as 1..6
Boolean   // Can only be true or false

Fonction sans arguments

// Define the function.
fun printHello () {
    println ("Hello Kotlin")
}

// Call the function.
printHello()

Fonction avec arguments

fun printBorder(border: String, timesToRepeat: Int) {
    repeat(timesToRepeat) {
        print(border)
    }
    println()
}

Fonction qui renvoie une valeur

fun roll(): Int {
     val randomNumber = (1..6).random()
     return randomNumber
}

Principaux opérateurs

*     // multiplication
/     // division
+     // addition
-     // subtraction
=     // assignment

Opérateurs logiques

>    // greater than
<    // less than
==   // equal
>=   // greater or equal
<=   // less or equal
!=   // not equal

Créer des nombres au hasard

val randomNumber = diceRange.random()

fun roll() {
     val anotherRandomNumber = (1..6).random()
     println(randomNumber)
}

Contrôler le flux du programme

Répéter une action avec repeat()

fun printBorder() {
    repeat(23) {
        print("=")
    }
}

Imbriquer des boucles repeat()

fun printCakeBottom(age: Int, layers: Int) {
    repeat(layers) {
        repeat(age + 2) {
            print("@")
        }
        println()
    }
}

Instructions conditionnelles avec if/else

fun main() {
   val num = 4
   if (num > 4) {
       println("The variable is greater than 4")
   } else if (num == 4) {
       println("The variable is equal to 4")
   } else {
       println("The variable is less than 4")
   }
}

Instructions conditionnelles avec when

when (rollResult) {
    luckyNumber -> println("You won!")
    1 -> println("So sorry! You rolled a 1. Try again!")
    2 -> println("Sadly, you rolled a 2. Try again!")
    3 -> println("Unfortunately, you rolled a 3. Try again!")
    4 -> println("No luck! You rolled a 4. Try again!")
    5 -> println("Don't cry! You rolled a 5. Try again!")
    6 -> println("Apologies! you rolled a 6. Try again!")
}

Attribuer le résultat d'une instruction when à une variable

// Determine which drawable resource ID to use based on the dice roll.
val drawableResource = when (diceRoll) {
    1 -> R.drawable.dice_1
    2 -> R.drawable.dice_2
    3 -> R.drawable.dice_3
    4 -> R.drawable.dice_4
    5 -> R.drawable.dice_5
    else -> R.drawable.dice_6
}

Classes

Classe simple avec propriété et méthode

class Dice {
    var sides = 6

    fun roll() {
        val randomNumber = (1..6).random()
        println(randomNumber)
    }
}

Classe avec paramètre

class Dice (val numSides: Int) {

    fun roll(): Int {
        val randomNumber = (1..numSides).random()
        return randomNumber
    }
}

Créer des instances

val myFirstDice = Dice(6)

Module 2

Classes

Classe abstraite

abstract class Dwelling() {
}

Classe abstraite avec une propriété abstraite

abstract class Dwelling() {
    abstract val buildingMaterial: String
}

Classe abstraite avec une méthode abstraite

abstract class Dwelling() {
    abstract fun floorArea(): Double
}

Marquer une classe open pour qu'elle puisse être sous-classée

open class RoundHut(residents: Int) {
}

Créer une sous-classe en étendant une classe parente

class SquareCabin : Dwelling()

Remplacer une fonction d'une super-classe

override fun floorArea(): Double {
}

Appeler l'implémentation de la super-classe d'une fonction

override fun floorArea(): Double {
    return super.floorArea() * floors
}

Listes

Définir une liste en lecture seule

val numbers = listOf(1, 2, 3, 4, 5, 6)

Obtenir la taille de la liste

numbers.size

Obtenir le premier élément d'une liste

numbers[0]

Obtenir la copie d'une liste dans l'ordre inverse

listOf("red", "blue", "green").reversed()

Définir une liste de chaînes modifiable

val entrees = mutableListOf<String>()

Ajouter un élément à une liste modifiable

entrees.add("spaghetti")

Modifier un élément dans une liste modifiable

entrees[0] = "lasagna"

Supprimer un élément d'une liste modifiable

entrees.remove("lasagna")

Boucles

Utiliser la boucle for pour itérer les éléments d'une liste

for (element in myList) {
    // Perform an operation with each item
    println(element)
}

Utiliser la boucle while pour itérer les éléments d'une liste

var index = 0
while (index < myList.size) {
    println(myList[index])
    index++
}

Chaînes

Nombre de caractères dans une chaîne

val name = "Android"
println(name.length)

Utiliser une variable dans un modèle de chaîne

val number = 10
println("$number people")

Utiliser une expression dans un modèle de chaîne

val number = 10
val groups = 5
println("${number * groups} people")

Divers

Instructions augmentées

a += b   // a = a + b
a -= b   // a = a - b
a *= b   // a = a * b
a /= b   // a = a / b

Simplifier l'accès à un objet à l'aide de with

with(squareCabin) {
    println("Capacity: ${capacity}")
    println("Material: ${buildingMaterial}")
    println("Has room? ${hasRoom()}")
}

Importer depuis la bibliothèque mathématique Kotlin

import kotlin.math.PI

Utiliser un nom complet pour une constante de la bibliothèque mathématique Kotlin (aucune instruction d'importation n'est nécessaire)

kotlin.math.PI * radius * radius

Enchaîner des appels ensemble (pour accéder aux propriétés et aux méthodes d'appel)

val stringInTextField = binding.costOfService.text.toString()

Nombre variable d'arguments de fonction

fun addToppings(vararg val toppings: String)

Déclaration de package

package com.example.affirmations.model

Module 3

Sets

Créer un set à partir d'une liste

val numbers = listOf(0, 3, 8, 4, 0, 5, 5, 8, 9, 2)
val setOfNumbers = numbers.toSet()

Définir un set

val set1 = setOf(1,2,3)
val set2 = mutableSetOf(3, 4, 5)

Opérations d'ensemble

set1.intersect(set2) // 3
set1.union(set2) // 1, 2, 3, 4, 5

Maps

Définir une carte modifiable

val peopleAges = mutableMapOf<String, Int>(
    "Fred" to 30,
    "Ann" to 23
)

Définir une valeur dans une carte modifiable

peopleAges.put("Barbara", 42)
peopleAges["Joe"] = 51

Opérations de collection

Effectuer des itérations sur une collection

peopleAges.forEach { print("${it.key} is ${it.value}, ") }
// Fred is 31, Ann is 23, Barbara is 42, Joe is 51,

Transformer chaque élément d'une collection

println(peopleAges.map { "${it.key} is ${it.value}" }.joinToString(", ") )
// Fred is 31, Ann is 23, Barbara is 42, Joe is 51

Filtrer les éléments d'une collection

val filteredNames = peopleAges.filter { it.key.length < 4 }
println(filteredNames)
// {Ann=23, Joe=51}

Autres opérations de collecte

val words = listOf("about", "acute", "balloon", "best", "brief", "class")
val filteredWords = words.filter { it.startsWith("b", ignoreCase = true) }
    .shuffled() // [brief, balloon, best]
    .take(2) // [brief, balloon]
    .sorted() // [balloon, brief]

Fonctions de champ d'application

let

arguments?.let {
    letterId = it.getString(LETTER).toString()
}

apply

binding?.apply {
    ...
    flavorFragment = this@FlavorFragment
}

Divers

Propriété de support

private var _currentScrambledWord = "test"
val currentScrambledWord: String
    get() = _currentScrambledWord

Appels sécurisés

val letterId = intent?.extras?.getString("letter").toString()

Fonctions lambda

val triple: (Int) -> Int = { a: Int -> a * 3 }
println(triple(5))

Objets compagnons


class DetailActivity: AppCompatActivity() {

    ...

    companion object {
        const val LETTER = "letter"
    }

    ...

}

// accessible outside DetailActivity
DetailActivity.LETTER

Délégation de propriété

// syntax
var <property-name> : <property-type> by <delegate-class>()
// example
private val viewModel: GameViewModel by viewModels()

Initialisation tardive

private var wordsList: MutableList<String> = mutableListOf() // has a value at initialization
private lateinit var currentWord: String // needs to be assigned after initialization

Opérateur Elvis

var quantity : Int? = null
quantity ?: 0 // 0
quantity = 4
quantity ?: 0 // 4

Module 4

Coroutines

Déclarer une fonction de suspension

suspend fun getValue(): Double {
    // long running work or calls to other suspend functions
}

Exécuter une fonction de suspension dans GlobalScope

GlobalScope.launch {
    val output = getValue()
}

Appelez la fonction de suspension à partir d'une autre fonction de suspension.

suspend fun processValue() {
    val value = getValue()
    // modify the value
}

Accéder à une tâche de coroutine

val job: Job = GlobalScope.launch {
    val output = getValue()
}

Annuler une tâche de coroutine

job.cancel()

Exécuter une fonction de suspension et bloquer le thread actuel jusqu'à la fin de l'exécution de la fonction

runBlocking {
    val output = getValue()
}

Utiliser la fonction asynchrone pour pouvoir reporter une fonction de suspension

runBlocking {
    val output = await { getValue() }

    println("Output is ${output.await()}")
}

Divers

Déclarer un objet

object DataProviderManager {

}

Intercepter une exception

try {
    // code that may throw an error
} catch (exception: Exception) {
    // handle the thrown exception
}

Créer une classe d'énumération

enum class Direction {
    NORTH, SOUTH, WEST, EAST
}

Accéder à une valeur de classe énumération

val direction = Direction.NORTH

Vérifier les valeurs d'énumération

when (direction) {
    Directon.NORTH -> {

    }
    Direction.SOUTH -> {

    }
    Direction.WEST -> {

    }
    Direction.EAST -> {

    }
}