Points clés
Apprenez Kotlin en créant une petite application, plutôt qu’en mémorisant un catalogue de fonctionnalités.
Commencez par un problème concret. Le livre enseigne Kotlin en construisant une application météo sur sept jours, au lieu de présenter les fonctionnalités dans des chapitres théoriques. Le projet commence par une liste de prévisions d’exemple, puis évolue pour récupérer de vraies données, afficher des détails, enregistrer les prévisions localement et permettre aux utilisateurs de changer de ville. À chaque étape, des outils du langage sont introduits au moment où ils permettent de résoudre une tâche Android concrète.
La pratique aide à retenir la syntaxe. Le lecteur visé connaît déjà les bases de Java et d’Android. Kotlin est présenté comme une étape pratique: suffisamment familier pour être adopté progressivement, mais assez expressif pour simplifier le travail quotidien. Les lecteurs sont invités à suivre le code dans Android Studio, à l’exécuter et à le modifier, plutôt qu’à se contenter de lire les exemples.
Le projet donne une fonction à chaque nouvelle syntaxe. Une lambda est plus facile à retenir lorsqu’elle remplace un écouteur de clic, et une classe de données prend tout son sens lorsqu’il faut définir la structure d’une réponse d’API. C’est une forme d’apprentissage situé particulièrement efficace : les connaissances s’acquièrent dans le contexte même qui les rend utiles. En contrepartie, un projet peut laisser des lacunes dans la couverture systématique du langage. Les lecteurs devraient considérer l’application comme un apprentissage guidé, et non comme une référence complète du langage.
Remplacez le code passe-partout de Java par des propriétés, des valeurs par défaut et des classes de données.
Laissez le langage prendre en charge les tâches courantes. Les propriétés Kotlin associent un champ à un comportement d’accesseur: le code appelant peut donc lire `person.name`, tandis que des accesseurs personnalisés contrôlent toujours la manière dont cette valeur est traitée. Les fonctions peuvent définir des valeurs par défaut pour leurs paramètres et accepter des arguments nommés, ce qui réduit le nombre de surcharges souvent nécessaires en Java. Le compilateur peut également déduire le type de nombreuses valeurs à partir de ce qui leur est attribué.
Utilisez les classes de données pour représenter les données. Une `data class` Kotlin déclare les propriétés qui définissent un objet, puis génère des méthodes utiles telles que `equals`, `hashCode` et `toString`. Elle fournit aussi `copy` pour créer une instance révisée et des fonctions de composant pour la décomposition. Une prévision peut ainsi être représentée par sa date, sa température et sa description sans qu’il soit nécessaire d’écrire à la main les accesseurs et les comparaisons habituels.
Moins de code passe-partout peut aussi signifier moins d’endroits où des défauts peuvent se cacher. L’égalité et le calcul du hachage générés sont particulièrement utiles, car une version écrite à la main peut facilement omettre un champ sans qu’on s’en aperçoive. Les propriétés rendent également les API plus faciles à lire sans empêcher l’encapsulation. La concision n’est toutefois pas automatiquement synonyme de clarté : une déclaration courte mérite malgré tout des noms explicites, et le comportement généré dépend des propriétés présentes dans le constructeur principal. Il faut se demander si le code raccourci rend plus visible l’intention du modèle.
Rendez la nullabilité visible, puis concevez des valeurs qui changent moins.
Exprimez l’incertitude dans le type. En Kotlin, un type comme `Forecast?` indique explicitement qu’une valeur peut être absente, contrairement à `Forecast`. Le code ne peut pas utiliser une valeur nullable comme si sa présence était garantie. L’opérateur d’appel sûr n’effectue une opération que si une valeur est présente, tandis que l’opérateur Elvis fournit une solution de rechange, par exemple une valeur par défaut ou un retour anticipé. Une assertion de non-nullité (`!!`) permet de forcer l’accès, mais risque de provoquer à l’exécution l’échec que la sécurité contre les valeurs nulles vise à éviter.
Privilégiez les références stables. `val` empêche la réaffectation, tandis que `var` l’autorise. Le livre recommande d’utiliser `val` dans la mesure du possible, car moins de références susceptibles de changer rendent le code plus facile à comprendre, en particulier dans un contexte multithread. La méthode `copy` des classes de données va dans le même sens: elle permet de créer un objet révisé au lieu de modifier l’original.
La nullabilité constitue une forme concise de documentation que le compilateur peut faire respecter. Elle transforme une défaillance courante, susceptible de survenir à l’exécution, en une question de conception du programme. L’immutabilité complète cette garantie en réduisant le nombre de changements d’état que le lecteur doit suivre. Ni l’une ni l’autre n’offre une protection absolue : les bibliothèques Java peuvent exposer des valeurs dont la nullabilité est incertaine, et une référence immuable peut toujours désigner un objet mutable. Une conception sûre exige donc de prêter attention aux objets derrière le type, et pas seulement à la déclaration du type.
Utilisez les fonctions d’extension et les lambdas pour exprimer l’intention au point d’appel.
Placez le comportement près de son utilisation. Une fonction d’extension ajoute une opération appelable à un type existant sans modifier le code source de ce type. Le livre s’appuie sur cette idée pour créer des utilitaires, par exemple une opération d’affichage d’un toast pour les contextes Android. Ces fonctions peuvent remplacer des appels épars à des utilitaires par des opérations lisibles sur l’objet concerné.
Transmettez directement les actions. Une lambda est une fonction anonyme qui peut être stockée ou transmise comme argument. Kotlin peut convertir une lambda en implémentation lorsqu’une API Java attend une interface dotée d’une seule méthode, comme dans le cas d’un écouteur de clic pour une vue. L’adaptateur de l’application météo peut donc accepter une fonction qui reçoit une prévision, sans exiger une interface d’écouteur distincte ni une classe anonyme. Les fonctions de portée telles que `with` permettent de regrouper plusieurs opérations sur un même objet.
Ces fonctionnalités réduisent la distance entre un appel et son objectif. Un gestionnaire de clic peut faire apparaître directement l’action, tandis qu’une extension peut faire lire une opération courante comme si elle faisait partie du vocabulaire du type. Le gain de lisibilité est réel lorsque les utilitaires sont courts et nommés de façon cohérente. Le risque, c’est que les extensions donnent l’impression que la classe elle-même a changé, et que des couches de lambdas concises masquent le déroulement du contrôle. Un bon style Kotlin met son expressivité au service de la clarté de l’opération, plutôt que de la seule compression du code.
Séparez les modèles de l’API, du domaine et de la base de données, puis établissez des correspondances entre eux.
Donnez à chaque couche sa propre structure. L’API météo renvoie une vaste structure JSON contenant des informations sur la ville et de nombreux champs de prévision. L’interface de l’application n’a pas besoin de tous ces champs: le livre analyse donc la réponse en classes de données, puis transforme les informations pertinentes en modèles de domaine plus simples. Les modèles de base de données ont encore une autre fonction: ils correspondent aux colonnes et aux identifiants stockés.
Choisissez délibérément la source. Un fournisseur de prévisions vérifie ses sources dans l’ordre: d’abord la base de données locale, puis le serveur. Il n’accepte un résultat que s’il contient suffisamment de jours de prévision à jour. Lorsque le serveur fournit de nouvelles données, l’application les convertit et les enregistre, puis les relit depuis le stockage. Cette organisation évite que le réseau, la persistance et la logique d’affichage ne s’enchevêtrent dans une seule activité.
Des modèles séparés ne constituent pas une duplication inutile lorsqu’ils protègent différentes frontières. Une API peut modifier ses noms ou sa charge utile sans obliger l’interface à reprendre ces choix, et les identifiants de la base de données n’ont pas à dicter la structure d’un écran. La recherche ordonnée du fournisseur rend également explicite la politique de cache, au lieu de la dissimuler dans une requête. Le coût, c’est du code de correspondance et la coordination entre les couches. Ce coût est justifié lorsque les frontières isolent les changements ; pour une petite application jetable, une structure plus légère peut suffire.
Laissez les opérations sur les collections exprimer le sens d’une transformation.
Décrivez le résultat, pas la boucle. Les fonctions de collection de Kotlin expriment directement les tâches courantes. `filter` sélectionne les éléments qui répondent à une condition, `map` transforme chaque élément et `mapIndexed` fournit également sa position. Dans l’application, les enregistrements de prévision sont convertis en objets de domaine prêts à être affichés, sans qu’il soit nécessaire de construire manuellement une deuxième liste ni de gérer un index.
Composez les opérations avec soin. D’autres fonctions peuvent compter les correspondances, regrouper les éléments, les trier ou trouver le premier résultat approprié. Le livre ajoute même un utilitaire `firstResult` qui parcourt des sources de données jusqu’à ce que l’une d’elles renvoie une prévision non nulle. Kotlin prend aussi en charge les intervalles et les expressions `when` expressives, tandis que les génériques permettent aux fonctions de travailler avec différents types. Ces outils réduisent le contrôle de flux répétitif, mais chaque opération a toujours un coût et un comportement qu’il convient de comprendre.
Un pipeline de collections rend visible la forme de la transformation : sélectionner, convertir et renvoyer. Il est souvent plus facile à examiner qu’une accumulation mutable répartie dans une boucle. Cette approche facilite aussi la réutilisation et les tests de petites opérations. Cependant, une chaîne de transformations peut allouer des collections intermédiaires, et un utilitaire astucieux comme firstResult peut dissimuler une exception lorsqu’aucune source ne réussit. Le meilleur choix dépend à la fois de la lisibilité et du comportement. Un code concis devrait faciliter le suivi des données, et non en faire un casse-tête.
Déléguez les comportements de propriété répétitifs, mais vérifiez le cycle de vie et la mise en cache Android.
Réutilisez la logique des propriétés. Une propriété déléguée confie à un autre objet le comportement de son accesseur ou de son mutateur. Les délégués standard de Kotlin comprennent `lazy`, qui initialise une valeur lors de son premier accès, et `observable`, qui réagit aux affectations. Le livre crée aussi un délégué pour une valeur des préférences partagées (Shared Preferences), qui permet de lire et d’enregistrer le code postal d’une ville au moyen de la syntaxe des propriétés. Un délégué personnalisé montre comment imposer qu’une valeur ne puisse être affectée qu’une seule fois.
Sachez ce que génère le greffon. Kotlin Android Extensions permet au code d’accéder aux vues à l’aide de leurs identifiants XML. Son cache généré fonctionne pour les activités et les fragments; dans le cas des fragments, les vues sont supprimées du cache lorsqu’elles sont détruites. Le livre avertit que l’accès aux vues dans un adaptateur n’utilise pas automatiquement ce cache et présente une approche fondée sur `LayoutContainer` pour un ViewHolder.
La délégation est utile lorsque plusieurs propriétés partagent véritablement la même règle, par exemple l’initialisation différée ou le stockage des préférences. Elle transforme des mécanismes répétitifs en une abstraction réutilisable et permet au code appelant de se concentrer sur la valeur. L’accès généré aux vues offre une commodité similaire, mais celle-ci peut masquer des détails liés au cycle de vie et aux performances. L’inspection du bytecode recommandée par le livre est une bonne habitude : il est plus facile de faire confiance aux abstractions lorsqu’on sait ce qu’elles produisent. Les outils Android ont évolué depuis cette édition ; ses instructions précises sur le greffon doivent donc être considérées comme des exemples historiques, et non comme des conseils de configuration actuels.
Écrivez les flux asynchrones dans l’ordre, sans oublier le cycle de vie des activités.
Gardez une logique lisible. L’exemple commence par utiliser `doAsync` d’Anko pour effectuer une requête réseau hors du thread principal, puis revient au thread de l’interface utilisateur pour mettre l’écran à jour. Il présente ensuite les coroutines, qui permettent d’écrire le travail asynchrone dans un style séquentiel. Dans l’exemple, une opération en arrière-plan renvoie un résultat différé, et le flux de l’interface attend ce résultat avant de lier les prévisions.
Un flux lisible a tout de même un cycle de vie. Le livre souligne qu’un bloc asynchrone peut conserver une référence à une activité après sa destruction par Android. Anko propose une approche fondée sur une référence faible, mais le texte fait remarquer que sa complexité supplémentaire n’en vaut peut-être pas la peine pour une requête courte et limitée. L’essentiel est de ne pas effectuer de travail bloquant sur l’interface utilisateur et de réfléchir à ce qui se passe si l’écran disparaît.
Une syntaxe séquentielle peut faciliter la compréhension des dépendances asynchrones, car le code se lit dans l’ordre où les résultats sont nécessaires. Mais la syntaxe ne résout pas à elle seule la gestion du cycle de vie. Une requête peut survivre à l’écran qui l’a lancée, et la mise à jour d’une activité détruite reste un problème de conception, même lorsque les rappels disparaissent. Le livre refuse à juste titre de présenter une API pratique comme une solution magique. Ses exemples de coroutines appartiennent à une période où Kotlin était expérimental ; les appels de bibliothèque employés ne doivent donc pas être pris pour une prescription Android intemporelle.
Injectez les composants pour que les tests puissent remplacer serveurs, bases de données et fournisseurs.
Rendez les dépendances interchangeables. Au lieu de construire chaque composant à l’intérieur d’une classe, l’application peut recevoir ses dépendances par son constructeur. Les arguments par défaut simplifient l’utilisation ordinaire, tandis que les tests peuvent fournir des objets factices ou des doublures. Le fournisseur de prévisions, par exemple, accepte une liste de sources de données, ce qui permet de vérifier son comportement lorsqu’une source ne renvoie aucun résultat et qu’une autre en renvoie un.
Testez à la bonne frontière. Le livre présente des tests unitaires locaux pour les fonctions qui ne nécessitent pas Android, ainsi que des tests d’instrumentation pour les interactions qui exigent une application en cours d’exécution, comme la sélection d’une prévision ou la modification du code postal d’une ville. Il montre également une difficulté pratique: les classes Kotlin sont fermées par défaut, ce qui peut empêcher certains outils de simulation de les remplacer, à moins que la classe ne soit ouverte, qu’elle n’implémente une interface ou qu’une configuration de simulation adaptée ne soit utilisée.
L’injection par constructeur rend les tests possibles en explicitant les dépendances cachées. Elle clarifie aussi ce dont une classe a besoin pour fonctionner, un avantage qui dépasse le cadre des tests. La distinction entre tests locaux et tests sur appareil est tout aussi importante : des tests rapides peuvent couvrir les transformations et les règles de décision, tandis que les tests d’interface vérifient l’intégration que les tests purs ne peuvent pas contrôler. La simulation ne devrait toutefois pas devenir l’unique moyen de tester la conception. Lorsqu’une classe est difficile à tester sans une simulation élaborée, cette difficulté peut indiquer que ses responsabilités sont trop étroitement liées.
Adoptez Kotlin aux côtés de Java, tout en tenant compte de leur frontière d’interopérabilité.
Migrez sans tout réécrire. Kotlin et Java peuvent coexister dans un même projet Android: une équipe peut donc écrire de nouvelles fonctionnalités en Kotlin tout en conservant le code et les bibliothèques Java existants. Kotlin peut appeler les accesseurs Java au moyen de la syntaxe des propriétés, et Java peut appeler de nombreuses fonctions Kotlin à l’aide des classes et méthodes générées.
La frontière n’est pas invisible. Pour Java, les fonctions d’extension Kotlin apparaissent comme des fonctions statiques dont le récepteur devient un argument. Les arguments par défaut ne sont pas automatiquement accessibles sous forme de surcharges Java, à moins que ces surcharges ne soient générées sur demande. Certaines fonctionnalités, notamment les fonctions génériques réifiées, ne peuvent pas être appelées depuis Java de la même manière. Le conseil pratique du livre est d’adopter Kotlin progressivement, tout en vérifiant la façon dont ses fonctionnalités se présentent aux appelants Java.
L’interopérabilité transforme l’adoption de Kotlin : au lieu d’une réécriture risquée, elle permet une série de choix plus modestes. Cela réduit le risque pour l’organisation et permet aux équipes d’apprendre tout en maintenant un logiciel fonctionnel. Mais une base de code mixte s’adresse à deux publics : les appelants Kotlin et les appelants Java. Une API élégante dans un langage peut être malcommode dans l’autre ; les frontières publiques méritent donc une conception réfléchie. La migration la plus durable n’est pas nécessairement la plus rapide. C’est celle qui préserve des interfaces compréhensibles tout en permettant à chaque nouvel élément Kotlin de faire ses preuves.
Analyse
Ce livre est à la fois une introduction à Kotlin et une démonstration pratique de l’intérêt d’apprendre un langage à travers les problèmes qu’il permet de résoudre. L’application météo lui sert de fil narratif: les données arrivent depuis une API, deviennent des objets de domaine exploitables, s’affichent dans une liste et sur un écran de détails, sont enregistrées localement et réagissent à la modification d’un paramètre. Cette progression donne une raison d’être à des fonctionnalités qui, autrement, paraîtraient sans lien. Les classes de données répondent au code passe-partout des modèles; la nullabilité modifie la représentation des données manquantes; les lambdas simplifient la gestion des événements; et l’injection de dépendances rend le fournisseur testable.
La leçon la plus durable du livre ne tient pas à une fonctionnalité syntaxique en particulier. C’est que l’expressivité de Kotlin prend tout son sens lorsqu’elle s’accompagne de frontières bien définies: séparer les représentations des données, distinguer le travail de l’interface utilisateur de celui du réseau et du stockage, et exposer les dépendances afin qu’elles puissent être remplacées. Les fonctions d’extension et les délégués sont particulièrement efficaces lorsqu’ils rendent ces frontières plus claires. Ils le sont moins lorsque la commodité masque le comportement généré ou les hypothèses liées au cycle de vie.
Cette édition date de 2018 et a été écrite à l’époque de Kotlin 1.1 et des outils Android de cette période. Certaines bibliothèques citées, certains mécanismes de greffon, conventions Gradle et API de coroutines sont propres à leur époque et ne devraient pas être repris dans un projet actuel sans consultation de la documentation contemporaine. L’ancienneté du livre n’efface pas ses idées fondamentales, mais elle change son rôle: il expose clairement les avantages de conception de Kotlin et propose un modèle d’apprentissage pratique; ce n’est pas un guide actuel de mise en œuvre Android. L’application est également volontairement modeste. Son architecture constitue un échafaudage pédagogique utile, et non la preuve que toutes les applications ont besoin du même nombre de couches.
Résumé des avis
Kotlin for Android Developers reçoit des avis partagés. Beaucoup louent son approche pratique et son efficacité pour enseigner Kotlin dans le cadre du développement Android. Les lecteurs apprécient les exemples concrets et les comparaisons avec Java. Certains critiquent toutefois l’organisation du livre, le manque d’instructions claires sur l’emplacement du code et le caractère dépassé de certains contenus. L’utilité du dépôt GitHub fait débat. Malgré ces problèmes, beaucoup le considèrent comme une bonne introduction à Kotlin, en particulier pour les personnes ayant de l’expérience en développement Android. La concision du livre et son style d’écriture chaleureux sont également salués.
Les lecteurs ont aussi lu
Glossaire
classe de données
Classe axée sur les donnéesClasse Kotlin principalement destinée à contenir des valeurs. Le compilateur génère des méthodes à partir des propriétés de son constructeur principal, notamment pour l’égalité, le calcul du code de hachage, la représentation sous forme de chaîne, la copie et le dégroupement. Dans l’application météo du livre, les classes de données représentent les réponses de l’API et les prévisions du domaine sans qu’il soit nécessaire d’écrire à la main le code d’accès aux propriétés et de comparaison.
fonction d’extension
Ajoute un comportement appelableFonction déclarée avec un type récepteur, ce qui permet de l’appeler avec la syntaxe d’une méthode de ce type, même si la classe d’origine n’est pas modifiée. Elle permet d’ajouter des fonctions utilitaires ciblées à des types existants ou tiers. Depuis Java, une fonction d’extension est généralement accessible comme une fonction statique, le récepteur étant passé en argument.
propriété déléguée
Comportement de propriété déléguéPropriété dont l’accesseur et, le cas échéant, le mutateur délèguent leur travail à un autre objet. Kotlin utilise la syntaxe by pour associer la propriété à ce comportement. Les délégués peuvent fournir des règles réutilisables, par exemple l’initialisation différée, l’observation des changements ou la lecture et l’écriture d’une valeur dans les préférences partagées d’Android.
conversion intelligente (smart cast)
Type précisé par le compilateurFonctionnalité du compilateur Kotlin qui traite une valeur comme ayant un type plus précis et non nullable après une vérification de type ou de nullité réussie, lorsque la valeur ne peut pas changer d’une manière qui invaliderait cette vérification. Elle évite les conversions de type et les assertions de non-nullité répétées dans la portée vérifiée, tout en préservant le type déclaré ailleurs.
coroutine
Calcul asynchrone légerMécanisme permettant de structurer le travail asynchrone, de sorte que les opérations en attente puissent être suspendues puis reprises sans qu’un thread distinct soit nécessaire pour chaque tâche. La fonctionnalité de coroutine de Kotlin s’appuie sur des fonctions suspendues, qui s’exécutent dans un contexte de coroutine. Les exemples du livre utilisent la prise en charge d’Android par Anko, alors encore expérimentale, pour effectuer des tâches en arrière-plan et renvoyer les résultats à l’interface utilisateur.
variance
Régit la flexibilité des types génériquesRègles qui déterminent si un type générique utilisant un argument de type donné peut être utilisé là où un argument de type apparenté est attendu. Kotlin prend en charge la variance au niveau de la déclaration : out indique qu’un type produit des valeurs et permet la covariance, tandis que in indique qu’un type consomme des valeurs et permet la contravariance. Ces annotations limitent les façons dont le type générique peut être utilisé.
type réifié
Type générique disponible à l’exécutionParamètre de type générique rendu disponible à l’intérieur d’une fonction Kotlin inline, ce qui permet à la fonction d’utiliser le type réel, contrairement aux informations de type générique ordinaires qui ne sont pas disponibles de la même manière. Le livre s’appuie sur cette idée pour simplifier la navigation entre activités Android. Les fonctions à type réifié sont propres à Kotlin et ne sont pas directement accessibles aux appelants Java.
Anko
Bibliothèque d’outils Kotlin pour AndroidBibliothèque de JetBrains utilisée dans le livre pour simplifier des tâches Android courantes à l’aide d’extensions Kotlin et de fonctions utilitaires. Elle propose notamment des outils pour le travail asynchrone, l’accès aux bases de données, les contextes et les vues, ainsi que la navigation entre activités. Le livre présente Anko comme un moyen d’étudier comment les fonctionnalités de Kotlin facilitent le développement Android ; ses exemples reflètent la bibliothèque et l’écosystème disponibles à l’époque de sa rédaction.
Kotlin Android Extensions
Accès généré aux vues AndroidFonctionnalité d’un plug-in Kotlin décrite dans le livre, qui expose les vues Android définies en XML sous forme de propriétés nommées d’après leurs identifiants de ressources. Le code généré peut inclure un cache pour les activités et les fragments ; les caches des vues de fragment sont effacés lorsque la vue est détruite. Le comportement du plug-in et ses instructions de configuration sont propres à l’outillage de l’époque du livre.
Télécharger le PDF
Télécharger l'EPUB
.epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.