Apprendre la programmation orientée objet avec le langage Java : avec exercices pratiques et corrigés

Auteur(s) :

Gervais, Luc (1964-....) Découvrir l'auteur

Résumé

Un ouvrage destiné à acquérir les bases pour appréhender les API Java et réaliser des programmes objet modulaires, fiables et extensibles. Avec des ressources complémentaires à télécharger et un accès gratuit à la version en ligne. ©Electre 2020

Éditeur(s)
- Éditions ENI
Date
- C 2020
Notes
- La couv. porte en plus : "En téléchargement : corrigés des exercices, code source des exemples" ; "+ quiz" ; "Version en ligne offerte ! pendant 1 an"
- La 4e de couv. indique : "Sur www.editions-eni.fr : le code source des exemples, les corrigés des exercices proposés dans le livre"
Langues
- Français
Description matérielle
- 1 vol. (426 p.) : ill.; ; 22 cm
Collections
- Ressources informatiques
Sujet(s)
- Java (langage de programmation)
- Programmation orientée objets (informatique)
ISBN
- 978-2-409-02630-0
Indice
- 681.225(07) Java. Manuels
Quatrième de couverture
- Apprendre la Programmation Orientée Objet avec le langage Java
  Cette troisième édition du livre s'adresse aux étudiants et aux développeurs ayant déjà une première expérience de la programmation structurée et qui sont désireux de passer à la Programmation Orientée Objet (POO) avec le langage Java, pour développer des applications portables.
  Après un historique de la POO et du langage Java l'auteur explique pourquoi ce type de programmation est devenu incontournable pour développer dans les environnements graphiques événementiels. Les notions d'objet, de classe et de référence sont présentées puis les fondements de la POO que sont l'encapsulation, l'héritage, le polymorphisme et l'abstraction. Les différentes étapes d'un développement objet avec les principes de modélisation UML sont exposées.
  L'auteur présente ensuite la machine virtuelle Java, son intérêt, sa richesse et un environnement de développement avec IntelliJ IDEA de la société JetBrains. Le lecteur découvre comment Java reproduit les principes de la POO en suivant des explications simples, des exemples concrets et en réalisant des exercices d'entraînement. Il découvre également les types de base du développement Java et leur utilisation, comment exploiter un IDE pour simplifier la saisie des programmes et les mettre au point. Les programmes d'essais sont de type console ou graphique, basés sur l'utilisation de Swing pour illustrer les communications entre objets. Quand ils sont pertinents, des parallèles sont menés avec les langages de programmation objet C++ et C#. La programmation multithread permettant l'exécution simultanée de plusieurs flux d'instructions est présentée, suivie d'une introduction aux tests unitaires tellement importants pour fiabiliser les objets. Une partie consacrée à la réflexion en Java promet quelques surprises. Enfin, le dernier chapitre est consacré aux classes anonymes et aux expressions lambda.
  À la fin de ce livre, le lecteur disposera de bases solides pour appréhender les puissantes API Java et réaliser des programmes objet modulaires, fiables et extensibles.
  Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.
Tables des matières
- - Apprendre la Programmation Orientée Objet avec le langage Java
  - (avec exercices pratiques et corrigés)
  - 3e édition
  - Editions ENI
  - Avant-propos
  - Chapitre 1
  - Introduction à la POO
  - 1. Histoire de la POO11
  - 2. Historique du langage Java14
  - Chapitre 2
  - La conception orientée objet
  - 1. Approche procédurale et décomposition fonctionnelle15
  - 2. La transition vers l'approche objet16
  - 3. Les caractéristiques de la POO17
  - 3.1 L'objet, la classe et la référence17
  - 3.1.1 L'objet17
  - 3.1.2 La classe19
  - 3.1.3 La référence20
  - 3.2 L'encapsulation21
  - 3.3 L'héritage21
  - 3.4 Le polymorphisme23
  - 3.5 L'abstraction24
  - 4. Le développement objet25
  - 4.1 Cahier des charges du logiciel25
  - 4.2 Présentation du cycle en V26
  - 4.3 Rester agile avec le corps en V30
  - 4.4 Modélisation et représentation UML31
  - 4.4.1 Les diagrammes de cas d'utilisation33
  - 4.4.2 Les diagrammes de classes34
  - 4.4.3 Les énumérations41
  - 4.4.4 Les diagrammes de séquences42
  - 4.5 Codage, intégration et mise en production44
  - 5. Exercices45
  - 5.1 Hiérarchie de classes45
  - 5.2 Relations entre objets47
  - 5.3 Agrégation d'objets47
  - 5.4 Diagramme de cas d'utilisation49
  - 5.5 Diagramme de séquences50
  - Chapitre 3
  - Introduction à la plate-forme Java
  - 1. Introduction53
  - 2. Environnement d'exécution55
  - 3. Une librairie très complète56
  - 4. Des outils de développement performants57
  - 5. Téléchargement et installation d'intelliJ IDEA58
  - 6. L'incontournable Hello World62
  - 7. Un point sur les acronymes81
  - Chapitre 4
  - Les types en Java
  - 1. Introduction83
  - 2. Les types primitifs84
  - 3. Les types référence86
  - 4. Pour nous aider88
  - 5. La superclasse java.lang.Object92
  - 5.1 equals92
  - 5.2 hashCode96
  - 5.3 toString97
  - 5.4 finalize99
  - 5.5 getClass, .class et l'opérateur instanceof100
  - 5.6 clone102
  - 5.7 notify, notifyAll et wait106
  - 6. La classe java.lang.String107
  - 7. Exercice110
  - 7.1 Énoncé110
  - 7.2 Corrigé111
  - Chapitre 5
  - Création de classes
  - 1. Introduction115
  - 2. Package115
  - 3. Déclaration d'une classe122
  - 3.1 Accessibilité des membres124
  - 3.2 Attributs125
  - 3.3 Accesseurs128
  - 3.4 Constructeurs134
  - 3.4.1 Étapes de la construction d'un objet134
  - 3.4.2 Surcharge de constructeurs136
  - 3.4.3 Chaînage de constructeurs136
  - 3.4.4 L'initialiseur static139
  - 3.4.5 L'initialiseur dynamique140
  - 3.4.6 Les constructeurs de type private142
  - 3.4.7 Le « builder pattern »145
  - 3.5 Destructeurs147
  - 3.6 Le mot-clé this152
  - 3.7 Méthodes155
  - 3.7.1 Déclaration155
  - 3.7.2 Passages de paramètres par valeur159
  - 3.8 Surcharge des méthodes164
  - 3.9 Mécanisme des exceptions166
  - 3.9.1 Présentation166
  - 3.9.2 Principe de fonctionnement des exceptions168
  - 3.9.3 Prise en charge de plusieurs exceptions177
  - 3.10 Exercice178
  - 3.10.1 Énoncé178
  - 3.10.2 Conseils179
  - 3.10.3 Corrigé180
  - 4. Les interfaces183
  - 4.1 Introduction183
  - 4.2 Le contrat183
  - 4.3 Déclaration d'une interface184
  - 4.4 Implémentation186
  - 4.5 IntelliJ IDEA et les interfaces188
  - 4.6 Représentation UML d'une interface190
  - 4.7 Interfaces et polymorphisme190
  - 4.8 Exercice191
  - 4.8.1 Énoncé191
  - 4.8.2 Conseils192
  - 4.8.3 Corrigé195
  - 4.9 Les interfaces de la machine virtuelle Java199
  - 5. Associations, compositions et agrégations202
  - 5.1 Les tableaux210
  - 5.2 Les collections217
  - 5.2.1 ArrayList <E> et LinkedList <E>221
  - 5.2.2 Queue <T> et Stack <T>225
  - 5.2.3 HashMap <K, V>225
  - 5.2.4 Les itérateurs226
  - 5.3 Exercice227
  - 5.3.1 Énoncé227
  - 5.3.2 Corrigé229
  - 6. Les classes imbriquées231
  - 7. Quelques différences avec le C#235
  - Chapitre 6
  - Héritage et polymorphisme
  - 1. Comprendre l'héritage237
  - 2. Codage de la superclasse (classe de base) et de sa sous-classe (classe héritière)238
  - 2.1 Interdire l'héritage238
  - 2.2 Définir les membres héritables239
  - 2.3 Syntaxe de l'héritage239
  - 2.4 Exploitation d'une classe héritée240
  - 3. Communication entre classe de base et classe héritière242
  - 3.1 Les constructeurs242
  - 3.2 Accès aux membres de la classe de base depuis l'héritier246
  - 3.3 Méthodes virtuelles248
  - 3.4 Méthodes de type « final »253
  - 4. Exercice255
  - 4.1 Énoncé255
  - 4.2 Corrigé256
  - 5. Les classes abstraites262
  - 6. Le polymorphisme263
  - 6.1 Comprendre le polymorphisme263
  - 6.2 Exploitation du polymorphisme264
  - 6.3 Les opérateurs instanceof et ()265
  - Chapitre 7
  - Communication entre objets
  - 1. L'événementiel : être à l'écoute267
  - 2. Le pattern Observateur268
  - 2.1 Généralités268
  - 2.2 Implémentation en langage Java269
  - 2.3 Les listeners275
  - 2.4 Utilisation d'un listener dans une application graphique276
  - 3. Exercices283
  - 3.1 Exercice 1283
  - 3.1.1 Énoncé283
  - 3.1.2 Corrigé284
  - 3.2 Exercice 2287
  - 3.2.1 Énoncé287
  - 3.2.2 Corrigé287
  - 4. Appels synchrones, appels asynchrones290
  - Chapitre 8
  - Le multithreading
  - 1. Introduction293
  - 2. Comprendre le multithreading293
  - 3. Multithreading et Java296
  - 4. Implémentation des threads en Java297
  - 4.1 Étendre la classe Thread297
  - 4.2 Implémenter l'interface Runnable300
  - 4.3 S'endormir et S'attendre302
  - 4.4 Abandon depuis le thread primaire306
  - 4.5 Threads et classes anonymes309
  - 4.5.1 Avec l'interface Runnable309
  - 4.5.2 Avec la classe Thread310
  - 4.5.3 Accès aux variables et aux données membres simplifié311
  - 5. Synchronisation entre threads315
  - 5.1 Nécessité de la synchronisation315
  - 5.2 Les méthodes « synchronized »317
  - 5.3 Les traitements « synchronized »319
  - 5.4 La classe Semaphore321
  - 6. Communication interthreads325
  - 6.1 La méthode join325
  - 6.2 Les objets de synchronisation327
  - 7. Exercice336
  - 7.1 Énoncé336
  - 7.2 Corrigé338
  - Chapitre 9
  - Les tests
  - 1. Introduction345
  - 2. Environnement d'exécution des tests unitaires347
  - 3. Le projet avec tests unitaires348
  - 4. La classe de tests350
  - 5. Contenu d'une méthode de test353
  - 6. Traitements de préparation et de nettoyage356
  - 7. Les tests avec paramètres externes359
  - 8. Les suites de tests364
  - 9. Exercice365
  - 9.1 Énoncé365
  - 9.2 Corrigé365
  - Chapitre 10
  - La réflexion
  - 1. Introduction367
  - 2. Mais pour quoi faire ?367
  - 3. Introspection d'une classe Java369
  - 4. Chargement dynamique et utilisation d'une classe découverte372
  - 5. Exercice380
  - 6. Privé, mais pas tant380
  - 7. Décompilation et obfuscation381
  - Chapitre 11
  - Anonymat et lambda
  - 1. Introduction395
  - 2. Les classes anonymes396
  - 2.1 D'une pierre deux coups396
  - 2.2 Syntaxe particulière396
  - 2.3 Exemple d'extension d'une superclasse397
  - 2.4 Exemple d'implémentation d'une interface399
  - 2.5 Échange d'informations401
  - 2.6 Exercice403
  - 2.6.1 Énoncé403
  - 2.6.2 Corrigé403
  - 3. Les expressions lambda405
  - 3.1 Le concept405
  - 3.2 Les interfaces « fonctionnelles » comme modèles406
  - 3.3 Les syntaxes lambda408
  - 3.4 Échange d'informations409
  - 3.5 Exercice409
  - 3.5.1 Énoncé409
  - 3.5.2 Correction409
  - 3.6 Paramètre type Lambda412
  - 3.7 java.util.function, un package « vivier »414
  - 3.8 Application sur des collections415
  - 3.9 Conclusion416
  - Index 417
Origine de la notice:
- Electre