Kotlin : Fonction

Temps : 30, 10, 20 min.
Diffiulté : *

Cette partie approfondie le concept de fonction avec le langage Kotlin :

1. Déclaration de fonction
2. Expression Lambda
3. Exention de fonction

1. Déclaration de fonctions

Fonction à expression simple

En Kotlin, la déclaration de fonction a plusieurs syntaxes.
Elle peut être écrite en expression simple, Single-expression functions, lorsque le corps de la fonction ne fait pas plus d'une ligne.
La syntaxe est alors caractérisé par la présence du symbôle égal =.

1. Dans le fichier Fun.kt, définissez la fonction showAquarium()

    
    package beach.aqua

    fun showAquarium() = println("This is an aquarium.")
    
    

2. Déclarez une variable appellant la fonction showAquarium() et affichez-là, depuis main()

    
    package beach.aqua
    ...
    fun main() {
        val isUnit = showAquarium()
        println(isUnit)
    }
    
    

3. Exécutez la fonction main() (Control + Shift + R)

Note : En Kotlin, tout a une valeur, sauf les boucles, ici le type kotlin.Unit est renvoyé.

Tout a une valeur

En Kotlin, un extrait de code peut être enregistrée directement dans une variable.

1. Dans la fonction main(), déclarez une variable immuable et assignez lui un extrait de code if else

    
    package beach.aqua
    ...
    fun main() {
      val temperature = 10
      val isHot = if (temperature > 50) true else false
      println(isHot)
    }
    
    

2. Exécutez la fonction main()

Fonction originale

En Kotlin, une fonction contient généralement un corps entre ses accolades et déclare optionnellement :

• des paramètres, entre parenthèses (nb: Int)
• un type de retour, précédé de :, à la suite des paramètres

1. Dans le fichier Fun.kt, déclarez une fonction dont le type de retour est String

    
    fun randomBeach() : String {
        val beachArray = arrayOf("Plage des Rochers", "Praia de Carcavelos", "Playa de la Barceloneta", "Plage des ondes", "Copacabana", "Ipanema", "Bahamas")
        return beachArray[Random.nextInt(beachArray.size)]
    }
    
    

2. La fonction nextInt() sur Random est définie dans kotlin.random.Random. Ajoutez l'importation nécessaire :

    
    package beach.aqua

    import kotlin.random.Random
    
    

3. Affichez le résultat de la fonction randomBeach() dans la fonction main(), puis exécutez là

    
    package beach.aqua
    ...
    fun main() {
      println(randomBeach())
    }
    
    

4. Ecrivez une fonction avec un paramètre Int et un type de retour String :

    
    fun whereIsAquarium(aquariumId: Int) : String {
        val beachArray = arrayOf("Plage des Rochers", "Praia de Carcavelos", "Playa de la Barceloneta", "Plage des ondes", "Copacabana", "Ipanema", "Bahamas")
        val beach : String
        when (aquariumId) {
            1 -> beach = beachArray[3]
            2 -> beach = beachArray[0]
            3 -> beach = beachArray[5]
            4 -> beach = beachArray[4]
            5 -> beach = beachArray[1]
            else -> beach = beachArray[2]
        }
        return beach
    }
    
    

5. Affichez le résultat de la fonction whereIsAquarium(3) dans la fonction main(), puis exécutez
6. Comment éviter la répétition de déclaration du tableau ?
7. Comment éviter l'utilisation de la variable beach dans whereIsAquarium() ?
8. Comment mettre un paramètre par défaut à la fonction whereIsAquarium() ?

Une fonction peut préciser un ou plusieurs paramètre·s par défaut (example de signature : fun move(dx: Int = 5, dy: Int = 5)).
Lorsqu'il y a plusieurs paramètres dont certain·s ont une valeur précisée par défaut, le nommage est obligatoire, lors de l'appel de la fonction.

2. Expression Lambda

En Kotlin, une expression lambda décrit une fonction, elle est remarquable avec ses accolades { }.
Tout comme les fonctions anonymes, elle n'a pas de nom.
L'intérêt est de passer cette une expression comme une donnée.
Par ailleurs, les règles de syntaxes lui étant associées permettent d'épurer le code :

• une expression lamda est toujours dans des accolades { paramètres -> corps }
• la syntaxe complète est btn.setOnClickListener({ v: View -> println("H!") })
• si le type du paramètre est évident, d'après le contexte, alors on l'enlève btn.setOnClickListener({ v -> println("H!") })
• si l'expression lamda est le dernier argument, alors on la sort btn.setOnClickListener() { v -> println("H!") }
• les parenthèses vides peuvent être enlevées btn.setOnClickListener { v -> println("H!") }
• si il y a un seul paramètre alors on peut l'enlever (et y accèder via it si besoin) btn.setOnClickListener { println("H!") }

1. Dans le main du fichier Fun.kt, stockez une expression lambda dans une variable et affichez le résultat :

  
  var cleanLevel = 10
  val waterFilter = { clean: Int -> clean / 2 }
  println(waterFilter(cleanLevel))
  
  

2. Exécutez
3. Pour faire propre, utilisez plutôt cette syntaxe :

  
  val waterFilter: (Int) -> Int = { clean -> clean / 2 }
  
  

3. Extension de fonction

En Kotlin, l'extension permet d'étendre une classe existante avec :

• une fonction (ou bien)
• une propriété

1. Dans le main du fichier Fun.kt, écrivez une fonction d'extension pour le type String :

  
  fun String.hasSpaces(): Boolean {
    val found = this.indexOf(' ')
    return found != -1
  }
  
  

2. Testez, Exécutez

  
  println("to to".hasSpaces())
  println("toto".hasSpaces())
  
  

1. Dans le package fish créez une classe AquariumPlant :

  
  class AquariumPlant(val color: String, private val size: Int)
  
  

2. Créez une fonction d'extension au sujet de la propriété color :

  
  fun AquariumPlant.isRed() = color == "red"
  
  

3. Écrivez une fonction pour tester, puis exécutez

  
  fun makeAquaPlant(){
      val plant = AquariumPlant("red", 33)
      println(plant.isRed())
  }
  
  

4. Créez une fonction d'extension au sujet de la propriété private :

  
  fun AquariumPlant.isBig() = size > 50
  
  

5. C'est pas possible
6. Ajoutez une propriété d'extension pour AquariumPlant :

  
  val AquariumPlant.isGreen: Boolean
    get() = color == "green"
  
  

7. Testez, exécutez
8. Créez une fonction d'extension à receveur potentiellement null :

  
  fun AquariumPlant?.pull() {
    this?.apply {
        println("removing $this")
    }
  }
  
  

9. Testez, exécutez

Finalement, Kotlin est un langage de programmation fonctionnelle et orientée objet par rapport à :

• Fonction à expression simple
• Tout a une valeur, Unit, sauf l'exception ?
• Fonction original

Solution de la fonction originale

val beachArray = arrayOf("Plage des Rochers", "Praia de Carcavelos", "Playa de la Barceloneta", "Plage des ondes", "Copacabana", "Ipanema", "Bahamas")
fun whereIsAquarium(aquariumId: Int = 3) : String {
    return when (aquariumId) {
        1 -> beachArray[3]
        2 -> beachArray[0]
        3 -> beachArray[5]
        4 -> beachArray[4]
        5 -> beachArray[1]
        else -> beachArray[2]
    }
}

Référence

developer.android.com: Functions in Kotlin