En raison d’une maintenance technique, la boutique Editions ENI sera inaccessible ce mercredi soir à compter de 21h, jusqu’à 2h jeudi matin. Nous vous invitons à passer votre commande avant 20h30. Merci pour votre compréhension. L’équipe des Editions ENI
  1. Supports de cours
  2. Kotlin - Les fondamentaux du langage

Kotlin Les fondamentaux du langage

  • En stock
  • Expédié en 24h00
  • Personnalisable
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7

Présentation

Ce support s’adresse à toute personne désireuse d’apprendre à programmer avec le langage Kotlin (en version 1.4 au moment de l’écriture). Que le lecteur soit débutant ou qu’il ait déjà de l’expérience avec un ou plusieurs langages de programmation, il trouvera dans ce livre, articulé en cinq grandes parties, toutes les connaissances nécessaires à la prise en main de Kotlin, largement illustrées par de nombreux exemples, pour une utilisation dans un contexte JVM (Java Virtual Machine).

La première partie permet au lecteur de préparer son environnement de travail et d’appréhender les bases de la programmation en Kotlin grâce aux variables, conditions, boucles, tableaux et fonctions. La deuxième partie détaille toutes les possibilités du langage Kotlin autour du concept de programmation orientée objet permettant ainsi au lecteur d’étudier les notions de classes, d’héritage, d’interfaces, d’énumérations, de généricité...

Une troisième partie donne la possibilité de progresser dans son apprentissage de la programmation avec Kotlin en se familiarisant avec des notions avancées contenues directement dans le langage (conversion de type, réification de type, fonctions de portée…), avant de poursuivre avec une partie dédiée aux collections.

La dernière partie de ce support implique le lecteur dans la manipulation de bibliothèques tierces utiles pour la gestion de la programmation asynchrone, de channels, de flows, de requêtes web ou encore de sérialisation JSON.

L’auteur conclut avec un chapitre dans lequel il propose une mise en application des différentes notions étudiées avec le développement, étape par étape, d’un programme Kotlin destiné à la JVM.

Table des matières

  • Bien commencer en Kotlin
    • 1. Installer IntelliJ IDEA
    • 2. Créer un premier programme avec IntelliJ IDEA
      • 2.1 La barre d’outils
      • 2.2 L’onglet Project
      • 2.3 Le terminal
    • 3. Créer des fichiers Kotlin
    • 4. Hello World!
    • 5. En résumé
  • Manipuler les variables
    • 1. Qu’est-ce qu’une variable ?
    • 2. Déclarer une variable
    • 3. Nommer une variable
    • 4. Les types de variables
      • 4.1 Les nombres entiers
      • 4.2 Les nombres flottants
      • 4.3 Les caractères
      • 4.4 Les booléens
      • 4.5 Les chaînes de caractères
    • 5. Déclarer une variable (suite)
    • 6. Affecter une valeur à une variable
    • 7. Les variables de type "lecture seule"
    • 8. Les constantes
    • 9. Formater des nombres
    • 10. L’inférence de type
    • 11. Afficher le contenu d’une variable
    • 12. Place aux calculs !
      • 12.1 Les calculs de base
        • 12.1.1 L’addition
        • 12.1.2 La soustraction
        • 12.1.3 La multiplication
        • 12.1.4 La division
        • 12.1.5 Le modulo
        • 12.1.6 Des calculs et des variables
      • 12.2 Écrire moins de code
        • 12.2.1 Incrémenter une variable
        • 12.2.2 Décrémenter une variable
        • 12.2.3 D’autres raccourcis
      • 12.3 Des calculs plus complexes
        • 12.3.1 Quelques exemples de fonctions mathématiques
        • 12.3.2 D’autres fonctions
    • 13. En résumé
  • Les structures de contrôle
    • 1. Qu’est-ce qu’une condition ?
      • 1.1 if... else
        • 1.1.1 Les symboles de comparaison
        • 1.1.2 if
        • 1.1.3 else
        • 1.1.4 else if
        • 1.1.5 D’autres symboles ?
      • 1.2 when
      • 1.3 Stocker la valeur de retour d’une condition
    • 2. Qu’est-ce qu’une boucle ?
      • 2.1 La boucle while
      • 2.2 La boucle do... while
      • 2.3 La boucle for
    • 3. En résumé
  • Les fonctions
    • 1. Qu’est-ce qu’une fonction ?
    • 2. Définir une fonction
    • 3. Appeler une fonction
    • 4. Affecter des valeurs par défaut
    • 5. La surcharge de fonction
    • 6. Aller plus loin
      • 6.1 Les paramètres sont en lecture seule
      • 6.2 Une écriture raccourcie
    • 7. En résumé
  • Les tableaux
    • 1. Les tableaux à une dimension
      • 1.1 L’intérêt des tableaux
      • 1.2 Déclarer un tableau
        • 1.2.1 Déclarer un tableau "vide"
        • 1.2.2 Déclarer un tableau "prérempli"
      • 1.3 Accéder aux éléments d’un tableau
      • 1.4 Parcourir un tableau
      • 1.5 Les tableaux et les fonctions
      • 1.6 Les tableaux de primitives
    • 2. Les tableaux multidimensionnels
      • 2.1 Déclarer un tableau multidimensionnel
        • 2.1.1 Déclarer un tableau "vide"
        • 2.1.2 Déclarer un tableau "prérempli"
      • 2.2 Accéder aux éléments d’un tableau multidimensionnel
      • 2.3 Parcourir un tableau multidimensionnel
      • 2.4 Les tableaux multidimensionnels et les fonctions
      • 2.5 Les tableaux multidimensionnels de primitives
    • 3. En résumé
  • Introduction à la programmation orientée objet
    • 1. Qu’est-ce qu’un objet ?
    • 2. Qu’est-ce que la programmation orientée objet ?
    • 3. En résumé
  • Les classes
    • 1. Créer une classe
      • 1.1 Un peu de vocabulaire
      • 1.2 La classe Dog
    • 2. Ajouter des attributs et des méthodes
      • 2.1 Les attributs
      • 2.2 Les méthodes
    • 3. Utiliser des objets
    • 4. Afficher un objet
    • 5. Les droits d’accès
      • 5.1 Les méthodes
      • 5.2 Les attributs
    • 6. Les mutateurs et les accesseurs
    • 7. Les constructeurs
      • 7.1 Créer un constructeur
      • 7.2 Les constructeurs secondaires
    • 8. En résumé
  • L’héritage
    • 1. Introduction
    • 2. Qu'est-ce que l’héritage ?
    • 3. Mettre en place l’héritage
      • 3.1 La classe Animal
      • 3.2 La classe Cat
      • 3.3 La classe Dog
      • 3.4 Manipuler les classes
    • 4. Un nouveau droit d’accès
    • 5. La covariance
    • 6. Vérifier le type d’un objet
    • 7. Le polymorphisme
    • 8. Les classes abstraites
      • 8.1 Qu’est-ce qu’une classe abstraite ?
      • 8.2 Écrire une classe abstraite
      • 8.3 Les méthodes abstraites
      • 8.4 La covariance
      • 8.5 Créer une classe anonyme
    • 9. En résumé
  • Des classes dans des classes
    • 1. Les classes internes
    • 2. Les classes imbriquées
    • 3. Les classes scellées
      • 3.1 Qu’est-ce qu’une classe scellée ?
      • 3.2 Écrire une classe scellée
      • 3.3 Les méthodes abstraites
      • 3.4 La covariance
    • 4. En résumé
  • Des classes particulières
    • 1. Les énumérations
      • 1.1 Qu’est-ce qu’une énumération ?
      • 1.2 Écrire une énumération
      • 1.3 Lister les valeurs d’une énumération
      • 1.4 Retrouver la valeur d’une énumération
      • 1.5 Ajouter des attributs à une énumération
      • 1.6 Ajouter des méthodes à une énumération
      • 1.7 Aller plus loin
    • 2. Les classes de données
      • 2.1 Qu’est-ce qu’une classe de données ?
      • 2.2 Écrire une classe de données
      • 2.3 Les limitations des classes de données
      • 2.4 Les méthodes générées automatiquement dans les classes de données
        • 2.4.1 La méthode equals
        • 2.4.2 La méthode hashCode
        • 2.4.3 La méthode copy
    • 3. Les objets Singleton
      • 3.1 Qu’est-ce qu’un patron de conception ?
      • 3.2 Le patron de conception Singleton
      • 3.3 Écrire une classe qui implémente le patron de conception Singleton
    • 4. En résumé
  • Les interfaces
    • 1. Qu’est-ce qu’une interface ?
    • 2. Écrire une interface
    • 3. Implémenter une interface
    • 4. Ajouter des attributs et des implémentations par défaut dans les interfaces
      • 4.1 Les méthodes non abstraites
      • 4.2 Les attributs abstraits
    • 5. La covariance
    • 6. Créer une classe anonyme
    • 7. En résumé
  • La généricité
    • 1. Des chiens et des chats
    • 2. Écrire une classe générique
    • 3. Utiliser une classe générique
    • 4. Ajouter une contrainte sur le type de paramètre
    • 5. Ajouter plusieurs contraintes sur le type de paramètre
    • 6. Les classes génériques covariantes
    • 7. Les classes génériques contravariantes
    • 8. En résumé
  • Aller plus loin avec les classes
    • 1. Les éléments statiques
      • 1.1 Les méthodes statiques
        • 1.1.1 Qu’est-ce qu’une méthode statique ?
        • 1.1.2 Écrire une méthode statique
        • 1.1.3 Utiliser une méthode statique
      • 1.2 Les attributs statiques
        • 1.2.1 Qu’est-ce qu’un attribut statique ?
        • 1.2.2 Écrire un attribut statique
        • 1.2.3 Utiliser un attribut statique
    • 2. Les extensions
      • 2.1 Les limites de l’héritage
      • 2.2 Les méthodes d’extension
      • 2.3 Les attributs d’extension
    • 3. Les alias
      • 3.1 Qu’est-ce qu’un alias ?
      • 3.2 Créer un alias
    • 4. En résumé
  • Le type Nullable
    • 1. Qu’est-ce que le type nullable ?
    • 2. Indiquer des éléments nullables
    • 3. Composer avec les éléments nullables
      • 3.1 L’opérateur !!
      • 3.2 L’opérateur ?
      • 3.3 L’opérateur Elvis
    • 4. En résumé
  • Initialiser les attributs autrement
    • 1. Initialiser les attributs plus tard
    • 2. Initialisation paresseuse des attributs
    • 3. En résumé
  • Des fonctions particulières
    • 1. Les expressions lambda et les fonctions d’ordre supérieur
      • 1.1 Qu’est-ce qu’une expression lambda ?
      • 1.2 Écrire une expression lambda
      • 1.3 Utiliser une expression lambda
      • 1.4 Qu'est-ce qu'une fonction d’ordre supérieur ?
        • 1.4.1 Écrire une fonction d’ordre supérieur
        • 1.4.2 Utiliser une fonction d’ordre supérieur
        • 1.4.3 Optimiser une fonction d’ordre supérieur
    • 2. Les fonctions de portée
      • 2.1 Qu’est-ce qu’une fonction de portée ?
      • 2.2 Manipuler un objet dans une fonction de portée
      • 2.3 Retourner un résultat dans une fonction de portée
      • 2.4 La fonction let
      • 2.5 La fonction with
      • 2.6 La fonction run
      • 2.7 La fonction apply
      • 2.8 La fonction also
    • 3. En résumé
  • Les interfaces fonctionnelles
    • 1. La problématique des instanciations anonymes des interfaces
    • 2. Écrire une interface fonctionnelle
    • 3. En résumé
  • Les exceptions
    • 1. Qu’est-ce qu’une exception ?
      • 1.1 Analyser une stacktrace
      • 1.2 Des exceptions et des classes
    • 2. Capturer une ou plusieurs exceptions
      • 2.1 Capturer une exception
      • 2.2 Capturer plusieurs exceptions
      • 2.3 Exécuter du code systématiquement
    • 3. Lever des exceptions
      • 3.1 Quand lever une exception ?
      • 3.2 Utiliser le mot-clé throw
      • 3.3 Utiliser l’opérateur Elvis
      • 3.4 Utiliser la fonction require
      • 3.5 Utiliser la fonction check
    • 4. Créer des exceptions personnalisées
    • 5. En résumé
  • Les conversions de type
    • 1. Qu’est-ce que la conversion de type ?
    • 2. Mettre en place la conversion de type
    • 3. La conversion de type intelligente
    • 4. En résumé
  • Les collections
    • 1. Introduction
    • 2. List et MutableList
      • 2.1 Qu’est-ce qu’une liste ?
      • 2.2 Les listes en lecture seule
        • 2.2.1 Déclarer une liste en lecture seule
        • 2.2.2 Parcourir une liste
        • 2.2.3 Retrouver l’indice d’un élément
        • 2.2.4 Récupérer un sous-ensemble d’une liste
        • 2.2.5 Récupérer une valeur à partir de son indice
        • 2.2.6 Les listes et les fonctions
        • 2.2.7 Une liste vide
      • 2.3 Les listes en lecture et en écriture
        • 2.3.1 Déclarer une liste en lecture et en écriture
        • 2.3.2 Ajouter un ou plusieurs éléments
        • 2.3.3 Mettre à jour les éléments d’une liste
        • 2.3.4 Retirer un élément
        • 2.3.5 Les listes et les fonctions
      • 2.4 Passer du type List à MutableList
      • 2.5 Les listes et la covariance de type
    • 3. Set et MutableSet
      • 3.1 Qu’est-ce qu’un "set" ?
      • 3.2 Les sets en lecture seule
        • 3.2.1 Déclarer un set en lecture seule
        • 3.2.2 Parcourir un set
        • 3.2.3 D’autres opérations
        • 3.2.4 Les sets et les fonctions
        • 3.2.5 Un set vide
      • 3.3 Les sets en lecture et en écriture
        • 3.3.1 Déclarer un set en lecture et en écriture
        • 3.3.2 Ajouter un ou plusieurs éléments
        • 3.3.3 Retirer un élément
        • 3.3.4 Les sets et les fonctions
      • 3.4 Passer du type Set à MutableSet
      • 3.5 Les sets et la covariance de type
    • 4. Map et MutableMap
      • 4.1 Qu’est-ce qu’une map ?
      • 4.2 Les maps en lecture seule
        • 4.2.1 Déclarer une map en lecture seule
        • 4.2.2 Parcourir une map
        • 4.2.3 Récupérer l’ensemble des clés d’une map
        • 4.2.4 Récupérer l’ensemble des valeurs d’une map
        • 4.2.5 Récupérer une valeur d’une map à partir d’une clé
        • 4.2.6 Les maps et les fonctions
        • 4.2.7 Une map vide
      • 4.3 Les maps en lecture et en écriture
        • 4.3.1 Déclarer une map en lecture et en écriture
        • 4.3.2 Ajouter un ou plusieurs éléments
        • 4.3.3 Mettre à jour les éléments d’une map
        • 4.3.4 Retirer un élément
        • 4.3.5 Les maps et les fonctions
      • 4.4 Passer du type Map à MutableMap
      • 4.5 Les maps et la covariance de type
    • 5. Les opérations sur les collections
      • 5.1 Transformer une collection
        • 5.1.1 Le mapping
        • 5.1.2 Le zipping
      • 5.2 Filtrer une collection
        • 5.2.1 Le filtrage
        • 5.2.2 La partition
      • 5.3 Regrouper les éléments d’une collection
      • 5.4 Les opérations de sélection
        • 5.4.1 Sélectionner plusieurs éléments
        • 5.4.2 Sélectionner un seul élément
      • 5.5 Les opérations de tri
        • 5.5.1 Les opérations de tri non personnalisables
        • 5.5.2 Les opérations de tri personnalisables
      • 5.6 Les opérations d’agrégation
        • 5.6.1 Les valeurs minimale et maximale
        • 5.6.2 La valeur moyenne
        • 5.6.3 La somme des valeurs
        • 5.6.4 Compter le nombre de valeurs
    • 6. En résumé
  • Les séquences
    • 1. Qu’est-ce qu’une séquence ?
    • 2. Pourquoi utiliser les séquences ?
    • 3. En résumé
  • La programmation asynchrone avec les coroutines
    • 1. Qu’est-ce qu’une bibliothèque tierce ?
    • 2. Quand utiliser la programmation asynchrone ?
    • 3. Ajouter les coroutines dans un projet
    • 4. Créer des coroutines
      • 4.1 Le constructeur runBlocking
      • 4.2 Le constructeur launch
      • 4.3 Le constructeur async
      • 4.4 Les fonctions suspendues
    • 5. Annuler et synchroniser des coroutines
      • 5.1 Connaître l’état d’une coroutine
      • 5.2 Attendre la fin d’une coroutine
      • 5.3 Annuler une coroutine
    • 6. Des coroutines dans des coroutines
    • 7. La gestion des erreurs dans une coroutine
      • 7.1 La gestion locale
      • 7.2 La gestion centralisée
    • 8. Ajouter des paramètres aux constructeurs
      • 8.1 Le contexte
        • 8.1.1 Ajouter un objet de type Job
        • 8.1.2 Ajouter un objet de type Dispatchers
        • 8.1.3 Ajouter un objet de type CoroutineExceptionHandler au contexte
        • 8.1.4 Ajouter des objets de type Job, Dispatchers et CoroutineExceptionHandler
      • 8.2 Les options de démarrage
    • 9. Changer de contexte
    • 10. L’échange de données entre coroutines
      • 10.1 Les channels
        • 10.1.1 Qu’est-ce qu’un channel ?
        • 10.1.2 Différents types de channels
        • 10.1.3 Les inconvénients des channels
      • 10.2 Les flows
        • 10.2.1 Qu’est-ce que l’interface Flow ?
        • 10.2.2 Utiliser l’interface Flow
        • 10.2.3 Filtrer, transformer, etc. les données collectées
        • 10.2.4 Aller plus loin
    • 11. En résumé
  • L’introspection et la réification de type
    • 1. Qu’est-ce que l’introspection ?
    • 2. Utiliser l’introspection dans les projets
    • 3. Découvrir une classe par introspection
      • 3.1 Connaître la classe mère et les interfaces implémentées par une classe
      • 3.2 Connaître les constructeurs d’une classe
      • 3.3 Connaître les méthodes d’une classe
      • 3.4 Connaître les attributs d’une classe
    • 4. Instancier dynamiquement des objets
    • 5. Aller plus loin
    • 6. La réification de type
      • 6.1 La problématique
      • 6.2 Qu’est-ce que la réification de type ?
    • 7. En résumé
  • La sérialisation et la désérialisation
    • 1. Utiliser kotlinx-serialization dans les projets
    • 2. Qu’est-ce que la sérialisation ?
    • 3. Des solutions alternatives
    • 4. La sérialisation JSON avec kotlinx-serialization
      • 4.1 Qu’est-ce que JSON ?
      • 4.2 La sérialisation JSON
        • 4.2.1 Un exemple simple
        • 4.2.2 Aller plus loin
      • 4.3 La désérialisation JSON
        • 4.3.1 Un exemple simple
        • 4.3.2 Aller plus loin
    • 5. En résumé
  • Les requêtes réseau avec ktor
    • 1. Utiliser ktor dans les projets
    • 2. Qu’est-ce qu’une requête réseau ?
    • 3. Des solutions alternatives
    • 4. Faire une requête réseau
      • 4.1 Présentation de l’API
      • 4.2 Implémentation technique
    • 5. En résumé
  • Aller plus loin
    • 1. Créer des annotations
    • 2. Surcharger les opérateurs d’une classe
    • 3. L'interopérabilité avec Java
    • 4. Écrire et lire dans des fichiers
    • 5. Tester un programme
    • 6. Déboguer un programme
  • Création d’un projet complet
    • 1. Description du projet
    • 2. Créer le projet
      • 2.1 Ajouter un package
      • 2.2 Créer les objets métier
      • 2.3 Créer le service
        • 2.3.1 La méthode addFilm
        • 2.3.2 La méthode addPerson
        • 2.3.3 La méthode getFilmById
        • 2.3.4 La méthode getPersonById
        • 2.3.5 La méthode getFilmByName
        • 2.3.6 La méthode getFilmByActorId
        • 2.3.7 La méthode getFilmByDirectorId
        • 2.3.8 La méthode getFilmByGenre
      • 2.4 Écrire et lire dans un fichier
        • 2.4.1 Implémenter la sérialisation JSON
        • 2.4.2 La méthode saveDatabase
        • 2.4.3 La méthode loadDatabase
      • 2.5 Créer le programme principal
        • 2.5.1 Créer le menu
        • 2.5.2 Charger la base de données
        • 2.5.3 Sauvegarder la base de données
        • 2.5.4 Ajouter une personne
        • 2.5.5 Ajouter un film
        • 2.5.6 Rechercher un film par son nom
        • 2.5.7 Rechercher les films d’un acteur
        • 2.5.8 Rechercher les films d’un réalisateur
        • 2.5.9 Rechercher les films d’un genre particulier
        • Index

Auteur

Ludovic ROLANDEn savoir plus

Expert technique Android, Ludovic ROLAND a fait ses armes pendant plusieurs années avec le langage de programmation Java avant d’adopter Kotlin, dès la première version stable du langage en 2016, pour le développement de ses applications. Reconnu pour son expertise et ses compétences pédagogiques, Ludovic ROLAND intervient dans plusieurs écoles d’ingénieurs et organismes de formation en ligne et propose aujourd’hui un livre 100% opérationnel sur le développement de programmes en Kotlin.

Caractéristiques

  • Nombre de pages 428 pages
  • Parution avril 2021
    • Reliure spirale - 17 x 21 cm (Médian)
    • ISBN : 978-2-409-02917-2
    • EAN : 9782409029172
    • Ref. ENI : RIMKOT
  • Parution avril 2021
    • HTML
    • ISBN : 978-2-409-02918-9
    • EAN : 9782409029189
    • Ref. ENI : LNRIMKOT