Support de cours

Programmation orientée objet Langage Java

Réalisé par: Chiheb-Eddine Ben N’Cir, Maitre-assistant à ESEN, Université de Manouba

Avant Propos

Ce document présente le support de cours du module «Programmation orientée objet (POO)» . Ce

module s'adresse aux étudiants de 2éme année Licence Fondamentale et appliquée en Informatique de

Gestion, de l’ecole supérieure d’economie numérique de l’université de la manouba.

Description du module Année universitaire	2016-2017	Col3	Col4	Col5	Col6	Col7
Année universitaire	2016-2017	2016-2017	2016-2017	2016-2017	2016-2017	2016-2017
Volume Horaire semestriel * (14 semaines)*	Total	Cours	TD	TD	TP	Cours intégré
Volume Horaire semestriel * (14 semaines)*		1.5	1.5	1.5
Equipe pédagogique	Chargé des cours	Chargé des cours	Chargé des cours	Chiheb-eddine ben n’cir	Chiheb-eddine ben n’cir	Chiheb-eddine ben n’cir
Equipe pédagogique	Chargé des TD	Chargé des TD	Chargé des TD
Niveau d’étude	2~~ère~~ année	2~~ère~~ année	2~~ère~~ année	2~~ère~~ année	2~~ère~~ année	2~~ère~~ année
Plan du Cours
Bibliographies :	Bibliographies :	Bibliographies :	Bibliographies :	Bibliographies :	Bibliographies :	Bibliographies :

Partie 1 : Support de cours

Plan Chapitre 1

CHAPITRE 1 : ...................................................................................................................................................... 1

INTRODUCTION A LA PROGRAMMATION ORIENTEE OBJET ............................................................ 1

1. INTRODUCTION A LA CONSTRUCTION DE LOGICIELS .............................................................. 1

1.1 PROBLEMATIQUES ..................................................................................................................................... 1 1.2 SOLUTIONS .................................................................................................................................................... 1

2. PROGRAMMATION PROCEDURALES ............................................................................................... 3

3. PASSAGE DE LA PROGRAMMATION PROCEDURALE A LA PROGRAMMATION OBJETS 5

4. LES PRINCIPES DE LA PROGRAMMATION ORIENTEE OBJET ................................................. 6

CHAPITRE 2 : ...................................................................................................................................................... 8

PRESENTATION DE L’ENVIRONNEMENT JAVA ...................................................................................... 8

CHAPITRE 3 : .................................................................................................................................................... 10

CONCEPTS DE BASE DE LA PROGRAMMATION ORIENTEE OBJET ............................................... 10

1. STRUCTURE D’UN PROGRAMME ORIENTE OBJET .................................................................... 10

1.1. OBJET ................................................................................................................................................. 10 1.2. CLASSE ............................................................................................................................................... 11 1.3. ATTRIBUTS ......................................................................................................................................... 11 1.4. METHODES ......................................................................................................................................... 11 1.5. UN PACKAGE ...................................................................................................................................... 11

2. NOTIONS DE BASE D’UN PROGRAMME ORIENTE OBJET ........................................................ 12

2.1. ENCAPSULATION ................................................................................................................................. 12 2.2. ABSTRACTION ..................................................................................................................................... 13 2.3. SEPARATION ET SPECIALISATION ........................................................................................................ 13

3. APPLICATION : GESTION DE L’INSTITUTION. ............................................................................. 13

CHAPITRE 4 : .................................................................................................................................................... 15

CONSTRUCTION DES CLASSES ET INSTANCIATIONS DES OBJETS EN JAVA .............................. 15

1. DECLARATION DES CLASSES EN JAVA .......................................................................................... 15

1.1. LES ATTRIBUTS ................................................................................................................................... 16 1.2. LES METHODES ................................................................................................................................... 16 1.3. LES CONSTRUCTEURS ......................................................................................................................... 18 1.4. LES ACCESSEURS ................................................................................................................................ 20

2. INSTANCIATION DES OBJETS EN JAVA ......................................................................................... 21

2.1. LA CREATION D'UN OBJET : INSTANCIER UNE CLASSE .......................................................................... 21 2.2. APPEL DES ATTRIBUTS ET DES METHODES A PARTIR DES OBJETS ........................................................ 22 2.3. LA COMPARAISON DES OBJETS ............................................................................................................ 25

3. LES MOTS CLEFS ET LES METHODES SPECIFIQUES (RELATIVES AUX METHODES ET CLASSES) ........................................................................................................................................................... 27

3.1. LE MOT CLE « FINAL » ......................................................................................................................... 27

3.2. LE MOT CLEFS « THIS » ....................................................................................................................... 27 3.3. LE MOT CLEFS « STATIC » ................................................................................................................... 28 3.4. LE MOT CLEFS « INSTANCEOF » .......................................................................................................... 29 3.5. LE MOT CLEFS « NULL » ...................................................................................................................... 29

4. LA SURCHARGE DES METHODES .................................................................................................... 30

CHAPITRE 5....................................................................................................................................................... 31

HERITAGE ET POLYMORPHISME ............................................................................................................. 31

1. L’HERITAGE............................................................................................................................................ 31

2. LA REDEFINITION ................................................................................................................................. 32

EXEMPLE 1 : ...................................................................................................................................................... 33 EXEMPLE 2 ........................................................................................................................................................ 34 EXERCICE .......................................................................................................................................................... 35

CHAPITRE 6....................................................................................................................................................... 37

ABSTRACTION ET UTILISATION DES INTERFACES ............................................................................ 37

1. LES CLASSES ABSTRAITES ................................................................................................................. 37

1.1. SYNTAXE DE DECLARATION DES CLASSES ET DES METHODES ABSTRAITES ......................................... 38

Programmation orientée objet

Chapitre 1 : Introduction à la programmation orientée objet 1. Introduction à la construction de logiciels

1.1 Problématiques

Un Logiciel est ensemble de programmes, de procédés, de règles, et des documentations relatifs au fonctionnement de l’ensemble des traitements d’un système d’information. Le principal rôle d’un logiciel est d’automatiser un processus d’information dans un système d’information. L’automatisation de ce processus permettra de faciliter les taches des utilisateurs.

La construction de logiciel est alors une activité importante qui nécessite l’implication de plusieurs ressources (financières, humaines) et nécessitent un temps considérable. La durée de vie du logiciel ne s’arrête pas au moment de son intégration en le rendant accessible et fonctionnel aux utilisateurs. Un logiciel doit être maintenu et peut évoluer et survivre des années et des années. D’où la nécessité de maintenir le logiciel au fur et à mesure de son utilisation. Les questions qui se posent : comment peuton produire des logiciels de qualité tout en :

Respectant les besoins des utilisateurs
Minimisant les couts de développement
Minimisant les coûts de maintenance et d’évolution
Garantir la Fiabilité

1.2 Solutions

Pour construire des logiciels de qualité il faut appliquer des méthodes et des principes connus de l’ingénieur au domaine du logiciel et qui seront la base de construction d’une industrie de logiciel. On parle des principes du génie logiciels . Quels sont ces principes ?

“ There are two ways of constructing a software design : One way is

to make it so simple that there are obviously no deficiencies, and
the other way is to make it so complicated that there are no obvious

deficiencies. ” Hoare

1 Chiheb-Eddine Ben N’Cir

Programmation orientée objet

Parmi les principes du génie logiciel on peut citer (selon C.ghezzi) :

La décomposition des problèmes en sous-problèmes indépendants.

En anglais « Separation of concerns ». Il s’agit de :

Décorréler les problèmes pour n’en traiter qu’un seul à la fois.
Simplifier les problèmes (temporairement) pour aborder leur complexité progressivement

La modularité

C’est une instance cruciale du principe de décomposition des problèmes. Il s’agit de partitionner le logiciel en modules qui :

ont une cohérence interne (des invariants).
possèdent une interface ne divulguant sur le contenu du module que ce qui est strictement nécessaire aux modules clients.

L’évolution de l’interface est indépendante de celle de l’implémentation du module.

Les choix d’implémentation sont indépendants de l’utilisation du module.

Ce mécanisme s’appelle le camouflage de l’information (information hiding).

L’abstraction

C’est encore une instance du principe de décomposition des problèmes. Il s’agit d’exhiber des concepts généraux regroupant un certain nombre de cas particuliers et de raisonner sur ces concepts généraux plutôt que sur chacun des cas particuliers. Le fait de fixer la bonne granularité de détails permet :

de raisonner plus efficacement.
de factoriser le travail en instanciant le raisonnement général sur chaque cas particulier.

Exemples en programmation : les classes abstraites dans les langages orienté objets, les fonctions d’ordre supérieur.

La généricité.

Un logiciel réutilisable a beaucoup plus de valeur qu’un composant dédié. Un composant est générique lorsqu’il est adaptable à d’autre projet logiciel ou bien il est paramétrable dans d’autres contextes d’utilisations.

2 Chiheb-Eddine Ben N’Cir

Programmation orientée objet

Exemple : Comportement d’une pile sans savoir le type des données contenues.

La construction incrémentale

Un développement logiciel a plus de chances d’aboutir s’il suit une construction incrémental ( baby- steps ).

Exemple 1 :

Laquelle de ses deux méthodes de programmation est la plus efficace ?

Écrire l’ensemble du code source d’un programme et compiler.
Écrire le code source d’une fonction, le compiler et passer à la suivante.

Exemple 2 :

Réaliser un noyau du logiciel
Ajouter les fonctionnalités une à une.

L’anticipation des évolutions.

Un logiciel a un cycle de vie plus complexe que l’habituel cycle « commande-spécificationproduction-livraison ». La maintenance est la gestion des évolutions du logiciels sont 2 phases importante dans le cycle de vie logiciel.

Il est primordial de prévoir les évolutions possibles d’un logiciel pour que la maintenance soit la plus efficace possible. Pour cela, il faut s’assurer que les modifications à effectuer soient le plus locales possibles. Ces modifications ne devraient pas être intrusives car les modifications du produit existant remettent en cause ses précédentes validations.

Il faut concevoir un système suffisamment riche pour que l’on puisse le modifier d’une façon incrémentale. Il faut prévoir et faciliter les changements en favorisant la construction modulaire et en gérants les configurations (trace de ce qu’on a modifié).

Appliquer le principe d’ouverture-fermeture : Le système doit être ouvert aux évolutions mais fermé aux changements.

2. Programmation procédurales

La programmation procédurale consiste à décomposer le processus de construction du logiciel ( on parle de la phase d’implémentation) en plusieurs fonctionnalités (procédures), de complexité plus réduite, qui :

- Effectuent un traitement sur des données

Qui retournent une valeur après leur invocation (fonction)

3 Chiheb-Eddine Ben N’Cir

Programmation orientée objet

L’approche procédurale se base sur la réponse à la question « Que doit faire mon programme ? »

La figure ci-dessus montre la décomposition d’un programme avec une approche procédurale

Figure 1 Structure d'un programme en C (langage procédural)

Les limites d’un programme en programmation procédurale :

Il n’y a pas de méthode ou de cadre pour bien organiser les fonctions.
Les modifications d’une fonction entraînent d’autres modifications dans d’autres fonctions, etc.
La portée d’une modification est trop grande et difficile à gérer.
Difficulté de faire évoluer le code
Redondance dans le code (la même chose est codé plusieurs fois)
Propagation des erreurs – déboggage difficile

4 Chiheb-Eddine Ben N’Cir

Programmation orientée objet

3. Passage de la programmation procédurale à la programmation objets

La programmation structurée traditionnelle consiste à concevoir un ensemble de fonctions (ou algorithmes ) permettant de résoudre un problème. Après avoir déterminé ces fonctions, l’étape suivante consistait traditionnellement à trouver la manière appropriée de stocker des données. C’est la raison pour laquelle le concepteur du langage Pascal, Niklaus Wirth, a intitulé son fameux ouvrage de programmation « Algorithmes + Structures de données = Programmes » . Remarquez que le terme algorithmes est placé en tête dans ce titre, devant l’expression structures de données. Cela montre bien la manière dont les programmeurs travaillaient à cette époque. D’abord, vous décidiez de la manière dont vous alliez manipuler les données ; ensuite seulement, vous choisissiez le genre de structures que vous imposeriez aux données afin de faciliter cette manipulation.

La POO inverse cet ordre et place les données au premier plan avant de déterminer l’algorithme qui sera employé pour opérer sur ces données. En POO, la clé de la productivité consiste à rendre chaque objet responsable de l’accomplissement de quelques tâches associées. Si un objet dépend d’une tâche qui n’est pas de sa responsabilité, il doit avoir accès à un autre objet capable d’accomplir cette tâche. Le premier objet demande alors au second d’exécuter la tâche en question. Cela s’effectue grâce à une version plus généralisée des appels de fonctions auxquels vous êtes habitués en programmation traditionnelle.

Il faut remarquer qu’un objet ne doit jamais manipuler directement les données internes d’un autre objet, pas plus qu’il ne doit rendre accessibles directement les données aux autres objets. Toute communication se fait par l’intermédiaire d’appels de méthodes. Par l’encapsulation des données d’un objet, vous facilitez leur réutilisation, vous réduisez la dépendance aux données et vous minimisez le temps de débogage.

Bien entendu, comme c’est le cas pour les modules d’un langage procédural, il ne faut pas qu’un objet accomplisse trop de choses. La conception et le débogage sont simplifiés lorsque l’on construit de petits objets spécialisés au lieu d’énormes objets contenant des données complexes et possédant des centaines de fonctions pour les manipuler.

La figure ci-dessus montre la différence entre un programme procédurale et un programme orienté objet :

Figure 2 Structure d'un programme procédural et un programme objet

5 Chiheb-Eddine Ben N’Cir

Programmation orientée objet

La construction des logiciels avec des langages orientés objet consiste donc à décomposer le programme en plusieurs objets qui contiennent :

-Des données internes

-Des traitements manipulant des données internes ou d’autres données

Les données d’un objet sont appelées ses attributs et ses traitements sont appelés méthodes (opérations)

Une approche orientée-objet permet de répondre à la question : « De quoi doit être composé mon programme ? »

4. Les principes de la programmation orientée objet

Encapsulation : Tous les données sont soient liées a un objet soient liées à une classe. Chaque objet peut manipuler ces données mais, ne peut accéder aux données d’un autre objet qu’à travers l’échange de message avec l’objet en question
Séparation et spécialisation : Les classes définies (résultat de découplage) doivent être clairement séparables et ne partagent pas des propriétés similaires
Abstraction et généralisation : Détail de l’implémentation seront cachés et les propriétés partagées doivent être modélisées dans une même entité (classe).
Héritage : possibilité d’héritage entre les classes qui partagent des propriétés communes de telle façon qu’une classe est une extension d’une autre classe.

Exemple d’application :

Ecrire un programme qui permet de gérer le calcul des moyennes d’une institution (contenant 10 élèves) sachant que le calcul des moyennes pour :

Etudiant 1 ere et 2 eme: (note1 + note 2 ) /2

Etudiant 3 eme : ((note1 *2) + note pfe) /3

Etudiant 1 ere et 2 eme : nom, prenom, adresse, num-cin, note1 et note 2

Etudiant 3 eme : nom, prenom, adresse, num-cin, note1, note PFE

6 Chiheb-Eddine Ben N’Cir

Programmation orientée objet

Le programme demande à l’utilisateur de saisir les informations des étudiants (de 1 à 10), ensuite affiche les informations et la moyenne de chaque étudiant. Développer le programme en utilisant l’approche procédurale et ensuite en utilisant l’approche Objet.

Question : Comment peut-on relier les différentes données relatives à un étudiant ?

Réponse : Tableaux à indices correspondant aux ronds respectifs des étudiants.

Question : comment peut-on découper (procédure) le programme pour le simplifier.

Réponse : Fonction cal moyenne 1 ere et 2 eme ; Fonction calcul moyenne 3 eme

Résoudre l’exercice en utilisant les notions de la programmation orientée objets

Classe Etudiant Attributs: Méthodes(traitements ou bien opérations)
Classe Etudiant 3 eme Attributs Méthodes
Classe Etudiant 1 et 2 eme Attributs Méthodes

Les objectifs donc de la programmation orientée objet sont :

7 Chiheb-Eddine Ben N’Cir