You are previewing La programmation orientée objet.
O'Reilly logo
La programmation orientée objet

Book Description

Présentation

L'approche objet est enseignée dans les universités dès les premiers niveaux des cursus informatiques, car sa compréhension est le prérequis indispensable à toute pratique économe, fiable et élégante de la plupart des techniques informatiques qui en sont dérivées, depuis Java et Python, jusqu'à UML 2, en passant par .Net et C++.

L'objet par la pratique avec Python, Java, C# et C++ et PHP 5... en UML 2

Cette cinquième édition de l'ouvrage L'orienté objet décortique l'ensemble des mécanismes de la programmation objet (classes et objets, interactions entre classes, envois de messages, encapsulation, héritage, polymorphisme, interface, multi-threading, sauvegarde des objets, programmation distribuée, modélisation...) en les illustrant d'exemples empruntant aux technologies les plus populaires : Java et C#, C++, Python, PHP 5, UML 2, LinQ mais aussi les services web, Cobra, les bases de données objet, différentes manières de résoudre la mise en correspondance relationnel/objet dont le langage innovant de requête objet LinQ et enfin les design patterns. Chaque chapitre est introduit par un dialogue vivant, à la manière du maître et de l'élève, et se complète de nombreux exercices en UML 2, Java, Python, PHP 5, C# et C++.

À qui s'adresse ce livre ?
  • Ce livre sera lu avec profit par tous les étudiants de disciplines informatiques liées à l'approche objet (programmation orientée objet, modélisation UML, Java, Python, PHP 5, C#/C++...) et pourra être utilisé par leurs enseignants comme matériel de cours.
  • Il est également destiné à tous les développeurs qui souhaitent approfondir leur compréhension des concepts objet sous-jacents au langage qu'ils utilisent.

Le code source des exercices et leurs corrections sont fournis sur le site d'accompagnement www.editions-eyrolles.com

Au sommaire
  • Principes de base : quel objet pour l'informatique
  • Un objet sans classe... n'a pas de classe
  • Du faire-savoir au savoir-faire... du procédural à l'OO
  • Ici Londres : les objets parlent aux objets
  • Collaboration entre classes
  • Méthodes ou messages ?
  • L'encapsulation des attributs
  • Les classes et leur jardin secret
  • Vie et mort des objets
  • UML 2
  • Héritage
  • Redéfinition des méthodes
  • Abstraite, cette classe est sans objet
  • Clonage, comparaison et assignation d'objets
  • Interfaces
  • Distribution gratuite d'objets : pour services rendus sur le réseau
  • Multithreading
  • Programmation événementielle
  • Persistance d'objets
  • Et si on faisait un petit flipper ?
  • Les graphes
  • Petite chimie et biologie OO amusante
  • Design patterns

Table of Contents

  1. Couverture
  2. Titre
  3. Licence
  4. Table
  5. Avant-propos
    1. L’orientation objet en deux mots
    2. Objectifs de l’ouvrage
    3. Plan de l’ouvrage
    4. À qui s’adresse ce livre ?
  6. 1 - Principes de base : quel objet pour l’informatique ?
    1. Le trio <entité, attribut, valeur>
    2. Stockage des objets en mémoire
      1. Types primitifs
      2. Le référent d’un objet
      3. Plusieurs référents pour un même objet
    3. L’objet dans sa version passive
      1. L’objet et ses constituants
      2. Objet composite
      3. Dépendance sans composition
    4. L’objet dans sa version active
      1. Activité des objets
      2. Les différents états d’un objet
      3. Les changements d’état : qui en est la cause ?
      4. Comment relier les opérations et les attributs ?
    5. Introduction à la notion de classe
      1. Méthodes et classes
      2. Sur quel objet précis s’exécute la méthode
    6. Des objets en interaction
      1. Comment les objets communiquent
      2. Envoi de messages
      3. Identification des destinataires de message
    7. Des objets soumis à une hiérarchie
      1. Du plus général au plus spécifique
      2. Dépendance contextuelle du bon niveau taxonomique
    8. Polymorphisme
    9. Héritage bien reçu
    10. Exercices
      1. Exercice 1.1
      2. Exercice 1.2
      3. Exercice 1.3
      4. Exercice 1.4
      5. Exercice 1.5
  7. 2 - Un objet sans classe… n’a pas de classe
    1. Constitution d’une classe d’objets
      1. Définition d’une méthode de la classe : avec ou sans retour
      2. Identification et surcharge des méthodes par leur signature
    2. La classe comme module fonctionnel
      1. Différenciation des objets par la valeur des attributs
      2. Le constructeur
      3. Mémoire dynamique, mémoire statique
    3. La classe comme garante de son bon usage
    4. La classe comme module opérationnel
      1. Mémoire de la classe et mémoire des objets
      2. Méthodes de la classe et des instances
    5. Un premier petit programme complet dans les cinq langages
      1. En Java
      2. EN C#
      3. En C++
      4. En Python
      5. En PHP 5
    6. La classe et la logistique de développement
      1. Classes et développement de sous-ensembles logiciels
      2. Classes, fichiers et répertoires
    7. Exercices
      1. Exercice 2.1
      2. Exercice 2.2
      3. Exercice 2.3
      4. Exercice 2.4
      5. Exercice 2.5
      6. Exercice 2.6
      7. Exercice 2.7
      8. Exercice 2.8
      9. Exercice 2.9
  8. 3 - Du faire savoir au savoir-faire… du procédural à l’OO
    1. Objectif objet : les aventures de l’OO
      1. Argumentation pour l’objet
      2. Transition vers l’objet
    2. Mise en pratique
      1. Simulation d’un écosystème
    3. Analyse
      1. Analyse procédurale
      2. Fonctions principales
    4. Conception
      1. Conception procédurale
      2. Conception objet
    5. Impacts de l’orientation objet
      1. Les acteurs du scénario
      2. Indépendance de développement et dépendance fonctionnelle
      3. Petite allusion (anticipée) à l’héritage
      4. La collaboration des classes deux à deux
  9. 4 - Ici Londres : les objets parlent aux objets
    1. Envois de messages
    2. Association de classes
    3. Dépendance de classes
    4. Réaction en chaîne de messages
    5. Exercices
      1. Exercice 4.1
      2. Exercice 4.2
      3. Exercice 4.3
      4. Exercice 4.4
      5. Exercice 4.5
  10. 5 - Collaboration entre classes
    1. Pour en finir avec la lutte des classes
    2. La compilation Java : effet domino
    3. En C#, en Python, PHP 5 et en C++
    4. De l’association unidirectionnelle à l’association bidirectionnelle
    5. Auto-association
    6. Package et namespace
    7. Exercices
      1. Exercice 5.1
      2. Exercice 5.2
      3. Exercice 5.3
      4. Exercice 5.4
      5. Exercice 5.5
  11. 6 - Méthodes ou messages ?
    1. Passage d’arguments prédéfinis dans les messages
      1. En Java
      2. En C#
      3. En C++
      4. En Python
      5. En PHP 5
    2. Passage d’argument objet dans les messages
      1. En Java
      2. En C#
      3. En PHP 5
      4. En C++
      5. En Python
    3. Une méthode est-elle d’office un message ?
      1. Même message, plusieurs méthodes
      2. Interface : liste de signatures de méthodes disponibles
      3. Des méthodes strictement intimes
    4. La mondialisation des messages
      1. Message sur Internet
      2. L’informatique distribuée
    5. Exercices
      1. Exercice 6.1
      2. Exercice 6.2
      3. Exercice 6.3
      4. Exercice 6.4
      5. Exercice 6.5
      6. Exercice 6.6
  12. 7 - L’encapsulation des attributs
    1. Accès aux attributs d’un objet
      1. Accès externe aux attributs
      2. Cachez ces attributs que je ne saurais voir
      3. Encapsulation des attributs
    2. Encapsulation : pourquoi faire ?
      1. Pour préserver l’intégrité des objets
      2. La gestion d’exception
      3. Pour cloisonner leur traitement
      4. Pour pouvoir faire évoluer leur traitement en douceur
      5. La classe : enceinte de confinement
    3. Exercices
      1. Exercice 7.1
      2. Exercice 7.2
      3. Exercice 7.3
      4. Exercice 7.4
  13. 8 - Les classes et leur jardin secret
    1. Encapsulation des méthodes
      1. Interface et implémentation
      2. Toujours un souci de stabilité
      3. Signature d’une classe : son interface
    2. Les niveaux intermédiaires d’encapsulation
      1. Une classe dans une autre
      2. Utilisation des paquetages
    3. Afin d’éviter l’effet papillon
    4. Exercices
      1. Exercice 8.1
      2. Exercice 8.2
      3. Exercice 8.3
      4. Exercice 8.4
      5. Exercice 8.5
      6. Exercice 8.6
  14. 9 - Vie et mort des objets
    1. Question de mémoire
      1. Un rappel sur la mémoire RAM
      2. L’OO coûte cher en mémoire
      3. Qui se ressemble s’assemble : le principe de localité
      4. Les objets intérimaires
      5. Mémoire pile
      6. Disparaître de la mémoire comme de la vie réelle
      7. Mémoire tas
    2. C++ : le programmeur est le seul maître à bord
      1. La mémoire a des fuites
    3. En Java, C#, Python et PHP 5 : la chasse au gaspi
      1. Le ramasse-miettes (ou garbage collector)
      2. Des objets qui se mordent la queue
    4. Exercices
      1. Exercice 9.1
      2. Exercice 9.2
      3. Exercice 9.3
      4. Exercice 9.4
      5. Exercice 9.5
      6. Exercice 9.6
      7. Exercice 9.7
      8. Exercice 9.8
  15. 10 - UML 2
    1. Diagrammes UML 2
    2. Représentation graphique standardisée
    3. Du tableau noir à l’ordinateur
    4. Programmer par cycles courts en superposant les diagrammes
    5. Diagrammes de classe et diagrammes de séquence
    6. Diagramme de classe
      1. Une classe
      2. Similitudes et différences entre les langages
      3. Association entre classes
      4. Similitudes et différences entre les langages
      5. Pas d’association sans message
      6. Rôles et cardinalité
      7. Dépendance entre classes
      8. Composition
      9. En Java
      10. En C#
      11. En C++
      12. En Python
      13. Classe d’association
      14. Les paquetages
    7. Les bienfaits d’UML
      1. Un premier diagramme de classe de l’écosystème
      2. Des joueurs de football qui font leurs classes
      3. Les avantages des diagrammes de classe
      4. Un diagramme de classe simple à faire, mais qui décrit une réalité complexe à exécuter
      5. Procéder de manière modulaire et incrémentale
    8. Diagramme de séquence
    9. Diagramme d’états-transitions
    10. Exercices
      1. Exercice 10.1
      2. Exercice 10.2
      3. Exercice 10.3
      4. Exercice 10.4
      5. Exercice 10.5
      6. Exercice 10.6
  16. 11 - Héritage
    1. Comment regrouper les classes dans des superclasses
    2. Héritage des attributs
      1. Pourquoi l’addition de propriétés ?
      2. L’héritage : du cognitif aux taxonomies
      3. Interprétation ensembliste de l’héritage
      4. Qui peut le plus peut le moins
    3. Héritage ou composition ?
    4. Économiser en rajoutant des classes ?
    5. Héritage des méthodes
    6. La recherche des méthodes dans la hiérarchie
    7. Encapsulation protected
    8. Héritage et constructeurs
    9. Héritage public en C++
    10. Le multihéritage
      1. Ramifications descendantes et ascendantes
      2. Multihéritage en C++ et Python
        1. Des méthodes et attributs portant un même nom dans des superclasses distinctes
        2. Plusieurs chemins vers une même superclasse
        3. L’héritage virtuel
    11. Exercices
      1. Exercice 11.1
      2. Exercice 11.2
      3. Exercice 11.3
      4. Exercice 11.4
      5. Exercice 11.5
      6. Exercice 11.6
      7. Exercice 11.7
      8. Exercice 11.8
      9. Exercice 11.9
      10. Exercice 11.10
      11. Exercice 11.11
  17. 12 - Redéfinition des méthodes
    1. La redéfinition des méthodes
    2. Beaucoup de verbiage mais peu d’actes véritables
    3. Un match de football polymorphique
      1. La classe Balle
      2. Précisons la nature des joueurs
      3. Passons à l’entraîneur
      4. Passons maintenant au bouquet final
      5. Un même ordre mais une exécution différente
      6. Polymorphisme : uniquement possible dans la mémoire tas
      7. Quand la sous-classe doit se démarquer pour marquer
        1. Les attaquants participent à un « casting »
        2. Éviter les « mauvais castings »
        3. Le « casting » a mauvaise presse
        4. Redéfinition et encapsulation
    4. Exercices
      1. Exercice 12.1
      2. Exercice 12.2
      3. Exercice 12.3
      4. Exercice 12.4
      5. Exercice 12.5
      6. Exercice 12.6
      7. Exercice 12.7
  18. 13 - Abstraite, cette classe est sans objet
    1. De Canaletto à Turner
    2. Des classes sans objet
    3. Du principe de l’abstraction à l’abstraction syntaxique
      1. Classe abstraite
      2. « new » et « abstract » incompatibles
      3. Abstraite de père en fils
      4. Un petit exemple dans les cinq langages de programmation
      5. L’abstraction en Python
    4. Un petit supplément de polymorphisme
      1. Les enfants de la balle
      2. Cliquez frénétiquement
      3. Le Paris-Dakar
      4. Le polymorphisme en UML
    5. Exercices
      1. Exercice 13.1
      2. Exercice 13.2
      3. Exercice 13.3
      4. Exercice 13.4
      5. Exercice 13.5
      6. Exercice 13.6
      7. Exercice 13.7
      8. Exercice 13.8
      9. Exercice 13.9
      10. Exercice 13.10
      11. Exercice 13.11
      12. Exercice 13.12
  19. 14 - Clonage, comparaison et assignation d’objets
    1. Introduction à la classe Object
      1. Une classe à compétence universelle
    2. Décortiquons la classe Object
    3. Test d’égalité de deux objets
      1. Égalité en profondeur
    4. Le clonage d’objets
    5. Égalité et clonage d’objets en Python
    6. Égalité et clonage d’objets en PHP 5
    7. Égalité, clonage et affectation d’objets en C++
      1. Traitons d’abord la mémoire tas
      2. Surcharge de l’opérateur d’affectation
      3. Comparaisons d’objets
      4. La mémoire pile
      5. Surcharge de l’opérateur de comparaison
      6. Dernière étape
    8. En C#, un cocktail de Java et de C++
      1. Pour les structures
      2. Pour les classes
    9. Exercices
      1. Exercice 14.1
      2. Exercice 14.2
      3. Exercice 14.3
      4. Exercice 14.4
      5. Exercice 14.5
      6. Exercice 14.6
      7. Exercice 14.7
  20. 15 - Interfaces
    1. Interfaces : favoriser la décomposition et la stabilité
    2. Java, C# et PHP 5 : interface via l’héritage
    3. Les trois raisons d’être des interfaces
      1. Forcer la redéfinition
      2. Permettre le multihéritage
      3. La carte de visite de l’objet
    4. Les Interfaces dans UML 2
    5. En C++ : fichiers .h et fichiers .cpp
    6. Interfaces : du local à Internet
    7. Exercices
      1. Exercice 15.1
      2. Exercice 15.2
      3. Exercice 15.3
      4. Exercice 15.4
      5. Exercice 15.5
      6. Exercice 15.6
      7. Exercice 15.7
      8. Exercice 15.8
      9. Exercice 15.9
      10. Exercice 15.10
  21. 16 - Distribution gratuite d’objets : pour services rendus sur le réseau
    1. Objets distribués sur le réseau : pourquoi ?
      1. Faire d’Internet un ordinateur géant
      2. Répartition des données
      3. Répartition des utilisateurs et des responsables
      4. Peer-to-peer
      5. L’informatique ubiquitaire
      6. Robustesse
    2. RMI (Remote Method Invocation)
      1. Côté serveur
      2. Côté client
      3. RMIC : stub et skeleton
      4. Lancement du registre
    3. Corba (Common Object Request Broker Architecture)
      1. Un standard : ça compte
      2. IDL
      3. Compilateur IDL vers Java
      4. Côté client
      5. Côté serveur
      6. Exécutons l’application Corba
      7. Corba n’est pas polymorphique
    4. Rajoutons un peu de flexibilité à tout cela
      1. Corba : invocation dynamique versus invocation statique
      2. Jini
      3. XML : pour une dénomination universelle des services
    5. Les services web sur .Net
      1. Code C# du service
      2. WDSL
      3. Création du proxy
      4. Code C# du client
      5. Soap (Simple Object Access Protocol)
      6. Invocation dynamique sous .Net
      7. Invocation asynchrone en .Net
      8. Mais où sont passés les objets ?
      9. Un annuaire des services XML universel : UDDI
      10. Services web vs RMI et Corba
    6. Exercices
      1. Exercice 16.1
      2. Exercice 16.2
      3. Exercice 16.3
      4. Exercice 16.4
      5. Exercice 16.5
      6. Exercice 16.6
      7. Exercice 16.7
      8. Exercice 16.8
      9. Exercice 16.9
      10. Exercice 16.10
      11. Exercice 16.11
      12. Exercice 16.12
  22. 17 - Multithreading
    1. Informatique séquentielle
    2. Multithreading
    3. Implémentation en Java
    4. Implémentation en C#
    5. Implémentation en Python
    6. L’impact du multithreading sur les diagrammes de séquence UML
    7. Du multithreading aux applications distribuées
    8. Des threads équirépartis
    9. Synchroniser les threads
    10. Exercices
      1. Exercice 17.1
      2. Exercice 17.2
      3. Exercice 17.3
      4. Exercice 17.4
      5. Exercice 17.5
      6. Exercice 17.6
      7. Exercice 17.7
      8. Exercice 17.8
  23. 18 - Programmation événementielle
    1. Des objets qui s’observent
    2. En Java
    3. En C# : les délégués
      1. Généralités sur les délégués dans .Net
      2. Retour aux observateurs et observables
    4. En Python : tout reste à faire
    5. Un feu de signalisation plus réaliste
    6. Exercices
      1. Exercice 18.1
      2. Exercice 18.2
      3. Exercice 18.3
      4. Exercice 18.4
  24. 19 - Persistance d’objets
    1. Sauvegarder l’état entre deux exécutions
      1. Et que dure le disque dur
      2. Quatre manières d’assurer la persistance des objets
    2. Simple sauvegarde sur fichier
      1. Utilisation des « streams »
      2. Qui sauve quoi ?
    3. Sauvegarder les objets sans les dénaturer : la sérialisation
      1. Contenu des fichiers de sérialisation : illisible
    4. Les bases de données relationnelles
      1. SQL
      2. Une table, une classe
      3. Comment Java et C# s’interfacent aux bases de données
      4. Relations entre tables et associations entre classes
        1. Relation 1-n
        2. Relation n-n
        3. Dernier problème : l’héritage
    5. Réservation de places de spectacles
    6. Les bases de données relationnelles-objet
      1. SQL3
    7. Les bases de données orientées objet
      1. OQL
    8. Linq
    9. Exercices
      1. Exercice 19.1
      2. Exercice 19.2
      3. Exercice 19.3
      4. Exercice 19.4
      5. Exercice 19.5
      6. Exercice 19.6
      7. Exercice 19.7
      8. Exercice 19.8
      9. Exercice 19.9
      10. Exercice 19.10
  25. 20 - Et si on faisait un petit flipper ?
    1. Généralités sur le flipper et les GUI
      1. Une petite animation en C#
    2. Retour au Flipper
    3. Un petit tennis
  26. 21 - Les graphes
    1. Le monde regorge de réseaux
    2. Tout d’abord : juste un ensemble d’objets
    3. Liste liée
    4. La généricité en C++
    5. La généricité en Java et C#
    6. Passons aux graphes
    7. Exercices
      1. Exercice 21.1
      2. Exercice 21.2
      3. Exercice 21.3
      4. Exercice 21.4
      5. Exercice 21.5
      6. Exercice 21.6
      7. Exercice 21.7
      8. Exercice 21.8
      9. Exercice 21.9
  27. 22 - Petites chimie, biologie et économie OO amusantes
    1. Pourquoi de la chimie OO ?
      1. Chimie computationnelle
      2. Chimie comme plate-forme didactique
      3. Une aide à la modélisation chimique
    2. Les diagrammes de classe du réacteur chimique
      1. Les composants chimiques
        1. La classe composant chimique
        2. Les classes composant neutre et composant chargé
        3. La classe atome
        4. La classe molécule
        5. La classe Groupe
        6. Les trois sous-classes de composant chargé
        7. La classe NœudAtomique
        8. La classe Liaison
        9. Le graphe moléculaire
        10. Les règles de canonisation
      2. Les réactions chimiques
        1. Comment est calculée la cinétique réactionnelle
        2. La classe Reaction
        3. Les sous-classes de Reaction
    3. Quelques résultats du simulateur
    4. La simulation immunologique en OO ?
      1. Petite introduction au fonctionnement du système immunitaire
      2. Le diagramme UML d’état-transition
    5. Dernière simulation : économie de marché
  28. 23 - Design patterns
    1. Introduction aux design patterns
      1. De l’architecte à l’archiprogrammeur
    2. Les patterns « truc et ficelle »
      1. Le pattern singleton
      2. Le pattern adaptateur
      3. Les patterns patron de méthode, proxy, observer et memento
      4. Le pattern flyweight
      5. Les patterns builder et prototype
      6. Le pattern façade
    3. Les patterns qui se jettent à l’OO
      1. Le pattern command
      2. Le pattern décorateur
      3. Le pattern composite
      4. Le pattern chain of responsabililty
      5. Les patterns strategy, state et bridge
  29. Index
    1. Symboles
    2. A
    3. B
    4. C
    5. D
    6. E
    7. F
    8. G
    9. H
    10. I
    11. J
    12. K
    13. L
    14. M
    15. N
    16. O
    17. P
    18. R
    19. S
    20. T
    21. U
    22. V
    23. W
    24. X