Propriétés calculées

Bonjour,

dans ce morceau de code:

class Person {
    var health:Int = 100
    
    val isAlive:Boolean
        get() { return health > 0}
    
    fun setAlive() {
        health = 100
    }
}

je ne comprends pas le get(), quelqu’un pourrait m’expliquer svp?

Merci!

Salut Spiderman !

Je ne me suis pas encore penché sur Android et Kotlin, mais ça doit être normalement pareil qu’en Swift.
Donc, « get » permet d’obtenir une valeur dans une propriété calculée.

En l’occurrence la un boolean si, le personnage est en vie.

Du pourrais faire de même avec une fonctionne par exemple :

fun isAlive() -> Boolean {
         if health > 0 {
              return true
         }
         return false
}

en espérant t’avoir aidé

1 J'aime

Classiquement une propriété de classe est une variable. On peut écrire dedans et lire son contenu.

Une propriété calculée est un cas particulier où l’information n’est pas stockée en mémoire, mais calculée par le code au moment de la lecture.

D’après ce que je vois, ton exemple vient d’un jeu vidéo. La classe Person sert à gérer les points de vie d’un personnage.

La propriété isAlive est une information booléenne (ne pouvant avoir que deux valeurs vrai ou faux). Elle permet de savoir si un personnage est vivant ou mort, avec un test simple : s’il lui reste des points de vie, il est vivant.

Je présume qu’il doit y avoir quelque part dans le code, une fonction diminuant le nombre de points de vie, à chaque coups reçu par le personnage.

L’instruction get() indique au compilateur que isAlive n’est pas une vraie variable à stocker en mémoire, mais qu’il faut la calculer a chaque appel.

Personnellement, je n’aurais pas utilisé de propriété calculée si j’avais eu à écrire ce code, mais une vraie variable binaire. Quelque chose comme :

class Person {
    var health:Int = 100
    val isAlive:Boolean = true
    
    fun setAlive() {
        health = 100
        isAlive = true
    }

   fun recevoirDegats(degats:Int) {
       health = health - degats
       if health > 0 {
           isAlive = true
       } else {
           isAlive = false
      }
   }

}

Je ne garantis pas que le code fonctionne. Je n’ai pas testé, et a vrai dire n’ayant pas pratiqué Kotlin depuis longtemps, il est possible que je soit influencé par la syntaxe de Swift. Mais le principe est là.

L’avantage des propriétés calculés, c’est qu’elles permettent de faire des calculs uniquement quand c’est nécessaire. Pour mon exemple, j’ai du précalculer le résultat et le stocker en mémoire.


Techniquement parlant, la solution d’Anthony est meilleure que la mienne. Créer une fonction dans la classe pour savoir si un personnage est vivant ou non est plus simple que gérer une variable interne, notamment à cause des problèmes d’initialisation.

Cependant l’utilisation d’une fonction pour obtenir une information auprès d’une classe n’est pas très esthétique.

// Utilisation d'une fonction
etatPerso = perso3.isAlive()

Il est plus simple et lisible d’utiliser une propriété, comme ceci :

// Utilisation d'une propriété
etatPerso = perso3.isAlive

C’est pourquoi les langages de programmation modernes intègrent la notion de propriétés calculées, pour rendre le code plus facile à lire. On peut s’en passer, mais c’est agréable à l’usage.