COURS POO Vers 2020

Programmation Orientée Objet
Support de cours
Cours destiné aux Ingénieurs en SI
Donacien GUIFO KOUAM
[email protected]
IAI – 2018/2019 Donacien GUIFO Page 1

Table des matières
Syllabus – Introduction à la POO ................................................................................................................. 3
Chapitre 1 – CONCEPTS DE BASE ........................................................................................................... 6
Chapitre 2 – Encapsulation et surcharge ..................................................................................................... 12
Chapitre 3 – L’HERITAGE ....................................................................................................................... 18
Chapitre 4 – Le Polymorphisme ................................................................................................................. 28
Chapitre 5 –Classes Abstraites et Interfaces ................................................................................................ 34

Syllabus – Introduction à la POO

Présentation du cours
Le cours est une introduction aux paradigmes de la programmation orientée objet. Il présente les notions de
base de cette technologie : type abstrait de données, classe, objet, héritage simple et multiple, objet complexe.
Mécanisme d’abstraction, surcharge, généricité, polymorphisme. Nous utiliserons le langage JAVA pour
illustrer nos exemples d’application
.
Niveaux cibles :
Étudiants de 2ème Année AP, 1ère Année du cycle des Ingénieurs et du Master S8 en Conception des systèmes
d’information.
Pré-requis :
Savoir écrire des algorithmiques, connaitre les principales structures de données, avoir effectué des travaux
pratiques en algorithmique et structure de donnée (aussi bien en programmation impérative que
fonctionnelle).
Formule pédagogique :
 Exposé informel
 Salle machine
Moyens pédagogiques :
 Tableau
 Support de cours
Méthodologie :
 Cours intégré
 Travaux dirigés (réalisation et correction d’exercices)
 Travaux pratiques (JAVA sous Eclipse ou NetBeans)
Volume Horaire :
 20 heures de cours
 30 heures de travaux pratiques/dirigés
Objectifs généraux :
 Comprendre les origines et l’intérêt d’un nouveau style de programmation
 Maîtriser les concepts orientés objet en termes de définitions, syntaxe Java et usage
 Savoir utiliser cette nouvelle approche pour modéliser des problèmes
 Faire la liaison entre les différents éléments du cours (classes, objets, encapsulation, héritage,
polymorphisme, classe abstraite et interfaces)
Objectifs Généraux Conditions de réalisation de la Critère d’évaluation de la

performance performance
1- S’initier aux concepts orientés A partir des notes du cours, des Aucune confusion possible entre
objets et leurs intérêts pratiques. travaux dirigés et des références les principes de la programmation
bibliographiques, l’étudiant doit classique et la programmation
être capable de dégager les lacunes objet
de l’approche classique de
programmation et de distinguer
les principales caractéristiques de
POO

2- Comprendre les concepts A partir des notes du cours, des Les exercices relatifs à
orientés objet en termes de travaux dirigés et des références l’implémentation d’une classe en
concept, syntaxe Java et bibliographiques, l’étudiant doit Java doivent être réussis
utilisation. être capable de concevoir des
classes et des objets en Java
3- Comprendre l’utilité et A partir des notes du cours, des Les exercices relatifs à l’accès aux
l’application des concepts travaux dirigés et des références membres privés doivent être
d’encapsulation et de surcharge. bibliographiques, l’étudiant doit maîtrisés
maîtriser les concepts
d’encapsulation et surcharge
4- Comprendre la technique A partir des notes du cours, des Aucune erreur n’est permise au
d’héritage et ses intérêts pratiques travaux dirigés et des références niveau de la définition et la
bibliographiques, l’étudiant doit manipulation d’une classe dérivée
être capable de concevoir et
implémenter des classes dérivées
5- Comprendre le concept de A partir des notes du cours, des Aucune erreur n’est permise au
polymorphisme et ses intérêts travaux dirigés et des références niveau de la liaison entre l’héritage
pratiques bibliographiques, l’étudiant doit et le polymorphisme
comprendre l’intérêt pratique de
polymorphisme et la relation avec
l’héritage
6- Comprendre et distinguer entre A partir des notes du cours, des Aucune confusion entre les 2
les 2 concepts de classes abstraites travaux dirigés et des références concepts n’est permise
et interfaces bibliographiques, l’étudiant doit
comprendre l’utilité pratique des
classes abstraites et interfaces et
distinguer les nuances entre ces 2
concepts
Évaluation : 1 test (bonus), 1 TP(60%) et un contrôle final écrits(40%).
Bibliographie :
 http://java.com
 www.openclassrooms.com
 Cours Philippe Genoud, Java un langage Orienté Objets. L'approche Objets, Université
Joseph Fourrier, IMAG, Sept 2008
 Bailly C, Chaline J.F., Ferry H.C & al, Les langages orientés objets, Cepadues éditions.

Chapitre 1 – CONCEPTS DE BASE

2.1 Introduction
La programmation classique telle qu’étudiée au travers des langages C, Pascal… définie un programme comme
étant un ensemble de données sur lesquelles agissent des procédures et des fonctions. Les données constituent
la partie passive du programme. Les procédures et les fonctions constituent la partie active. Programmer dans
ce cas revenait à : - définir un certain nombre de variables (structures, tableaux…) - écrire des procédures
pour les manipuler sans associer explicitement les unes aux autres. Exécuter un programme se réduit alors à
appeler ces procédures dans un ordre décrit par le séquençage des instructions et en leur fournissant les
données nécessaires à l’accomplissement de leurs tâches.
Données
Fonction1
Fonction2
Procédure1
Procédure2
Dans cette approche données et procédure sont traitées indépendamment les unes des autres sans tenir
compte des relations étroites qui les unissent. Les questions qu’on peut se poser dans ce cas :
1. Cette séparation (données, procédures) est-elle utile ?
2. Pourquoi privilégier les procédures sur les données (Que veut-on faire ?) ?
3. Pourquoi ne pas considérer que les programmes sont avant tout des ensembles d’objets informatiques
caractérisés par les opérations qu’ils connaissent ?
Les langages objets sont nés pour répondre à ces questions. Ils sont fondés sur la connaissance d’une seule
catégorie d’entités informatiques : les objets. Un objet incorpore des aspects statiques et dynamiques au sein
d’une même notion. Avec les objets se sont les données qui deviennent prépondérantes.
On répond tout d’abord à la question « De quoi parle-t-on ? »
2.2 Définition : Qu’est-ce qu’un objet ?

Un objet est une modélisation de toute entité identifiable, concrète ou abstraite, manipulée par l’application
logicielle
• une chose tangible :ex: ville, véhicule, étudiant, un bouton sur l’écran
• une chose conceptuelle : ex: date, réunion, planning de réservation
Un objet réagit à certains messages qu’on lui envoie de l’extérieur; la façon et la façon dont il réagit détermine
le comportement de l’objet.
Un objet ne réagit pas toujours de la même façon à un même message; sa réaction dépend de l’état dans
lequel il se trouve.
Un objet possède :
– Une identité unique (permet de distinguer un objet d’un autre)
– Un état interne donné par des valeurs de variables (ou attributs)
• Attributs décrivent l’état de l’objet à un instant donné
ex: patient mesure 1,82 m et pèse 75 Kg
• Attributs sont typés et nommés
ex: float hauteur; float poids;
– Un comportement (capacités d’action de l’objet) donné par des fonctions ou sous-programmes, appelés
méthodes (ou opérations).
• Les méthodes définissent le comportement de l’objet (ce qu’il peut faire, comment il peut le faire…)
et ses réactions aux stimulations externes
ex: un étudiant passe un examen, etc…
• Les méthodes implémentent également les algorithmes invocables sur cet objet
Exemple :
Comportement de l’objet
Etat de l’objet
(caché)
(public)
Les objectifs de la POO :

 Faciliter le développement et l'évolution des applications ;
 Permettre le travail en équipe ;
 Augmenter la qualité des logiciels (moins de bugs).
Solutions proposées :
 Découpler (séparer) les parties des projets ;
 Limiter (et localiser) les modifications lors des évolutions ;
 Réutiliser facilement du code.
Conclusion : Un objet = données + algorithmes

Un objet est le regroupement de données (variables ou attributs) et des traitements (méthodes) associées
2.3 Programmation orientée-objet
Chaque langage de programmation appartient à une “famille” de langages définissant une approche ou une
méthodologie générale de programmation. Par exemple, le langage C est un langage de programmation
procédurale car il suppose que le programmeur s’intéresse en priorité aux traitements que son programme
devra effectuer. Un programmeur C commencera par identifier ces traitements pour écrire les fonctions qui
les réalisent sur des données prises comme paramètres d’entrée.
La programmation orientée-objet (introduite par le langage SmallTalk) propose une méthodologie centrée sur
les données. Le programmeur Java va d’abord identifier un ensemble d’objets, tel que chaque objet représente
un élément qui doit être utilisé ou manipulé par le programme, sous la forme d’ensembles de données. Ce
n’est que dans un deuxième temps, que le programmeur va écrire les traitements, en associant chaque
traitement à un objet donné. Un objet peut être vu comme une entité regroupant un ensemble de données et
de méthodes (l’équivalent d’une fonction en C) de traitement.
Il existe plusieurs langages orienté objet. Les principaux sont :
 C++ : très utilisé
 C# : langage de Microsoft (appartient à .NET)
 Objective C : langage utilisé par Apple
 PHP : langage très utilisé en programmation Web
 Python de plus en plus utilisés en ingénierie des données (Data science)
 Ruby
 Eiffel
 Ada
 Smalltalk
 Etc…
La syntaxe change mais le concept objet est le même quel que soit le langage utilisé !
B
Dans le cadre de ce cours, nous allons utiliser le langage JAVA qui :
 est un langage de programmation orienté objet
 crée par James Gosling et Patrick Naughton (Sun Microsystems)
 présenté officiellement le 23 mai 1995.
Les objectifs de Java :

 Simple, orienté objet et familier ;
 Robuste et sûr ;
 Indépendant de la machine employée pour l'exécution ;
 Très performant ;
 Interprété, multitâches et dynamique.
2.4 Notion de Classe

Un objet est une variable (presque) comme les autres. Il faut notamment qu’il soit déclaré avec son type. Le
type d’un objet est un type complexe (par opposition aux types primitifs entier, caractère, …) qu’on appelle
une classe.
Une classe regroupe un ensemble de données (qui peuvent être des variables primitives ou des objets) et un
ensemble de méthodes de traitement de ces données et/ou de données extérieures à la classe. On parle
d’encapsulation pour désigner le regroupement de données dans une classe.

Par exemple, une classe Rectangle utilisée pour instancier des objets représentant des rectangles, encapsule 4
entiers : la longueur et la largeur du rectangle ainsi que la position en abscisse et en ordonnée de l’origine du
rectangle (par exemple, le coin en haut à gauche). On peut alors imaginer que la classe Rectangle implémente
une méthode permettant de déplacer le rectangle qui nécessite en entrée deux entiers indiquant la distance de
déplacement en abscisse et en ordonnée.
L’accès aux positions de l’origine du rectangle se fait directement (i.e. sans passage de paramètre) lorsque les
données sont encapsulées dans la classe où est définie la méthode. Un exemple, écrit en Java, de la classe
Rectangle est donné ci-dessous :
class Rectangle {
int longueur ;
int largeur ;
int origine_x ;
int origine_y ;
void deplace(int x, int y) {
this.origine_x = this.origine_x + x ;
this.origine_y = this.origine_y + y ;
}
int surface() {
return this.longueur * this.largeur ;
}
}
Pour écrire un programme avec un langage orienté-objet, le programmeur écrit uniquement des classes
correspondant aux objets de son système. Les traitements à effectuer sont programmés dans les méthodes de
ces classes qui peuvent faire appel à des méthodes d’autres classes. En général, on définit une classe, dite
“exécutable”, dont une méthode peut être appelée pour exécuter le programme.

2.5 Concept de base de la POO
La POO se base sur les notions clés suivantes :

 Classes et objets
 Encapsulation
 Héritage
 Abstraction /Interface
 Polymorphisme

Chapitre 2 – Encapsulation et surcharge
Objectifs spécifiques
 Introduire la notion d’encapsulation et ses intérêts pratiques
 Comprendre les droits d’accès aux membres et aux classes
 Maîtriser le concept de surcharge des méthodes
Eléments de contenu
1. L’encapsulation
2. Modificateurs de visibilité et accès
3. Surcharge des méthodes

3.1 L’encapsulation
L’encapsulation est la possibilité de ne montrer de l’objet que ce qui est nécessaire à son utilisation.
L’encapsulation permet d’offrir aux utilisateurs d’une classe la liste des méthodes et éventuellement des
attributs utilisables depuis l’extérieur. Cette liste de services exportables est appelée l’interface de la classe et
elle est composée d’un ensemble des méthodes et d’attributs dits publics (Public).
Les méthodes et attributs réservés à l’implémentation des comportements internes à l’objet sont dits privés
(Private). Leur utilisation est exclusivement réservée aux méthodes définies dans la classe courante.
Les avantages de l’encapsulation sont :
 Simplification de l’utilisation des objets,
 Meilleure robustesse du programme,
 Simplification de la maintenance globale de l’application
3.2 Modificateurs de visibilité et Accès
3.2.1 Modificateurs de visibilité
Les attributs et les méthodes sont précédés lors de la déclaration par l’un des modificateurs de visibilité
suivants : «public», «private», «protected» et Néant.
 Une méthode, classe ou attribut sont déclarés comme publiques « public » s’ils doivent être visibles
à l’intérieur et à l’extérieur quel que soit leur package.
 Une méthode, classe ou attribut ne sont pas précédés par un modificateur de visibilité explicite
(Néant) ne vont être visibles qu’à l’intérieur de même package. C'est-à-dire seules les classes de
même package peuvent accéder aux attributs et méthodes de classes « amies ». Ce modificateur de
visibilité est aussi appelé « modificateur de package » ou modificateur « freindly ».
 Une méthode ou attributs définis comme étant privés « private » s’ils sont accessibles uniquement
par les méthodes de la classe en cours. Ils ne sont pas accessibles ailleurs.
 Une méthode ou attribut sont définis comme protégés « protected » s’ils ne peuvent être
accessibles qu’à travers les classes dérivées ou les classes de même package.
Tableaux récapitulatifs des droits d’accès

Public Protected Default(néant) Private
Dans la même classe Oui Oui Oui Oui
Dans une classe du même Oui Oui Oui Non
package
Dans une sous-classe d’un autre Oui Oui Non Non
package
Dans une classe quelconque Oui Non Non Non
3.2.2 Accès aux membres privés
 Pour accéder aux attributs de l’intérieur de la classe, il suffit d’indiquer le nom de l’attribut que
l’on veut y accéder.
 Pour accéder de l’extérieur de la classe, on utilise la syntaxe suivante :
<nom_méthode>.<nom_attribut>
Exemple 1
Si longueur et largeur étaient des attributs publics de Rectangle, on peut écrire le code suivant dans la méthode
« main » de la classe Test_Rect
Rectangle r = new Rectangle ();

r.longueur = 20;
r.largeur = 15;
int la = r.longueur ;
Si longueur et largeur étaient des attributs privés « private », les instructions suivantes seront refusées par le
compilateur
r.longueur = 20; //faux
r.largeur = 15; //faux
int la = r.longueur ; //faux
Il fallait dans le deuxième cas définir des méthodes d’accés « setlong (int) » et « setlarg (int) » qui permettent
de modifier les valeurs des attributs et les méthodes d’accès « getlong ()» et « getlarg ()» pour retourner les
valeurs de longueur et de largeur d’un objet Rectangle. Dans ce cas, les instructions seront les suivantes :
r.setlong(20); //juste
r.setlarg(15); //juste
int la = r.getlong() ; //juste
Exemple 2
public class Rectangle

{
private int longueur;
private int larg;
Rectangle (int l, int a) //Le premier constructeur
{longueur= l; larg= a;}
Rectangle() // Le deuxième constructeur
{longueur= 20; larg= 10;}
Rectangle (int x) //Le troisième constructeur
{longueur= 2*x;larg= x;}
int getlong () //pour retourner la valeur de longueur
{return (longueur);}
int getlarg () //Pour retourner la largeur

{return (larg);}
void setlong (int l) //pour modifier la longueur

{longueur=l;}
void setlarg (int l) //pour modifier la largeur

{larg=l;}
int surface() //Pour calculer la surface

{return(longueur*larg);}
int périmètre() //pour calculer le périmètre
{
return((larg+longueur)*2);}
void allonger(int l) //Pour allonger la longueur d’un rectangle

{
longueur+=l;}
void affiche() //pour afficher les caractéristiques d’un rectangle
{
System.out.println("Longueur=" + longueur + "et Largeur =" + larg );}
}
Code de la classe Test_Rect

class Test_Rec
{
public static void main(String []args)
{
Rectangle r = new Rectangle(10,5);
Rectangle r3;
r3= new Rectangle (14);
Rectangle r2 = new Rectangle();
r.affiche();
r2.affiche();
r3.affiche() ;
r2.setlong(50);
r2.setlarg(30);
r2.affiche();
System.out.println("Rectangle1" );
System.out.println("Surface= " + r.surface());
System.out.println("Périmetre= " + r.perimetre());
r.allonger(40);
System.out.println("Aprés allongement");
r.affiche();
}
}
3.3 Surcharge des Méthodes

La surcharge est la capacité des objets d’une même hiérarchie de classes à répondre différemment à une
méthode de même nom, mais avec des paramètres différents. Par exemple, la classe Rectangle peut avoir
plusieurs méthodes Allonger () acceptant des paramètres différents en nombre et/ou en types.
En fonction du type et du nombre de paramètres lors de l’appel, la méthode correspondante sera choisie.
Le mécanisme de surcharge permet de réutiliser le nom d’une méthode déjà définie, pour une autre méthode
qui en différera par ses paramètres.
La méthode surchargée doit conserver la même “intention sémantique”

La surcharge peut se faire sur une méthode définie localement ou héritée.
Exemple
void allonger(int l) //Pour allonger la longueur d’un rectangle
{

longueur+=l;}
void allonger(int l, int k) //Pour allonger un rectangle
{
longueur+=l;
larg+= k ;}
Lors de l’appel des méthodes surchargées, le compilateur sait distinguer entre les méthodes en considérant le
nombre et les types des paramètres
Rectangle r = new Rectangle (5,10) ; //Appel de constructeur à 2 paramètres
r.allonger (10) ; // Appel de la 1ère méthode surchargée
r.allonger (10, 3) ; // Appel de la 2ème méthode surchargée
3.4 Evaluation formative
Exercice 1:
public class Livre {
// Variables
private String titre, auteur;
private int nbPages
// Constructeur
public Livre(String unAuteur, String unTitre) {
auteur = unAuteur;
titre = unTitre;}
// getter
public String getAuteur() {
return auteur;
}
// Setter
void setNbPages(int n) {
nbPages = nb;}
}
a- Corrigez quelques petites erreurs

b- ajoutez une méthode main() pour Créer 2 livres, Faire afficher les auteurs de ces 2 livres.
Exercice 2:
Accesseurs et modificateurs
1) Modifiez la classe Livre :
 Ajoutez un gettet pour la variable titre et la variable nbPages.
 Ajoutez un setter pour les variables auteur et titre.
 Changez le setter de nbPages : il ne devra changer le nombre de pages que si on lui passe en paramètre
un nombre positif, et ne rien faire sinon, en affichant un message d'erreur.
2) Dans la méthode main(),
a- indiquez le nombre de pages de chacun des 2 livres,
b- faites afficher ces nombres de pages,
c- calculez le nombre de pages total de ces 2 livres et affichez-le.
Exercice 3:
1) Dans La classe Livre, ajoutez une méthode afficheToi() qui affiche une description du livre (auteur, titre et
nombre de pages).
2) Ajoutez une méthode toString() qui renvoie une chaîne de caractères qui décrit le livre. Modifiez la méthode
afficheToi() pour utiliser toString().
Voyez ce qui est affiché maintenant par l'instruction System.out.println(livre).
3) Ajoutez 2 constructeurs pour avoir 3 constructeurs dans la classe :

- Un constructeur qui n'a pas de paramètre
- Un qui prend en paramètre l'auteur et le titre du livre,
- et l'autre qui prend en plus le nombre de pages.
Utilisez les 3 constructeurs (et éventuellement d'autres méthodes) pour créer 3 livres de 300 pages dans la
méthode main() de la classe TestLivre.
Exercice 4
1) Contrôle des variables private par les setters
a- Ajoutez un prix aux livres (nombre qui peut avoir 2 décimales ; type Java float ou double) avec 2
méthodes getPrix et setPrix pour obtenir le prix et le modifier.
b- Ajoutez au moins un constructeur qui prend le prix en paramètre.
c- Testez. Si le prix d'un livre n'a pas été fixé, la description du livre (toString()) devra indiquer "Prixpas
encore fixé".
d- On bloque complètement les prix : un prix ne peut être saisi qu'une seule fois et ne peut être modifié
ensuite (une tentative pour changer le prix ne fait qu'afficher un message d'erreur).
Réécrivez la méthode setPrix (et autre chose si besoin est). Vous ajouterez une variable booléenne
prixFixe (pour "prix fixé") pour savoir si le prix a déjà été fixé.
e- Réécrire la méthode main () et prévoir le deux cas ( prix non fixé ou bien prix fixé plusieurs fois )
afficher le résultat de l’exécution.

Chapitre 3 – L’HERITAGE
 Technique d’héritage : intérêt et notation
 Maitriser les droits d’accès d’une classe dérivée aux membres de la classe de base
 Comprendre la construction d’un objet dérivé
 Maîtriser la notion de redéfinition
 Découvrir le concept de dérivations multiples
Eléments de contenu :
1. Le principe de l’héritage
2. La syntaxe
3. L’accès aux variables et méthodes dérivées
4. Construction et initialisation des objets dérivés
5. Dérivation successives
6. Redéfinition et surcharge de méthodes
7. Mots clés final et super
8. Des conseils sur l’héritage

4.1 Le principe de l'héritage
L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution. Grâce à
l'héritage, les objets d'une classe ont accès aux données et aux méthodes de la classe parent et peuvent les
étendre. Les sous classes peuvent redéfinir les variables et les méthodes héritées. Pour les variables, il suffit
de les redéclarer sous le même nom avec un type différent. Les méthodes sont redéfinies avec le même nom,
les mêmes types et le même nombre d'arguments, sinon il s'agit d'une surcharge. L'héritage successif de classes
permet de définir une hiérarchie de classe qui se compose de super classes et de sous classes.
Une classe qui hérite d'une autre est une sous classe et celle dont elle hérite est une super classe. Une classe
peut avoir plusieurs sous classes.
Attention : Une classe ne peut avoir qu'une seule classe mère : il n'y a pas d'héritage multiple en java.
Object est la classe parente de toutes les classes en java. Toutes les variables et méthodes contenues
dans Object sont accessibles à partir de n'importe quelle classe car par héritage successif toutes les classes
héritent d'Object.
4.2 Syntaxe
class Fille extends Mere { ... }
On utilise le mot clé extends pour indiquer qu'une classe hérite d'une autre. En l'absence de ce mot réservé
associé à une classe, le compilateur considère la classe Object comme classe parent.
Exemple
//Classe de base
class graphique {
private int x, y;
graphique (int x, int y) {this.x = x ; this.y = y ;}
void affiche () {
System.out.println (`" Le centre de l’objet se trouve dans : " + x + " et " + y) ;}
double surface () {return (0) ;}
} // fin de la classe graphique
//Classe dérivée1
class Cercle extends graphique {
private double rayon =1 ;
void affiche () {
Sustem.out.println (« C’est un cercle de rayon » + rayon) ;
Super.affiche () ;}
double surface ()
{return (rayon * rayon* 3.14) ;}
}
//Classe dérivée2
class Rectangle extends graphique {
private int larg, longueur ;
Rectangle ( int x, int y, int l1, int l2){
super (x,y) ;
longueur = l1 ; larg = l2 ;}
double surface () {return (longueur*largeur) ;}
}// fin de la classe Rectangle
//Classe dérivée3
class carré extends graphique {

private double côté ;
Carré (double c, int x, int y) {
Super ( x,y) ;
Côté = c ;}
Double surface () {return (côté * côté) ;}
}// fin de la classe carré
Interprétation
 Dans cet exemple, la classe Cercle hérite de la classe graphique les attributs et les méthodes, redéfinit
les deux méthodes surface et affiche et ajoute l’attribut rayon.
 La classe Rectangle redéfinit la méthode surface et ajoute les attributs longueur et larg
 La classe carré ajoute l’attribut côté et redéfinit la méthode surface.
Remarques
Le concept d’héritage permet à la classe dérivée de :
 Hériter les attributs et les méthodes de la classe de base.
 Ajouter ses propres définitions des attributs et des méthodes.
 Redéfinir et surcharger une ou plusieurs méthodes héritées.
 Tout objet peut être vu comme instance de sa classe et de toutes les classes dérivées.
 Toute classe en Java dérive de la classe Object.
 Toute classe en Java peut hériter directement d’une seule classe de base. Il n’y a pas la notion d’héritage
multiple en Java, mais il peut être implémenté via d’autres moyens tels que les interfaces(Chapitre
suivant).
Pour invoquer une méthode d'une classe parent, il suffit d'indiquer la méthode préfixée par super. Pour
appeler le constructeur de la classe parent il suffit d'écrire super(paramètres) avec les paramètres adéquats.
Le lien entre une classe fille et une classe parent est géré par le langage : une évolution des règles de gestion
de la classe parent conduit à modifier automatiquement la classe fille dès que cette dernière est recompilée.
En java, il est obligatoire dans un constructeur d'une classe fille de faire appel explicitement ou implicitement
au constructeur de la classe mère.
4.3 L'accès aux variables et méthodes héritées
Les variables et méthodes définies avec le modificateur d'accès public restent publiques à travers l'héritage et
toutes les autres classes.
Une variable d'instance définie avec le modificateur private est bien héritée mais elle n'est pas accessible
directement, elle peut l’être via les méthodes héritées.
Si l'on veut conserver pour une variable d'instance une protection semblable à celle assurée par le modificateur
private, il faut utiliser le modificateur protected. La variable ainsi définie sera héritée dans toutes les classes
descendantes qui pourront y accéder librement mais ne sera pas accessible hors de ces classes directement.
Exemple1 : La classe dérivée et la classe de base sont dans le même package

package Formes_geo ;
class graphiques {
private x, y ;
public String couleur ;
void affiche () {
System.out.println (« Le centre de l’objet = ( » + x + « , » + y + « ) » ) ; }
double surface ( ) {return (0) ;}
} //fin de la classe graphiques

class cercle extends graphiques{
double rayon ;
void changer_centre ( int x1, int y1, double r){
x = x1 ; y = y1 ;// faux car x et y sont déclarés private dans la classe de base
rayon =r ;
public double surface ( ) {return (rayon * rayon* 3.14) ;}
public void affichec (){
affiche () ;// juste car le modificateur de visibilité de ce membre est freindly
System.out.println (« Le rayon = » + rayon + « La couleur = « + couleur ) ;}
}
Interprétation :
Dans le premier cas, la classe dérivée est la classe de base sont dans le même package, donc la classe cercle a
pu accéder aux membres (attributs et méthodes) publiques (l’attribut couleur), de même elle a pu accéder aux
membres « freindly » c'est-à-dire qui n’ont pas un modificateur de visibilité (la méthode affiche), mais elle n’a
pas pu accéder aux membres privés (x et y).
Exemple 2 : La classe dérivée et la classe de base ne sont pas dans le même package
class graphiques {
private x, y ;
void affiche () {
double surface ( ) {return (0) ;} } //fin de la classe graphiques
package FormesCirc ;
double rayon ;
void changer_centre ( int x1, int y1, double r){
x = x1 ; y = y1 ; // faux car x et y sont déclarés private dans la classe de base
rayon =r ;}
public double surface ( ) {return (rayon * rayon* 3.14) ;}
public void affichec (){
affiche () ; // FAUX car le modificateur de visibilité de ce membre est freindly
}
Interprétation :
Dans le deuxième cas, la classe dérivée et la classe de base ne sont pas dans le même package, donc la classe
cercle a pu accéder aux membres (attributs et méthodes) publiques (l’attribut couleur), mais, elle n’a pas pu
accéder aux membres « freindly » c'est-à-dire qui n’ont pas un modificateur de visibilité (la méthode affiche) et
aux membres privés (x et y).
 Nous avons déjà vu qu’il existe 3 types de modificateurs de visibilité publiques (« public »), privés
(private) et de paquetage ou freindly (sans mention).
 Il existe encore un quatrième droit d’accès dit protégé (mot clé « protected »).
4.4 Construction et initialisation des objets dérivés

En java, le constructeur de la classe dérivée doit prendre en charge l’intégralité de la construction de l’objet.
Si un constructeur d’une classe dérivée appelle un constructeur d’une classe de base, il doit obligatoirement
s’agir de la première instruction du constructeur. Le constructeur de la classe de base est désigné par le mot
clé « super ».

Exemple
class graphiques {
private x, y ;
public graphiques (int x1, int y1) {x = x1 ; y=y1 ;}
//autres méthodes
}
private double rayon ;
cercle ( int a, int b, double r) {
super (a, b) ;//appelle le constructeur de la classe de base
rayon = r ; }
//autres méthodes
}
Remarque
Dans le cas général, une classe de base et une classe dérivée possèdent chacune au moins un constructeur. Le
constructeur de la classe dérivée complète la construction de l’objet dérivé, et ce, en appelant en premier lieu le
constructeur de la classe de base.
Toutefois, il existe des cas particuliers qui sont :
Cas1 : La classe de base ne possède aucun constructeur

Dans ce cas, si la classe dérivée veut définir son propre constructeur, elle peut optionnellement appeler
dans la 1ère instruction de constructeur la clause « super () » pour désigner le constructeur par défaut
de la classe de base.
Cas2 : La classe dérivée ne possède pas un constructeur
Dans ce cas, le constructeur par défaut de la classe dérivée doit initialiser les attributs de la classe
dérivée et appeler :
 Le constructeur par défaut de la classe de base si elle ne possède aucun constructeur.
 Le constructeur sans argument si elle possède au moins un constructeur.
 Dans le cas où il n’y a pas un constructeur sans argument et il y a d’autres constructeurs avec
arguments, le compilateur génère des erreurs.
Exemple1 (cas1)
Class A {
// pas de constructeur
}
class B extends A {
public B(….){
super() ; //appel de constructeur par défaut de A
………
}
B b = new B(…); // Appel de constructeur1 de A
Exemple2 (cas2)
Class A {
public A() {….} //constructeur1
public A ( int n) {…..} //constructeur2
}
class B extends A {
// …..pas de constructeur
}
B b = new B(); // Appel de constructeur1 de A
Exemple3 (cas 2)
Class A {
public A ( int n) {…..} //constructeur1
}
class B extends A {
// …..pas de constructeur
}
B b = new B(); /* On obtient une erreur de compilation car A ne dispose pas un constructeurs sans argument et possède
un autre constructeur*/
Exemple4 (cas1 et 2)
Class A {
//pas de constructeurs
}
class B extends A {
//pas de constructeurs
}
B b = new B (); // Appel de constructeur par défaut de B qui Appelle le constructeur par défaut de A.
4.5 Dérivations successives

D’une même classe peuvent être dérivées plusieurs classes différentes. Les notions de classe de base et de
classe dérivée sont relatives puisqu’une classe dérivée peut, à son tour servir de base pour une autre classe.
Autrement dit, on peut rencontrer des situations telles que :
Vehicule
Voiture Moto Camion
Tourisme Utilitaire Benne Carrosserie
 Un véhicule de tourisme est un descendant de voiture qui est lui-même descendant de vehicule.
 Un camion benne est un descendant de camion qui est lui-même descendant de vehicule.
Rappel : La notion de l’héritage multiple n’existe pas directement en Java, mais elle peut être implémentée
via la notion des interfaces
4.6 Redéfinition et surcharge de membres

Nous avons déjà étudié au Chapitre3 la notion de surcharge (surdéfinition) de méthode à l’intérieur d’une
même classe. Nous avons vu qu’elle correspondait à des méthodes de même nom, mais de signatures
différentes. Nous montrerons ici comment cette notion se généralise dans le cadre de l’héritage : une classe
dérivée pourra à son tour surcharger une méthode d’une classe ascendante. Bien entendu, la ou les nouvelles
méthodes ne deviendront utilisables que par la classe dérivée ou ses descendantes, mais pas par ses
ascendantes.
De même une classe dérivée peut fournir une nouvelle définition d’une méthode de même nom et aussi de
même signature et de même type de retour.

Remarque : Alors que la surcharge cumule plusieurs méthodes de même nom, la redéfinition substitue une
méthode à une autre.
4.6.1 Redéfinition d’une méthode
La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parent
(type et nombre de paramètres, la valeur de retour et les exceptions propagées doivent être identiques) et
fournir dans une sous-classe une nouvelle implémentation de la méthode. Cette nouvelle implémentation
masque alors complètement celle de la super classe. Si la signature de la méthode change, ce n'est plus une
redéfinition mais une surcharge.
Remarques
 La re-déclaration doit être strictement identique à celle de la super classe : même nom, même
paramètres et même type de retour.
 Grâce au mot-clé super, la méthode redéfinie dans la sous-classe peut réutiliser du code écrit dans
la méthode de la super classe, qui n’est plus visible autrement.
Exemple
//Super-classe
class graphiques {
private x, y ;
public void affiche () {
double surface ( ) {return (0) ;} } //fin de la classe graphiques
//classe dérivée
double rayon ;
public double surface ( ) {
return (rayon * rayon* 3.14) ;} //redéfinition de « surface »
public void affiche () {//redéfinition de la méthode « affiche »
super.affiche () ; // appel de affiche de la super-classe
}
4.6.2 Redéfinition de méthode et dérivations successives

Soit l’arborescence suivante : La présence d’un astérisque (*) signale la définition ou la redéfinition d’une
méthode f
A*
B C*
D* E F
L’appel de la fonction f conduira pour chaque classe à l’appel de la méthode indiquée :

 Classe A : Méthode f de A

 Classe B : Méthode f de A
 Classe C : Méthode f de C
 Classe D : Méthode f de D
 Classe E : Méthode f de A
 Classe F : Méthode f de C
4.6.3 Surcharge des méthodes
Remarque : En Java, une méthode dérivée peut surcharger une méthode d’une classe ascendante
Exemple
Class A{
public void f (int n) {…..}
…
}
Class B extends A{
public void f (float n) {…..}
…
}
Dans le main()
Aa,Bb;
int n; float x;
a.f(n) // appelle f(int) de A
a.f(x) // Erreur, on a pas dans A f(float)
b.f(n) // appelle f(int) de A
b.f(x) // appelle f(float) de B
4.6.4 Utilisation simultanée de surcharge et de redéfinition

Class A{
public void f (int n) {…..}
public void f (float n) {…..}
…
}
Class B extends A{
public void f (int n) {…..} // redefinition de la méthode f( int ) de A
public void f (double n) {…..} // Surcharge de la méthode f de A et de B
…
}
Dans le main()
Aa,Bb;
int n , float x, double y ;
a.f(n) ;//Appel de f(int) de A
a.f(x) ;//Appel de f(float) de A
a.f(y) ; //Erreur, il n’ y a pas f(double) dans A
b.f(n) ;//Appel de f(int) de B car f(int) est redéfinie dans B
a.f(x) ;//Appel de f(float) de A
a.f(y) ;//Appel de f(double) de B
4.6.3 Règles générales de redéfinition

 Si une méthode d’une classe dérivée a la même signature qu’une méthode d’une classe ascendante :
 Les 2 méthodes doivent avoir le même type de retour.
 Le droit d’accès de la méthode de la classe dérivée ne doit pas être moins élevé que celui de la
classe ascendante.
 Une méthode statique ne peut pas être redéfinie.
4.7 Mots clés «final » et « super »
 Le mot clé « super »

Le mot clé « super » peut être utilisé pour :
appeler un constructeur de la classe de base dans le constructeur de la classe dérivée. Cet appel doit
être la 1ère instruction dans le constructeur de la classe dérivée.
Syntaxe : super (<liste des arguments>).
Accéder dans une méthode d’une classe dérivée à une méthode de la super classe (optionnel sauf
dans le cas de redéfinition)
Syntaxe : super.nom_méthode (<liste des arguments>) ;
Accéder dans une méthode dérivée à un attribut de la classe de base (optionnel)
Syntaxe : super.nom_attribut
 Le modificateur « final »
Cas1 : Le modificateur « final » placé devant une classe interdit sa dérivation
Exemple
final class A {
//Méthodes et attributs
}
class B extends A //Erreur car la classe A est déclarée finale
{//....}
Cas 2 : Le modificateur « final » placé devant une méthode permet d’interdire sa redéfinition
Class A {
final Public void f(int x) {…..}
//…Autres méthodes et attributs
}
Class B {
//Autres méthodes et attributs
public void f (int x) {…} // Erreur car la méthode f est déclarée finale. Pas de redéfinition
}
Les classes et les méthodes peuvent être déclarées finales pour des raisons de sécurité pour garantir que
leur comportement ne soit modifié par une sous-classe.
4.8 Des conseils sur l'héritage

Lors de la création d'une classe « mère » il faut tenir compte des points suivants :
la définition des accès aux variables d'instances, très souvent privées, doit être réfléchie entre
protected et privaté;

pour empêcher la redéfinition d'une méthode (surcharge) il faut la déclarer avec le modificateur final.
Lors de la création d'une classe fille, pour chaque méthode héritée qui n'est pas final, il faut envisager
les cas suivant :
la méthode héritée convient à la classe fille : on ne doit pas la redéfinir ;
la méthode héritée convient mais partiellement du fait de la spécialisation apportée par la classe fille
: il faut la redéfinir voir la surcharger. La plupart du temps une redéfinition commencera par
appeler la méthode héritée (via super) pour garantir l'évolution du code ;
la méthode héritée ne convient pas : il faut redéfinir ou surcharger la méthode sans appeler la
méthode héritée lors de la redéfinition.

Chapitre 4 – Le Polymorphisme
 Comprendre Le concept de polymorphisme à travers des exemples
 Comprendre la conversion des arguments en liaison avec le polymorphisme
 Comprendre la conversion explicite des références en rapport avec le polymorphisme
1. Concept de polymorphisme
2. Exemple et interprétation
3. Conversion des arguments effectifs
4. Les conversions explicites des références

5.0 Introduction
Si vous avez bien compris le chapitre précédent sur l’héritage, vous êtes dans de bonnes dispositions pour
comprendre celui-ci, qui est relativement plus difficile. Je ne veux pas vous faire peur mais celui que vous êtes
en train de lire est au moins du même acabit. C'est sans doute le chapitre le plus complexe de tout le cours
sur la POO, mais vous allez voir qu'il va nous ouvrir de nouveaux horizons très intéressants en
programmation.
Le mot. « Poly » signifie « plusieurs », comme dans polygone ou polytechnique, et « morphe » signifie « forme »
comme dans…amorphe ou zoomorphe.
Nous allons donc parler de choses ayant plusieurs formes. Ou, pour utiliser des termes informatiques, nous
allons créer du code fonctionnant de différentes manières selon le type qui l'utilise.
5.1 Concept de polymorphisme

 Le polymorphisme est un concept extrêmement puissant en POO, il permet de manipuler des objets sans
en connaître tout à fait le type tout en se basant sur la relation d’héritage.
 Le polymorphisme en Java, se traduit par :
 La compatibilité entre un type dérivée et un type ascendant.
 La ligature dynamique des méthodes, dans le sens où il permet d’obtenir le comportement adapté
à chaque type d’objet, sans avoir besoin de tester sa nature de quelque façon que ce soit.
 Le polymorphisme se base sur cette affirmation : un objet a comme type non seulement sa classe mais
aussi n’importe quelle classe dérivée.
5.2 Exemples et interprétations
Exemple 1
//Classe de base
class graphique {
private int x, y;
public graphique ( int x, int y) { this.x = x ; this.y = y ;}
public void identifie () {
System.out.println (« Je suis une forme géometrique ») ;}
public void affiche () {
this.identifie() ;
System.out.println (« Le centre de l’objet se trouve dans : » + x
+ « et » + y) ;}
double surface () {return (0) ;}
//Classe dérivée1
public Cercle ( int x, int y, double r) {
super(x,y) ;
rayon = r ;}
System.out.println (« Je suis un cercle ») ;}
double surface (){
return ( rayon * rayon* 3.14) ;}
}
//Classe dérivée2
super (x,y) ;
public void identifie() {
System.out.println(« Je suis un rectangle ») ;}
//Classe de test
class test_poly {
public static void main (String [] args) {
graphique g = new graphique (3,7);
g.identifie ();
g= new Cercle (4,8,10) ;// compatibilité entre le type de la classe et de la classe dérivéé
g.identifie() ;
g= new Rectangle (7,9,10,3) ;// compatibilité entre le type de la classe et de la classe dérivéé
g.identifie () ;}
}
Résultat à l’exécution
Je suis une forme géométrique
Je suis un cercle
Je suis un rectangle
Interprétation
Le même identificateur « g » est initialisé dans la 1ère instruction avec une référence de type « graphique », puis
on a changé la référence de cette variable dans l’instruction3 en lui affectant une référence de type « Cercle »,
puis dans l’instruction 5, on a changé sa référence avec une référence de classe dérivée
« Rectangle ».
Ces affectations confirment la compatibilité entre un type d’une classe de base et la référence d’une classe
dérivée.
L’autre point qui semble plus important c’est la ligature dynamique des méthodes, dans le sens où le résultat
de la méthode « identifie » a changé dans chaque appel selon le type effectif de la variable « g ».
Question : Que produit le bout de programme test_poly1 suivant ?
class test_poly1 {
void presenter(graphque g){
g.identifier() ;}
c= new Cercle (4,8,10) ;
presenter(c);}
}
Pourquoi ?
Exemple 2 : Tableau des objets

Dans cet exemple, on va exploiter les possibilités de polymorphisme pour créer un tableau hétérogène
d’objets, c’est à dires dans lequel les éléments peuvent être de types différents.
class test_poly2 {
graphique [] tab = new graphique [6];
tab[0] = new graphique (3,2);
tab[1] = new Cercle (10,7,3) ;
tab [2] = new Rectangle (4,7,8,6) ;
tab [3] = new graphique (8,10);
tab[5 = new Rectangle (10,17,3,8) ;
for (i=0 ; i <=5 ; i++) {tab[i].affiche();}
}
}
Résultat de l’exécution
Je suis une forme géométrique Le centre de l'objet se trouve dans : 3 et 2
Je suis un cercle Le centre de l'objet se trouve dans : 10 et 7
Je suis un rectangle Le centre de l'objet se trouve dans : 4 et 7
Je suis une forme géométrique Le centre de l'objet se trouve dans : 8 et 10
Je suis un cercle Le centre de l'objet se trouve dans : 8 et 5
Je suis un rectangle Le centre de l'objet se trouve dans : 10 et 17
Exemple 3
class test_poly3 {
String c ;
graphique d;
int c= Integer.parseInt(args [0]) ;
switch (c) {
case 0 : d=new Cercle (10,10,10) ; break;
case 1 : d=new Rectangle (10,10,10,10) ; break;
case 2 : d= new graphique (10,10); break;
default: d= new graphique (0,0);
}
d.identifie () ;
System.out.println (« Surface = » + d.surface()) ;}
}
Résultat de l’exécution :
Le message affiché est en fonction de l’argument introduit dans la commande d’exécution. Le gros avantage
du polymorphisme est de pouvoir référencer des objets sans connaître à la compilation véritablement leur
classe et de pouvoir par la suite à l’exécution lancer le code approprié à cet objet. La liaison entre l’identificateur
de la méthode polymorphe et son code est déterminée à l’exécution et non à la compilation, on parle alors de
liaison dynamique.
Remarque :
Le polymorphisme se base essentiellement sur le concept d’héritage et la redéfinition des méthodes. Toutefois,
si dans le même contexte d’héritage, on a à la fois une redéfinition et une surcharge de la même méthode, les
règles de polymorphisme deviennent de plus en plus compliquées.
La notion de polymorphisme peut être généralisée dans le cas de dérivations successives.
5.3 Conversion des arguments effectifs

La conversion d’un type dérivé en un type de base est aussi une conversion implicite légale, elle va donc être
utilisée pour les arguments effectifs d’une méthode.
Exemple1
class A{
public void identifie(){

System.out.println (« Objet de type A ») ; }
}
class B extends A{// pas de redéfinition de identitie ici
}
class Test{
static void f(A a ) {
a.identitie(); }
}
…..
A a = new A();
B b = new B ();
Test.f(a);// OK Appel usuel; il affiche “objet de type A”
Test.f(b) ;/*OK une référence à un objet de type B est compatible avec une référence à un objet de type A.
L’appel a.identifie affiche : « Objetde type A » */
Exemple2
On va juste modifier le corps de la classe B par une redéfinition de la méthode « identifie »

class B {
System.out.println (« Objet de type B ») ;}
}
….
A a = new A(); B b = new B ();
Test.f (b) ;/*OK une référence à un objet de type B est compatible avec une référence à un objet de type A.
L’appel a.identifie affiche : « Objet de type B »*/
Cet exemple, montre que comme dans les situations d’affectation, la conversion implicite d’un type dérivé
dans un type de base n’est pas dégradante puisque grâce au polymorphisme, c’est bien le type de l’objet
référencé qui intervient.
Remarque :
Dans le cas où la méthode f est surdefinie, il y a encore des règles plus compliquées lors de la conversion
implicite des types de paramètres.
5.4 Les conversions explicites de références

Compatibilité entre référence à un objet d’un type donné et une référence à un objet d’un type ascendant.
Dans le sens inverse, la compatibilité n’est pas implicite.
Exemple :
Class graphique {…….}
Class Cercle extends graphique{……..}
…..
graphique g, g1 ;
Cercle c, c1 ;
c = new graphique (….) ; //Erreur de compilation
g = new Cercle (…) //Juste
g1 = new graphique (….) ; //évident
c1= new Cercle(…) ; //évident
c1 = g1 //faux (Conversion implicite illégale)
g1= c1 ; //juste ; (conversion implicite légale)
Il faut réaliser une conversion explicite c1 = (Cercle) g1 ;

Toutefois cette syntaxe qui est acceptée à la compilation peut être refusée à l’exécution et le traitement
peut être arrêtée si il n ‘y a pas compatibilité effective entre les types.
5.5 Evaluation formative : voir énoncé TPs

Chapitre 5 –Classes Abstraites et Interfaces
 1. Introduire la notion de classe abstraite, les règles de définition et l’intérêt pratique
 2. Introduire le concept d’interfaces, leurs intérêts pratiques et leurs relations avec l’héritage
1. Les classes abstraites
2. Les interfaces

6.1 Les classes abstraites
6.1.1 Concept des classes abstraites
 Une classe abstraite est une classe qui ne permet pas d’instancier des objets, elle ne peut servir que de
classe de base pour une dérivation par héritage.
 Dans une classe abstraite, on peut trouver classiquement des méthodes et des champs, dont héritera
toute classe dérivée et on peut trouver des méthodes dites « abstraites » qui fournissent uniquement
la signature et le type de retour.
Syntaxe
abstract class A{
public void f() {……} //f est définie dans A
public abstract void g (int n) ; //g est une méthode abstraite elle n’est pas définie dans A
}
}
Utilisation
A a ; //on peut déclarer une référence sur un objet de type A ou dérivé
a = new A (….) ;//Erreur pas d’instanciation d’objets d’une classe abstraite
Si on dérive une classe B de A qui définit les méthodes abstraites de A, alors on peut :
a = new B(…) ; //Juste car B n’est pas une classe abstraite
6.1.2 Règles des classes abstraites
 Dès qu’une classe abstraite comporte une ou plusieurs méthodes abstraites, elle est abstraite, et ce
même si l’on n’indique pas le mot clé « abstract » devant sa déclaration.
 Une méthode abstraite doit être obligatoirement déclarée « public », ce qui est logique puisque sa
vacation est d’être redéfinie dans une classe dérivée.
 Les noms d’arguments muets doivent figurer dans la définition d’une méthode abstraite
public abstract void g(int) ; //Erreur : nom argument fictif est obligatoire
 Une classe dérivée d’une classe abstraite n’est pas obligée de redéfinir toutes les méthodes abstraites,
elle peut ne redéfinir aucune, mais elle reste abstraite tant qu’il y a encore des méthodes abstraites non
implémentées.
 Une classe dérivée d’une classe non abstraite peut être déclarée abstraite.
6.1.3 Intérêt des classes abstraites
Le recours aux classes abstraites facilite largement la conception orientée objet. On peut placer dans une classe
abstraite toutes les fonctionnalités dont on souhaite disposer pour les classes descendantes :
 Soit sous la forme d’une implémentation complète de méthodes (non abstraites) et de champs (privés
ou non) lorsqu’ils sont communs à tous les descendants,
 Soit sous forme d’interface de méthodes abstraites dont on est alors sûr qu’elles existeront dans toute
classe dérivée instanciable.
6.1.4 Exemple
abstract class graphique {

private int x, y;
graphique ( int x, int y) { this.x = x ; this.y = y ;}
void affiche () {

System.out.println (« Le centre de l’objet se trouve dans : " + x + " et " + y) ;}
Abstract public double surface () ; // méthode abstraite
//Classe dérivée1
void affiche () {
System.out.println (« C’est un cercle de rayon » + rayon) ;
Super.affiche() ; }
double surface (){
return ( rayon * rayon* 3.14) ;}
}
//Classe dérivée2
super (x,y) ;
// Classe de test
class test_poly2 {
graphique [] tab = new graphique [6];
//tab[0] = new graphique (3,2); Erreur car une classe abstraite ne peutpas être instanciée
tab[0] = new Cercle (3,2,7);
tab[2] = new Rectangle (4,7,8,6) ;
tab[3] = new Rectangle (8,10,12,10);
tab[5] = new Rectangle (10,17,3,8) ;
for (int i=0 ; i <=5 ; i++) {tab[i].affiche();}
}
}
Remarque : Une classe abstraite peut ne comporter que des méthodes abstraites et aucun champ. Dans ce cas, on
peut utiliser le concept de l’interface.
6.2 Les interfaces

6.2.1 Concept d’interface
 Si on considère une classe abstraite n’implantant aucune méthode et aucun champ (sauf les
constantes), on aboutit à la notion d’interface.
 Une interface définit les entêtes d’un certain nombre de méthodes, ainsi que des constantes.
 L’interface est plus riche qu’un simple cas particulier des classes abstraites :
Une classe peut implémenter plusieurs interfaces (alors qu’une classe ne pouvait dériver que d’une
seule classe abstraite).
La notion d’interface va se superposer à celle de dérivation, et non s’y substitue.
Les interfaces peuvent se dériver.
Une classe dérivée peut implémenter 1 ou plusieurs interfaces, elle peut même réimplémenter une
interface déjà implémentée par la superclasse.
On pourra utiliser des variables de type interface.

6.2.2 Syntaxe
6.2.1.1 Définition d’une interface

public interface I{
void f (int n) ; //public abstract facultatifs
void g () ; //public abstract facultatifs
}
Toutes les méthodes d’une interface sont abstraites. On peut ne pas mentionner le modificateur de visibilité
(par défaut public) et le mot clé « abstract »
6.2.1.2 Implémentation d’une interface

Lorsqu’on définit une classe, on peut préciser qu’elle implémente une interface donnée en utilisant le mot clé
"implements "
Syntaxe
public interface I1{

….
}
public interface I2{
…
}
class A implements I1, I2{
…..A doit définir les méthodes de I1 et I2
}
6.2.1.3 Exemple
interface Affichable{
void affiche() ;
}
class Entier implements Affichable{
private int val ;
public Entier (int n){
val = n ;}
public void affiche() {
System.out.println (« Je suis un entier de valeur » + val) ;}
}
class Flottant implements Affichable{
private float val ;
public Flottant (float n){
val = n ;}
public void affiche() {
System.out.println (« Je suis un flottant de valeur » + val) ; }
}
public class TestInterface {
Afficheable [] tab = new Afficheable [2];
tab[0] = new Entier (25);
tab [1] = new Flottant (1.25);
tab [0].affiche(); tab [1].affiche; }
}
Résultat de l’exécution

- Je suis un entier de valeur 25
- Je suis un flottant de valeur 1.25
6.2.1.4 Interface et constantes

Une interface peut renfermer aussi des constantes symboliques qui seront accessibles à toutes les classes
implémentant l’interface :
public interface I{
void f (int n) ; //public abstract facultatifs
void g () ; //public abstract facultatifs
static final int max = 100 ;
}
Les constantes déclarées sont toujours considérées comme « static » et « final »
Remarque : L’interface est totalement indépendante de l’héritage : Une classe dérivée peut implémenter une ou
plusieurs interfaces.
6.3 Interface et dérivations

Exemple
interface I1 {…..}
interface I2 {…..}
class A implements I1 {……}
class B extends A implements I1, I2 {…..}
Remarque2 : On peut définir une interface comme une généralisation d’une autre. On utilise alors le mot clé
«extends »
Exemple
interface I1{
void f(int n) ;
static final int max = 100;
}
interface I2 extends I1{
void g (int n);
static final int min = 10;
}
En fait la définition de I2 est équivalente à
interface I2{
void g (int n);
static final int min = 10;
void f(int n) ;
static final int max = 100;
}
Remarque3 : Conflits des noms

Soit l’exemple suivant
interface I1{
void f(int n) ;
void g();
}
interface I2{
void f (float x);
void g();
}
class A implements I1, I2{ /*A doit implémenter la méthode g qui existe dans les 2
interfaces une seule fois*/}
=> Nous supposons que la méthode « g » est présente de 2 façons différentes dans I1 et I2
Exemple
interface I1{
void g(); } // g est une méthode abstraite de I1
interface I2{
int g(); } // g est aussi une méthode abstraite de I2
class A implements I1, I2 {/* Erreur car void g() et int g() ne peuvent pas coexister au sein de la même
classe*/
6.4 Evaluation formative : voir fiche TPs.

COURS POO Vers 2020

Transféré par

Droits d'auteur :

Formats disponibles

COURS POO Vers 2020

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

COURS POO Vers 2020

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Orientée Objet

IAI – 2018/2019 Donacien GUIFO Page 1

IAI – 2018/2019 Donacien GUIFO Page 2

IAI – 2018/2019 Donacien GUIFO Page 3

Objectifs Généraux Conditions de réalisation de la Critère d’évaluation de la

IAI – 2018/2019 Donacien GUIFO Page 4

Évaluation : 1 test (bonus), 1 TP(60%) et un contrôle final écrits(40%).

IAI – 2018/2019 Donacien GUIFO Page 5

IAI – 2018/2019 Donacien GUIFO Page 6

2.2 Définition : Qu’est-ce qu’un objet ?

Les objectifs de la POO :

Conclusion : Un objet = données + algorithmes

2.3 Programmation orientée-objet

Les objectifs de Java :

2.4 Notion de Classe

IAI – 2018/2019 Donacien GUIFO Page 9

IAI – 2018/2019 Donacien GUIFO Page 10

La POO se base sur les notions clés suivantes :

IAI – 2018/2019 Donacien GUIFO Page 11

IAI – 2018/2019 Donacien GUIFO Page 12

3.2 Modificateurs de visibilité et Accès

3.2.1 Modificateurs de visibilité

Tableaux récapitulatifs des droits d’accès

3.2.2 Accès aux membres privés

Rectangle r = new Rectangle ();

public class Rectangle

int getlarg () //Pour retourner la largeur

void setlong (int l) //pour modifier la longueur

void setlarg (int l) //pour modifier la largeur

int surface() //Pour calculer la surface

void allonger(int l) //Pour allonger la longueur d’un rectangle

Code de la classe Test_Rect

3.3 Surcharge des Méthodes

La méthode surchargée doit conserver la même “intention sémantique”

IAI – 2018/2019 Donacien GUIFO Page 15

3.4 Evaluation formative

a- Corrigez quelques petites erreurs

IAI – 2018/2019 Donacien GUIFO Page 16

IAI – 2018/2019 Donacien GUIFO Page 17

IAI – 2018/2019 Donacien GUIFO Page 18

IAI – 2018/2019 Donacien GUIFO Page 19

4.3 L'accès aux variables et méthodes héritées

Exemple1 : La classe dérivée et la classe de base sont dans le même package

} //fin de la classe graphiques

IAI – 2018/2019 Donacien GUIFO Page 20

4.4 Construction et initialisation des objets dérivés

IAI – 2018/2019 Donacien GUIFO Page 21

Toutefois, il existe des cas particuliers qui sont :

Cas1 : La classe de base ne possède aucun constructeur

4.5 Dérivations successives

Voiture Moto Camion

Tourisme Utilitaire Benne Carrosserie

4.6 Redéfinition et surcharge de membres

IAI – 2018/2019 Donacien GUIFO Page 23

4.6.2 Redéfinition de méthode et dérivations successives

L’appel de la fonction f conduira pour chaque classe à l’appel de la méthode indiquée :

IAI – 2018/2019 Donacien GUIFO Page 24

4.6.3 Surcharge des méthodes

4.6.4 Utilisation simultanée de surcharge et de redéfinition