Conception et programmation orientées objet

Auteur(s) :

Meyer, Bertrand (1950-....) Découvrir l'auteur

Résumé

Méthodes et techniques de la construction logicielle orientée objet. Description des aspects méthodologiques qui conduisent aux concepts orientés objets. Présentation des concepts de classe, de polymorphisme et de liaison dynamique. Illustration de l'aspect logique au travers d'études de cas et de l'évolution du schéma client-serveur. Exemple de l'emploi d'Internet et des systèmes interactifs. ©Electre 2017

Contributeur(s)
- Bezault, Éric. Auteur
- Jouvelot, Pierre (1958-....). Traducteur
Éditeur(s)
- Eyrolles
Date
- 2017
Notes
- Glossaire. Bibliogr. p. [1167]-1191. Index
- La couv. porte en plus : "Un des plus grands classiques de la littérature informatique"
Langues
- Français
- , traduit de : Anglais
Description matérielle
- 1 vol. (XXII-1223 p.) : ill.; ; 24cm
Sujet(s)
ISBN
- 978-2-212-67500-9
Indice
- 681.2 Programmation (généralités)
Quatrième de couverture
- L'oeuvre maîtresse d'un grand nom du génie logiciel et de l'objet
  Conception et programmation orientée objet, un classique de la littérature informatique, a joué un rôle essentiel dans le succès spectaculaire des technologies objet. Écrit par l'un des créateurs du domaine, largement traduit et récompensé par de nombreux prix, le livre de Bertrand Meyer a rendu compréhensible à des centaines de milliers de programmeurs la signification des concepts objet et leur utilisation pratique pour créer des applications de haute qualité.
  Réédité dans l'excellente traduction de Pierre Jouvelot, cet ouvrage est aussi nécessaire aujourd'hui qu'au moment de sa première parution. Si presque tous les programmeurs connaissent un langage à objets, cela ne signifie pas nécessairement qu'ils comprennent et appliquent les concepts sous-jacents.
  Dans un langage d'un grande clarté et sur la base d'une profonde expérience à la fois industrielle et universitaire, ce livre permettra à une nouvelle génération de programmeurs de comprendre en profondeur les bases de la programmation moderne et du génie logiciel.
  À qui s'adresse ce livre ?
  ¤ À tous les architectes logiciel et développeurs souhaitant approfondir leur compréhension des technologies objet.
  ¤ Aux étudiants en informatique de niveaux licence et master, ainsi qu'aux élèves d'écoles d'ingénieur.
Tables des matières
- - Conception et programmation orientées objet
  - Bertrand Meyer
  - Eyrolles
  - Partie A
    Les problèmes1
  - 1. La qualité du logiciel 3
  - 1.1. Facteurs externes et internes3
  - 1.2. Rappel des facteurs externes4
  - 1.3. De la maintenance logicielle17
  - 1.4. Concepts clés introduits dans ce chapitre20
  - 1.5. Notes bibliographiques20
  - 2. Critères d'orientation objet 23
  - 2.1. À propos des critères23
  - 2.2. Méthode et langage24
  - 2.3. Implémentation et environnement33
  - 2.4. Bibliothèques36
  - 2.5. Pour une bande-annonce plus longue37
  - 2.6. Notes bibliographiques et ressources objet37
  - Partie B
    La route de l'orientation objet 39
  - 3. Modularité 41
  - 3.1. Cinq critères42
  - 3.2. Cinq règles48
  - 3.3. Cinq principes55
  - 3.4. Concepts clés introduits dans ce chapitre65
  - 3.5. Notes bibliographiques65
  - 4. Approches de la réutilisabilité 69
  - 4.1. Les objectifs de la réutilisabilité70
  - 4.2. Ce que vous devriez réutiliser72
  - 4.3. Répétition durant le développement logiciel76
  - 4.4. Obstacles non techniques77
  - 4.5. Le problème technique84
  - 4.6. Cinq exigences sur les structures de module86
  - 4.7. Structures modulaires traditionnelles91
  - 4.8. Surcharge et généricité96
  - 4.9. Concepts clés introduits dans ce chapitre101
  - 4.10. Notes bibliographiques102
  - 5. Vers la technologie objet 105
  - 5.1. Les ingrédients du calcul105
  - 5.2. Décomposition fonctionnelle107
  - 5.3. Décomposition orientée objet118
  - 5.4. Construction de logiciel orienté objet120
  - 5.5. Problématique120
  - 5.6. Concepts clés introduits dans ce chapitre122
  - 5.7. Notes bibliographiques123
  - 6. Types abstraits de données 125
  - 6.1. Critères126
  - 6.2. Variations d'implémentation126
  - 6.3. Vers une vue abstraite des objets130
  - 6.4. Formaliser la spécification134
  - 6.5. Des types abstraits de données aux classes145
  - 6.6. Au-delà du logiciel151
  - 6.7. Sujets supplémentaires152
  - 6.8. Concepts clés introduits dans ce chapitre163
  - 6.9. Notes bibliographiques163
  - Partie C
    Techniques orientées objet167
  - 7. La structure statique : les classes 169
  - 7.1. Le sujet n'est pas les objets169
  - 7.2. Éviter la confusion classique170
  - 7.3. Le rôle des classes173
  - 7.4. Un système de types uniforme175
  - 7.5. Une classe simple176
  - 7.6. Conventions de base181
  - 7.7. Le style orienté objet de calcul184
  - 7.8. Exportations sélectives et rétention d'information194
  - 7.9. Regrouper le tout197
  - 7.10. Discussion206
  - 7.11. Concepts clés introduits dans ce chapitre216
  - 7.12. Notes bibliographiques217
  - 8. La structure à l'exécution : les objets 219
  - 8.1. Les objets220
  - 8.2. Les objets comme outils de modélisation230
  - 8.3. Manipuler les objets et les références233
  - 8.4. Procédures de création236
  - 8.5. Approfondir les références240
  - 8.6. Opérations sur les références242
  - 8.7. Objets composites et types expansés252
  - 8.8. Attachement : sémantique par référence et par valeur258
  - 8.9. Utiliser les références : bénéfices et dangers262
  - 8.10. Discussion267
  - 8.11. Concepts clés introduits dans ce chapitre273
  - 8.12. Notes bibliographiques273
  - 9. Gestion de la mémoire 275
  - 9.1. La vie des objets275
  - 9.2. L'approche décontractée286
  - 9.3. Récupérer la mémoire : les problèmes288
  - 9.4. Désallocation gérée par le programmeur289
  - 9.5. L'approche au niveau composant292
  - 9.6. Gestion automatique de la mémoire296
  - 9.7. Le comptage de références297
  - 9.8. Le ramasse-miettes299
  - 9.9. Aspects pratiques du ramasse-miettes304
  - 9.10. Un environnement avec gestion de la mémoire306
  - 9.11. Concepts clés introduits dans ce chapitre309
  - 9.12. Notes bibliographiques310
  - 10. Généricité 311
  - 10.1. Généralisations horizontale et verticale de type311
  - 10.2. La nécessité de paramétrisation de type312
  - 10.3. Classes génériques314
  - 10.4. Tableaux319
  - 10.5. Le coût de la généricité321
  - 10.6. Discussion : ce n'est pas fini322
  - 10.7. Concepts clés introduits dans ce chapitre323
  - 10.8. Notes bibliographiques323
  - 11. Conception par contrat : construire du logiciel fiable 325
  - 11.1. Les mécanismes de base de la fiabilité326
  - 11.2. À propos de la correction logicielle326
  - 11.3. Exprimer une spécification328
  - 11.4. Introduire des assertions dans les textes logiciels331
  - 11.5. Préconditions et postconditions331
  - 11.6. Contrat de fiabilité logicielle335
  - 11.7. Travailler avec des assertions341
  - 11.8. Invariants de classe354
  - 11.9. Quand une classe est-elle correcte ?359
  - 11.10. La connexion avec les ADT363
  - 11.11. Une instruction d'assertion368
  - 11.12. Invariants et variantes de boucle370
  - 11.13. Utiliser les assertions377
  - 11.14. Discussion386
  - 11.15. Concepts clés introduits dans ce chapitre394
  - 11.16. Notes bibliographiques395
  - 11.17. Post scriptum : Le crash d'Ariane 5397
  - 12. Quand le contrat est rompu : le traitement des exceptions 399
  - 12.1. Concepts de base du traitement des exceptions399
  - 12.2. Traitement des exceptions402
  - 12.3. Un mécanisme d'exception406
  - 12.4. Exemples de traitement d'exceptions409
  - 12.5. La tâche d'une clause de récupération415
  - 12.6. Traitement avancé des exceptions418
  - 12.7. Discussion422
  - 12.8. Concepts clés introduits dans ce chapitre423
  - 12.9. Notes bibliographiques424
  - 13. Mécanismes supplémentaires 425
  - 13.1. Interface avec du logiciel non OO425
  - 13.2. Passage d'arguments430
  - 13.3. Instructions432
  - 13.4. Expressions437
  - 13.5. Chaînes441
  - 13.6. Entrées et sorties442
  - 13.7. Conventions lexicales442
  - 13.8. Concepts clés introduits dans ce chapitre443
  - 14. Introduction à l'héritage 445
  - 14.1. Polygones et rectangles446
  - 14.2. Polymorphisme454
  - 14.3. Typage de l'héritage457
  - 14.4. Liaison dynamique465
  - 14.5. Caractéristiques et classe retardées467
  - 14.6. Techniques de redéclaration475
  - 14.7. Le sens de l'héritage478
  - 14.8. Le rôle des classes retardées484
  - 14.9. Discussion491
  - 14.10. Concepts clés introduits dans ce chapitre500
  - 14.11. Notes bibliographiques501
  - 15. Héritage multiple 503
  - 15.1. Exemples d'héritage multiple503
  - 15.2. Renommer les caractéristiques518
  - 15.3. Aplatir la structure524
  - 15.4. Héritage répété526
  - 15.5. Discussion545
  - 15.6. Concepts clés introduits dans ce chapitre548
  - 15.7. Notes bibliographiques548
  - 16. Techniques d'héritage 551
  - 16.1. Héritage et assertions551
  - 16.2. La structure globale d'héritage562
  - 16.3. Caractéristiques gelées564
  - 16.4. Généricité contrainte567
  - 16.5. La tentative d'affectation572
  - 16.6. Typage et redéclaration576
  - 16.7. Déclaration ancrée580
  - 16.8. Héritage et rétention d'information586
  - 16.9. Concepts clés introduits dans ce chapitre591
  - 16.10. Note bibliographique592
  - 17. Typage 593
  - 17.1. Le problème du typage593
  - 17.2. Typage statique : pourquoi et comment597
  - 17.3. Covariance et rétention de descendance603
  - 17.4. Premières approches de la validité de système610
  - 17.5. Compter sur les types ancrés612
  - 17.6. Analyse globale615
  - 17.7. Attention aux appels cat polymorphes !618
  - 17.8. Une évaluation621
  - 17.9. L'accord parfait622
  - 17.10. Concepts clés introduits dans ce chapitre623
  - 17.11. Notes bibliographiques623
  - 18. Objets globaux et constantes 625
  - 18.1. Constantes de type de base626
  - 18.2. Utilisation des constantes627
  - 18.3. Constantes de type de classe628
  - 18.4. Applications des routines à exécution unique630
  - 18.5. Constantes de type chaine635
  - 18.6. Valeurs uniques636
  - 18.7. Discussion637
  - 18.8. Concepts clés introduits dans ce chapitre641
  - 18.9. Notes bibliographiques641
  - Partie D
    Méthodologie orienté objet : bien appliquer la méthode643
  - 19. De la méthodologie 645
  - 19.1. Méthodologie logicielle : quoi et pourquoi645
  - 19.2. Concevoir de bonnes règles : conseil aux conseillers646
  - 19.3. De l'utilisation des métaphores653
  - 19.4. De l'importance d'être humble654
  - 19.5. Notes bibliographiques655
  - 20. Schéma de conception : systèmes interactifs à écrans multiples 657
  - 20.1. Systèmes à écrans multiples657
  - 20.2. Une tentative simpliste659
  - 20.3. Une solution fonctionnelle descendante660
  - 20.4. Une critique de la solution663
  - 20.5. Une architecture orientée objet665
  - 20.6. Discussion674
  - 20.7. Notes bibliographique674
  - 21. Étude de cas d'héritage : « défaire » dans un système interactif 675
  - 21.1. Perseverare diabolicum675
  - 21.2. Trouver les abstractions679
  - 21.3. Défaire-refaire à niveaux multiples684
  - 21.4. Questions d'implémentation686
  - 21.5. Une interface utilisateur pour défaire et refaire690
  - 21.6. Discussion691
  - 21.7. Notes bibliographiques694
  - 22. Comment trouver les classes 697
  - 22.1. Étudier un document d'exigences698
  - 22.2. Les signaux de danger703
  - 22.3. Heuristiques générales pour trouver les classes709
  - 22.4. Autres sources de classes713
  - 22.5. Réutilisation718
  - 22.6. La méthode pour obtenir des classes719
  - 22.7. Concepts clés introduits dans ce chapitre720
  - 22.8. Notes bibliographiques721
  - 23. Principes de conception des classes 723
  - 23.1. Effets de bord dans les fonctions724
  - 23.2. Combien d'arguments par caractéristique ?739
  - 23.3. Taille de classe : l'approche de la liste de commissions745
  - 23.4. Structures de données actives749
  - 23.5. Exportation sélective768
  - 23.6. Traiter les cas anormaux769
  - 23.7. Évolution de classe : la clause obsolète774
  - 23.8. Documenter une classe et un système775
  - 23.9. Concepts clés introduits dans ce chapitre778
  - 23.10. Notes bibliographiques778
  - 24. Bien utiliser l'héritage 781
  - 24.1. Comment ne pas utiliser l'héritage781
  - 24.2. Préféreriez-vous acheter ou hériter ?784
  - 24.3. Une application : la technique du handle789
  - 24.4. Taxomanie791
  - 24.5. Utiliser l'héritage : une taxonomie de la taxonomie793
  - 24.6. Un mécanisme, ou plusieurs ?804
  - 24.7. Héritage de sous-type et rétention de descendant806
  - 24.8. Héritage d'implémentation814
  - 24.9. Héritage de service817
  - 24.10. Critères multiples et héritage de vue821
  - 24.11. Comment développer des structures d'héritage827
  - 24.12. Une vision d'ensemble : bien utiliser l'héritage830
  - 24.13. Concepts clés introduits dans ce chapitre831
  - 24.14. Notes bibliographiques832
  - 24.15. Une brève histoire de la taxonomie832
  - 25. Techniques utiles 841
  - 25.1. Philosophie de conception841
  - 25.2. Classes842
  - 25.3. Techniques d'héritage843
  - 26. Un penchant pour le style 845
  - 26.1. De l'importance du style845
  - 26.2. Choisir les bons noms849
  - 26.3. Utiliser des constantes854
  - 26.4. Commentaires d'en-tête et clauses d'indexation855
  - 26.5. Mise en pages et présentation861
  - 26.6. Fontes869
  - 26.7. Notes bibliographiques870
  - 27. Analyse orientée objet 873
  - 27.1. Les objectifs de l'analyse873
  - 27.2. La nature changeante de l'analyse876
  - 27.3. La contribution de la technologie objet876
  - 27.4. Programmer une station de télévision877
  - 27.5. Exprimer l'analyse : vues multiples883
  - 27.6. Méthodes d'analyse887
  - 27.7. La notation d'objets métiers889
  - 27.8. Bibliographie892
  - 28. Le processus de construction logicielle 893
  - 28.1. Groupes893
  - 28.2. Ingénierie concurrente894
  - 28.3. Étapes et tâches896
  - 28.4. Le modèle de groupe du cycle de vie logiciel896
  - 28.5. Généralisation898
  - 28.6. Intégration et réversibilité900
  - 28.7. Chez nous, tout est comme le visage902
  - 28.8. Concepts clés introduits dans ce chapitre903
  - 28.9. Notes bibliographiques904
  - 29. Enseigner la méthode 905
  - 29.1. Formation industrielle905
  - 29.2. Cours d'introduction907
  - 29.3. Autres cours910
  - 29.4. Vers une nouvelle pédagogie logicielle912
  - 29.5. Un plan orienté objet916
  - 29.6. Concepts clés introduits dans ce chapitre918
  - 29.7. Notes bibliographiques918
  - Partie E
    Aspects avancés919
  - 30. Concurrence, répartition, client-serveur et Internet 921
  - 30.1. Un aperçu921
  - 30.2. L'essort de la concurrence923
  - 30.3. Des processus aux objets927
  - 30.4. Introduction de l'exécution concurrente934
  - 30.5. Questions de synchronisation946
  - 30.6. Accès aux objets séparés951
  - 30.7. Conditions d'attente960
  - 30.8. Demander un service spécial967
  - 30.9. Exemples972
  - 30.10. Vers une règle de preuve988
  - 30.11. Résumé du mécanisme990
  - 30.12. Discussion993
  - 30.13. Concepts clés introduits dans ce chapitre997
  - 30.14. Notes bibliographiques998
  - 31. Persistance d'objets et bases de données 1003
  - 31.1. Persistance dans le langage1003
  - 31.2. Au-delà de la fermeture de persistance1005
  - 31.3. Évolution de schéma1007
  - 31.4. De la persistance aux bases de données1013
  - 31.5. Interopérabilité objet-relationnel1014
  - 31.6. Fondements des bases de données orientées objet1016
  - 31.7. Systèmes de bases de données OO : Exemples1022
  - 31.8. Discussion : au-delà des bases de données1024
  - 31.9. Concepts clés introduits dans ce chapitre1027
  - 31.10. Notes bibliographiques1027
  - 32. Quelques techniques OO pour applications graphiques interactives 1029
  - 32.1. Outils requis1030
  - 32.2. Portabilité et adaptation de la plate-forme1033
  - 32.3. Abstractions graphiques1035
  - 32.4. Mécanismes d'interaction1037
  - 32.5. Traitement des événements1039
  - 32.6. Un modèle mathématique1043
  - 32.7. Notes bibliographiques1043
  - Partie F
    Appliquer la méthode dans divers langages et environnements1045
  - 33. Programmation OO et Ada 1047
  - 33.1. Rappel historique1047
  - 33.2. Paquetages1049
  - 33.3. Une implémentation de pile1049
  - 33.4. Cacher la représentation : l'histoire privée1053
  - 33.5. Exceptions1055
  - 33.6. Tâches1058
  - 33.7. D'ADA à ADA 951059
  - 33.8. Concepts clés introduits dans ce chapitre1064
  - 33.9. Notes bibliographiques1064
  - 34. Émulation de la technologie objet dans les environnements non OO 1067
  - 34.1. Niveaux de prise en compte par le langage1067
  - 34.2. Programmation orientée objet en pascal ?1069
  - 34.3. Fortran1070
  - 34.4. Programmation orientée objet et C1073
  - 34.5. Notes bibliographiques1080
  - 35. De Simula à Java et au-delà : principaux langages et environnement OO 1081
  - 35.1. Simula1081
  - 35.2. Smalltalk1094
  - 35.3. Extensions lisp1097
  - 35.4. Extensions C1098
  - 35.5. Java1103
  - 35.6. Autres langages OO1104
  - 35.7. Notes bibliographiques1104
  - Partie G
    Faire les choses bien1109
  - 36. Un environnement orienté objet 1111
  - 36.1. Composants1111
  - 36.2. Langage1112
  - 36.3. Technologie de compilation1112
  - 36.4. Outils1116
  - 36.5. Bibliothèques1119
  - 36.6. Mécanismes d'interface1120
  - 36.7. Notes bibliographiques1127
  - Épilogue : le langage dévoilé 1129
  - Partie H
    Annexes1131
  - A. Extraits des bibliothèques Base 1133
  - B. Généricité et héritage 1135
  - C. Glossaire de la technologie objet 1155
  - D. Bibliographie 1167
  - Index 1193
Origine de la notice:
- Electre