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.

Éditeur(s)
- Éditions ENI
Date
- C 2024
Notes
- La couv. porte en plus : "En téléchargement : corrigés des exercices, code source des exemples"
- La 4e de couv. indique : www.editions.editions-eni.fr : le code source des exemples, les corrigés des exercices proposés dans le livre"
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (428 p.) : ill. ; 21 cm
Collections
- Ressources informatiques
Sujet(s)
- Java (langage de programmation)
- Programmation orientée objets (informatique)
ISBN
- 978-2-409-04742-8
Indice
- 681.225(07) Java. Manuels
Quatrième de couverture
- Apprendre la Programmation Orientée Objet avec le langage Java
  Cette quatrième édition de ce 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é Jet-Brains. 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 POO
  - avec le langage Java
  - 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 fonctionnelle17
  - 2. La transition vers l'approche objet18
  - 3. Les caractéristiques de la POO19
  - 3.1 L'objet, la classe et la référence19
  - 3.1.1 L'objet19
  - 3.1.2 La classe21
  - 3.1.3 La référence22
  - 3.2 L'encapsulation23
  - 3.3 L'héritage23
  - 3.4 Le polymorphisme25
  - 3.5 L'abstraction26
  - 4. Le développement objet27
  - 4.1 Cahier des charges du logiciel27
  - 4.2 Présentation du cycle en V28
  - 4.3 Rester agile avec le corps en V32
  - 4.4 Modélisation et représentation UML33
  - 4.4.1 Les diagrammes de cas d'utilisation35
  - 4.4.2 Les diagrammes de classes36
  - 4.4.3 Les énumérations42
  - 4.4.4 Les diagrammes de séquences44
  - 4.5 Codage, intégration et mise en production46
  - 5. Exercices47
  - 5.1 Hiérarchie de classes47
  - 5.2 Relations entre objets49
  - 5.3 Agrégation d'objets49
  - 5.4 Diagramme de cas d'utilisation51
  - 5.5 Diagramme de séquences52
  - Chapitre 3
  - Introduction à la plate-forme Java
  - 1. Introduction55
  - 2. Environnement d'exécution57
  - 3. Une librairie très complète.58
  - 4. Des outils de développement performants.59
  - 5. Téléchargement et installation du JDK59
  - 6. Téléchargement et installation d'IntelliJ IDEA60
  - 7. L'incontournable Hello World65
  - 8. Un point sur les acronymes76
  - Chapitre 4
  - Les types en Java
  - 1. Introduction79
  - 2. Les types primitifs80
  - 3. Les types référence82
  - 4. Pour nous aider84
  - 5. La superclasse java. lang. Object90
  - 5.1 equals91
  - 5.2 hashCode94
  - 5.3 toString96
  - 5.4 finalize98
  - 5.5 getClass, class et l'opérateur instanceof98
  - 5.6 clone100
  - 5.7 notify, notifyAll et wait105
  - 6. La classe java. lang. String105
  - 7. Exercice109
  - 7.1 Énoncé109
  - 7.2 Corrigé109
  - Chapitre 5
  - Création de classes
  - 1. Introduction113
  - 2. Package113
  - 3. Déclaration d'une classe121
  - 3.1 Accessibilité des membres124
  - 3.2 Attributs125
  - 3.3 Accesseurs et Mutateurs128
  - 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é this et ses vertus152
  - 3.7 Méthodes155
  - 3.7.1 Déclaration155
  - 3.7.2 Passages de paramètres par valeur159
  - 3.8 Surcharge des méthodes165
  - 3.9 Mécanisme des exceptions167
  - 3.9.1 Présentation167
  - 3.9.2 Principe de fonctionnement des exceptions169
  - 3.9.3 Prise en charge de plusieurs exceptions178
  - 3.10 Exercice180
  - 3.10.1 Énoncé180
  - 3.10.2 Conseils181
  - 3.10.3 Corrigé181
  - 4. Les interfaces184
  - 4.1 Introduction184
  - 4.2 Le contrat185
  - 4.3 Déclaration d'une interface186
  - 4.4 Implémentation187
  - 4.5 IntelliJ IDEA et les interfaces189
  - 4.6 Représentation UML d'une interface191
  - 4.7 Interfaces et polymorphisme192
  - 4.8 Exercice192
  - 4.8.1 Énoncé192
  - 4.8.2 Conseils193
  - 4.8.3 Corrigé196
  - 4.9 Les interfaces de la machine virtuelle Java200
  - 5. Associations, compositions et agrégations203
  - 5.1 Les tableaux211
  - 5.2 Les collections218
  - 5.2.1 ArrayList<E> et LinkedList<E>223
  - 5.2.2 Queue<T> et Stack<T>226
  - 5.2.3 HashMap<K, V>226
  - 5.2.4 Les itérateurs227
  - 5.3 Exercice229
  - 5.3.1 Énoncé229
  - 5.3.2 Corrigé230
  - 6. Les classes imbriquées232
  - 7. Quelques différences avec le C#236
  - Chapitre 6
  - Héritage et polymorphisme
  - 1. Comprendre l'héritage239
  - 2. Codage de la superclasse (classe de base) et de sa sous-classe (classe héritière)240
  - 2.1 Interdire l'héritage240
  - 2.2 Définir les membres héritables241
  - 2.3 Syntaxe de l'héritage241
  - 2.4 Exploitation d'une classe héritée242
  - 3. Communication entre classe de base et classe héritière244
  - 3.1 Les constructeurs244
  - 3.2 Accès aux membres de la classe de base depuis l'héritier248
  - 3.3 Méthodes virtuelles250
  - 3.4 Méthodes de type final255
  - 4. Exercice.257
  - 4.1 Énoncé257
  - 4.2 Corrigé258
  - 5. Les classes abstraites264
  - 6. Le polymorphisme265
  - 6.1 Comprendre le polymorphisme265
  - 6.2 Exploitation du polymorphisme266
  - 6.3 Les opérateurs instanceof et ()267
  - Chapitre 7
  - Communication entre objets
  - 1. L'événementiel : être à l'écoute269
  - 2. Le pattern Observateur270
  - 2.1 Généralités270
  - 2.2 Implémentation en langage Java271
  - 2.3 Les listeners276
  - 2.4 Utilisation d'un listener dans une application graphique278
  - 3. Exercices285
  - 3.1 Exercice 1285
  - 3.1.1 Énoncé285
  - 3.1.2 Corrigé286
  - 3.2 Exercice 2289
  - 3.2.1 Énoncé289
  - 3.2.2 Corrigé289
  - 4. Appels synchrones, appels asynchrones292
  - Chapitre 8
  - Le multithreading
  - 1. Introduction295
  - 2. Comprendre le multithreading295
  - 3. Multithreading et Java298
  - 4. Implémentation des threads en Java299
  - 4.1 Étendre la classe Thread299
  - 4.2 Implémenter l'interface Runnable302
  - 4.3 S'endormir et S'attendre304
  - 4.4 Abandon depuis le thread primaire307
  - 4.5 Threads et classes anonymes310
  - 4.5.1 Avec l'interface Runnable310
  - 4.5.2 Avec la classe Thread311
  - 4.5.3 Accès simplifié aux variables et aux données membres312
  - 5. Synchronisation entre threads316
  - 5.1 Nécessité de la synchronisation316
  - 5.2 Les méthodes « synchronized »318
  - 5.3 Les traitements « synchronized »320
  - 5.4 La classe Semaphore322
  - 6. Communication inter-threads325
  - 6.1 La méthode join325
  - 6.2 Les objets de synchronisation328
  - 7. Exercice337
  - 7.1 Énoncé337
  - 7.2 Corrige339
  - Chapitre 9
  - Les tests
  - 1. Introduction347
  - 2. Environnement d'exécution des tests unitaires349
  - 3. Le projet avec tests unitaires350
  - 4. La classe de tests352
  - 5. Contenu d'une méthode de test354
  - 6. Traitements de préparation et de nettoyage358
  - 7. Les tests avec paramètres externes361
  - 8. Les suites de tests367
  - 9. Exercice368
  - 9.1 Énoncé368
  - 9.2 Corrigé368
  - Chapitre 10
  - La réflexion
  - 1. Introduction371
  - 2. Mais pour quoi faire ?372
  - 3. Introspection d'une classe Java374
  - 4. Chargement dynamique et utilisation d'une classe découverte376
  - 5. Exercice385
  - 6. Privé, mais pas tant386
  - 7. Décompilation et obfuscation387
  - Chapitre 11
  - Anonymat et lambda
  - 1. Introduction393
  - 2. Les classes anonymes394
  - 2.1 D'une pierre deux coups394
  - 2.2 Syntaxe particulière394
  - 2.3 Exemple d'extension d'une superclasse395
  - 2.4 Exemple d'implémentation d'une interface398
  - 2.5 Échange d'informations399
  - 2.6 Exercice402
  - 2.6.1 Énoncé402
  - 2.6.2 Corrigé402
  - 3. Les expressions lambda404
  - 3.1 Le concept404
  - 3.2 Les interfaces « fonctionnelles » comme modèles405
  - 3.3 Les syntaxes lambda407
  - 3.4 Échange d'informations408
  - 3.5 Exercice408
  - 3.5.1 Énoncé408
  - 3.5.2 Correction408
  - 3.6 Paramètre type Lambda411
  - 3.7 java. util. function, un package « vivier »413
  - 3.8 Application sur des collections414
  - 3.9 Conclusion416
  - Index417
Origine de la notice:
- Electre