Université Cadi Ayyad

Ecole Supérieure de Technologie – Safi

Cours de la programmation orientée

objet (JAVA)

: Cours 4

Pr. EL ABDELLAOUI SAID

Elabdellaoui.said@yahoo.fr

Said El Abdellaoui Programmation Orientée Objet : Java 2017 / 2018

 TD 3 CORRECTION
2

import java.util.ArrayList;
import java.util.Calendar;
public class Direction{
public static ArrayList<EPFLien>epfl= new ArrayList<EPFLien>();

public static void main(String[] args) {

epfl.add(new EtudiantRegulier("Gaston Peutimide", 2013, "SSC", 6.0));

epfl.add(new EtudiantRegulier("Yvan Rattrapeur", 2011, "SSC", 2.5));
epfl.add(new EtudiantEchange("Bjorn Borgue", 2012, "Informatique", "KTH"));
epfl.add(new Enseignant("Mathieu Matheu", 1998,"LMEP", 10000, "Physique"));
epfl.add(new Secretaire("Sophie Scribona", 2005, "LMT", 5000));

afficherStatistiques();
afficherEPFLiens();
}

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 TD 3 CORRECTION
3

public static void afficherEPFLiens() {

System.out.println("Liste des EPFLiens: ");
for (EPFLien epflien : epfl)
epflien.afficher();
}

public static void afficherStatistiques() {

int anneeCourante = Calendar.getInstance().get(Calendar.YEAR);
int nbAnneesTotal = 0;
int nbEtudiants = 0;
for (EPFLien epflien : epfl) {
nbAnneesTotal += anneeCourante - epflien.getAnnee();
if (epflien.estEtudiant()){
++nbEtudiants; }
}

System.out.println("Parmi les " + epfl.size() + " EPFLiens, " +

nbEtudiants + " sont des etudiants.");
double moyen = nbAnneesTotal;
moyen /= epfl.size();
System.out.println("Ils sont ici depuis en moyenne " + moyen + " ans");
}
} //Class

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

POLYMORPHISME
 SOUCI !!!!
5

class Rencontre
class Personnage{ {
// ... public static void main(...) {
public void rencontrer(Personnage p) { Guerrier g=new Guerrier(...);
System.out.print("Bonjour !"); Voleur v= new Voleur(...);
} uneRencontre(g,v);
} }

static void uneRencontre (Personnage a,

class Guerrier extends Personnage{ Personnage b) {
// ... System.out.print(a.getNom()+" rencontre ");
public void rencontrer(Personnage p) { System.out.print(b.getNom() +" ");
System.out.print("Boum !"); a.rencontrer(b);
} }
} }

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 POLYMORPHISME (UNIVERSEL D’INCLUSION)
6

 En POO, le polymorphisme (universel d’inclusion) est le fait que les instances d’une sous-
classe gardent leurs propres propriétés.

☞ Le choix des méthodes à invoquer se fait lors de l’exécution du programme en fonction de la

nature réelle des instances concernées. La mise en œuvre se fait au travers de :
Personnage p1,p2;
 l’héritage (hiérarchies de classes) ; // ...
 la résolution dynamique des liens. p1.rencontrer(p2);

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

MÉTHODES ABSTRAITES
 BESOIN DE MÉTHODES ABSTRAITES : EXEMPLE
8

 Exemple :
class FigureFermee {
//...
// difficile à définir à ce niveau !..
public double surface(...) {???}
// ...pourtant la méthode suivante en aurait besoin !
public double volume(double hauteur) {
return hauteur×surface();
}
}

 Définir surface de façon arbitraire sachant qu’on va la redéfinir plus tard n’est pas une bonne
solution (source d’erreurs) !

 Solution : déclarer la méthode surface comme abstraite.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 BESOIN DE MÉTHODES ABSTRAITES : EXEMPLE
9

 Première solution :
 Ajouter une méthode quelconque définie arbitrairement :

class Personnage{
// ...
// On n'affiche rien : corps de la méthode vide
public void afficher(){ }
// ...
}

☞ Mauvais modèle de la réalité

 Bonne solution : Signaler que la méthode doit exister dans chaque sous-classe sans qu’il
soit nécessaire de la définir dans la super-classe
☞ Déclarer la méthode comme abstraite

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 MÉTHODES ABSTRAITES : DÉFINITION ET SYNTAXE
10

 Syntaxe :

abstract Type nom_methode (liste d’arguments);

 Exemples :

abstract class FigureFermee{

public abstract double surface();
public abstract double perimetre();
// On peut utiliser une méthode abstraite :
public double volume (double hauteur) {
return hauteur×surface(); }
}

abstract class Personnage{

// ...
public abstract void afficher();
// … }

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 CLASSES ABSTRAITES
11

 Une classe abstraite ne peut être instanciée.

 Ses sous-classes restent abstraites tant qu’elles ne fournissent pas les définitions de toutes
les méthodes abstraites dont elles héritent.

 Une autre équipe crée la sous-classe Guerrier de Personnage et veut l’utiliser :

Jeu jeu= new Jeu();

jeu.ajouterPersonnage (new Guerrier(...));

 S’ils ont oublié de définir la méthode afficher, le code ci-dessus génère une
erreur de compilation car on ne peut pas créer d’instance de Guerrier :

Guerrier is abstract; cannot be instantiated

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 MÉTHODES ABSTRAITES : AUTRES EXEMPLES
12

class Polygone extends FigureFermee {

class Cercle extends FigureFermee {
private ArrayList <double> cotes; }
private double rayon;
}
}
public double perimetre() {
public double surface() {
double p=0.0;
return Math.PI×rayon×rayon;
for (double cote : cotes) {
}
p+ =cote;
public double perimetre() {
}
return 2.0×Math.PI×rayon;
return p;
}
}

Cercle n’est pas une classe abstraite Polygone reste par contre une classe abstraite

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 CONSTRUCTEURS ET POLYMORPHISME
13

 Un constructeur est une méthode spécifiquement dédiée à la construction de

l’instance courante d’une classe, il n’est pas prévu qu’il ait un comportement
polymorphique.
 Il est cependant possible d’invoquer une méthode polymorphique dans le corps d’un
constructeur.
☞ Ceci est cependant déconseillé: la méthode agit sur un objet qui n’est peut-
être alors que partiellement initialisé !!

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 CONSTRUCTEURS ET POLYMORPHISME
14

abstract classA
 Au sommet : {
public abstract void m();
public A() {
m(); // méthode invocable de manière polymorphique
}
}
//========================================
class B extends A{
private int b;
public B() {
b=1; // A() est invoquée implicitement juste avant
}
public void m() {
// définition de m pour la classe B
System.out.println("b vaut : "+b);
}
}
// .... dans le programme principal :
affiche : b vaut 0 B b= new B();

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 LA SUPER-CLASSE OBJECT
15

 Il existe en Java une super-classe commune à toutes les classes : la classe Object qui
constitue le sommet de la hiérarchie.
 Toute classe que vous définissez, si elle n’hérite d’aucune classe explicitement, dérive
de Object .
 Il est donc possible d’affecter une instance de n’importe quelle classe à une variable
de type Object :

Object v=new UneClasse(...); // OK

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 LA SUPER-CLASSE OBJECT
16

 La classe Object définit, entre autres, les méthodes :

 toString : qui affiche juste une représentation de l’adresse de l’objet.

 equals : qui fait une comparaison au moyen de == (comparaison des
références).
 clone : qui permet de copier l’instance courante.

 Dans la plupart des cas, ces définitions par défaut ne sont pas satisfaisantes quand
vous définissez vos propres classes

☞ Vous êtes amenés à les redéfinir pour permettre un affichage, une

comparaison ou une copie corrects de vos objets
☞ C’est ce que nous avons fait dans une séquence précédente avec toString !
☞ La classe String aussi par exemple redéfinit ces méthodes

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 EXEMPLE : REDÉFINITION DE EQUALS HÉRITÉ DE OBJECT
17

 L’entête proposée pour la méthode equals dans une séquence précédente était :

public boolean equals(UneClasse arg)

or l’entête de la méthode equals dans Object est :

public boolean equals(Object arg)

☞ Nos définitions de equals constituaient jusqu’ici des surcharges et non pas des
redéfinitions de la méthode equals de Object !

 Dans la plupart des cas, utiliser une surcharge fonctionne sans problème, mais il est
recommandé de toujours procéder par redéfinition.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 SURCHARGE, REDÉFINITION ( RAPPELS )
18

 On redéfinit (« override ») une méthode d’instance si les paramètres et leurs types

sont identiques et les types de retour compatibles :

public boolean equals(Object arg)

 Si c’est le même nom de méthode seulement, on surcharge (« overload ») :

public boolean equals(UneClasse arg)

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 REDÉFINITION USUELLE DE EQUALS
19

 Attention ! si l’on redéfinit equals pour la classe Rectangle, on doit pouvoir

comparer un Rectangle avec n’importe quel autre objet : unRectangle.equals("toto")
devrait retourner false.
class Rectangle{
//...
public boolean equals(Object autreObjet) {
}
}
if (autreObjet == null)
{ return false; }
else{
if (autreObjet.getClass() != getClass())
}
{ return false; }
else{
Rectangle r= (Rectangle) autreObjet;
return (largeur == r.largeur && hauteur == r.hauteur);
}

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 LE MODIFICATEUR FINAL
20

 Ce modificateur permet d’indiquer les éléments du programme qui ne doivent pas

être modifiés / redéfinis /étendus

 Possible pour les classes, méthodes, attributs, variables.

 Utile surtout pour les variables.
 Moins courant pour les méthodes et les classes.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 MÉTHODES FINALES
21

 Si l’on ajoute final à une méthode :

☞ Impossible de la redéfinir dans une sous-classe
 Exemple : on aimerait toujours appliquer la méthode vieillir de Personnage

class Personnage
{
//...
final void vieillir() {
-- dureeVie;
}
}

☞ Message d’erreur du compilateur si la classe Sorcier essaie de redéfinir la

méthode vieillir

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 CLASSES FINALES
22

 Si l’on ajoute final à une classe :

☞ Impossible d’étendre la classe par une sous-classe
 Exemple : on aimerait que la classe Sorcier n’ait jamais de sous-classe

final class Sorcier extends Magicien{

//...
}
class MageNoir extends Sorcier{ ..}
// illicite!!

☞ Message d’erreur du compilateur si la classe Sorcier essai de redéfinir la

méthode vieillir.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 CLASSES ET MÉTHODE FINALES
23

 Les méthodes et classes finales peuvent être à priori « agaçantes » :

 Exemple: la classe prédéfinie String est finale
 Aucune possibilité de définir

class MyString extends String

afin d’améliorer certaines méthodes par redéfinition!!

☞ Mais, permet de fixer une fois pour toute le comportement d’une classe ou
méthode

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 VARIABLES FINALES ET OBJETS RÉFÉRENCÉS
24

 Si l’on ajoute final à une variable d’instance, une variable locale ou un paramètre :

☞ il devient impossible de lui affecter une valeur plus d’une fois

 Un attribut final peut être initialisé dans le constructeur mais ne doit plus être modifié
par la suite

☞ Attention : final empêche l’affectation d’une nouvelle valeur à une variable,

mais n’empêche pas de modifier l’éventuel objet référencé par cette variable

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

INTERFACES
 ENCORE UN JEU
27

 Supposons que l’on souhaite programmer un jeu mettant en scène les entités
suivantes :

1. Balle 2. Raquette 3. Filet

4. Joueur

 Chaque entité sera principalement dotée d’une méthode evolue, gérant

l’évolution de l’entité dans le jeu.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 PREMIÈRE ÉBAUCHE DE CONCEPTION
28

class Entite

+ void evolue( )

class Balle class Raquette class Filet class joueur

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 PREMIÈRE ÉBAUCHE DE CONCEPTION
29

 Si l’on analyse de plus près les besoins du jeu, on réalise que :

 Certaines entités doivent avoir une représentation graphique (Balle,
Raquette, Filet) …. et d’autres non (Joueur)
 Certaines entités doivent être interactives (Balle, Raquette ) : on veut par
exemple pouvoir les contrôler avec la souris …. et d’autres non : (Joueur, Filet)

Comment organiser tout cela ?

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 JEU VIDÉO IMPOSSIBLE
30

 Idéalement, il nous faudrait mettre en place une hiérarchie de classes telle que celle-ci :

class Entite Class Interactif

+ Void evolue(…) + Void gestionClic (…)

class Balle class Raquette class Filet class joueur

Class Graphique
+ Void dessiner(…)

 Mais ….Java ne permet que l’héritage simple : chaque sous-classe ne peut avoir qu’une seule
classe parente directe !
 Imposer un contenu commun à des sous-classes en dehors d’une relation d’héritage est le rôle
joué par la notion d’interface en Java.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 ALTERNATIVE POSSIBLE DE JEU VIDÉO
31

Class Entite interface Interactif

+void evolue(…) +Void gestionClic (…)

class Balle class Raquette class Filet class joueur

interface Graphique
+Void dessiner(…)

 Interface ≠ Classe
 Une interface permet d’imposer à certaines classes d’avoir un contenu particulier
sans que ce contenu ne fasse partie d’une classe.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 INTERFACES
32

 Syntaxe :

interface UneInterface { constantes ou méthodes abstraites }

 Exemple :

interface Graphique{
void dessiner() {//…};
}
interface Interactif{
void gestionClic() {//…};
}

 Il ne peut y avoir de constructeur dans une interface.  Impossible de faire new.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 INTERFACES
33

 Attribution d’une interface à une classe :

 Syntaxe :

Class Une Classe implements Interface1,…, InterfaceN

{ ... }

 Exemple :

Class Filet extends Entite implements Graphique {

public void dessiner() { ... }
}

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 INTERFACES
34

 Une interface attribue un type supplémentaire à une classe d’objets, on peut donc
:
 Déclarer une variable de type interface
 Y affecter un objet d’une classe qui implémente l’interface
 (éventuellement, faire un transtypage explicite vers l’interface)

Graphique graphique;
Balle balle = new Balle(..);
graphique = balle;
// Autre exemple !
Entite entite = new Balle(..);
graphique = (Graphique) entite; // transtypage indispensable !

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 PLUSIEURS INTERFACES
35

 Une classe peut implémenter plusieurs interfaces (mais étendre une seule classe)
 Séparer les interfaces par des virgules

 Exemple :

,
class Balle extends Entite implements Graphique Interactif {
//code de la classe
}

 On peut déclarer une hiérarchie d’interfaces :

Mot-clé extends
La classe qui implémente une interface reçoit aussi le type des super-
interfaces

interface Interactif{ ..}

interface GerableParSouris extends Interactif{ ... }
interface GerableParClavier extends Interactif{ ... }

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 INTERFACE-RÉSUMÉ
36

 Une interface est un moyen d’attribuer des composants communs à des classes non-liées
par une relation d’héritage :
 Ses composants seront disponibles dans chaque classe qui l’implémente.

 Composants possibles :

1. Variables statiques finales (assez rare)

 Ambiguïté possible, nom unique exigé
2. Méthodes abstraites (courant)
 Chaque classe qui implémente l’interface sera obligée d’implémenter chaque
méthode abstraite déclarée dans l’interface si elle veut pouvoir être instanciée
 Une façon de garantir que certaines classes ont certaines méthodes, sans passer
par des classes abstraites
 Aucune ambiguïté car sans instructions

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018

 INTERFACE-RÉSUMÉ
37

 Nous avons vu que l’héritage permet de mettre en place une relation de type « est-
un » entre deux classes.

 Lorsqu’une classe a pour attribut un objet d’une autre classe, il s’établit entre les
deux classes une relation de type « a-un » moins forte que l’héritage (on parle de
délégation).

 Une interface permet d’assurer qu’une classe se conforme à un certain protocole.

 Elle met en place une relation de type « se-comporte-comme » : une Balle « est-
une » entité du jeu, elle « se-comporte-comme » un objet graphique et comme un
objet interactif.

Saïd EL ABDELLAOUI Orientée Objet : Java 2017 / 2018