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 -> {
}
}