Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

Chapitre3 - Part2

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 34

POO 3 (JAVA ET JAVA AVANCÉ)

Prof. Nisrine DAD


4° Ingénierie Informatique et Réseaux - Semestre 1
Ecole Marocaine des Sciences d’Ingénieur
Année Universitaire : 2022/2023
III. CONCEPTS DE LA PROGRAMMATION ORIENTÉE OBJETS
(POO) EN JAVA

2
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Concept


• Une classe abstraite est une classe qui ne permet pas l’instanciation des objets de son
type.
• C’est une classe incomplète puisqu’elle contient certaines méthodes dont leurs corps
sont définies dans la classe dérivée. En effet, elle doit être héritée.
• Une classe abstraite comporte une ou plusieurs méthodes abstraites, et elle peut
comporter d'autres méthodes non abstraites.
• Une méthode abstraite est une méthode qui ne possède pas d’instructions (corps). Elle
comporte seulement une signature de définition suivie du caractère point-virgule.
• Une méthode abstraite doit être précédée par le mot clé abstract.
• Exemple : public abstract double fAbstraite();
3
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Syntaxe


public abstract class Personne {

public void affiche() {


System.out.println("Personne");
} // affiche() est définie dans Personne

public abstract void determineAge (int annee) ;


//determineAge() est une méthode abstraite,
//elle n’est pas définie dans Personne.
}
Personne p ;
//on peut déclarer une référence sur un objet
//de type Personne ou dérivé.
p = new Personne (); //Erreur, pas
//d’instanciation d’objets d’une classe
//abstraite. 4
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Règles


• Une classe est automatiquement abstraite (déclarée avec le mot clé abstract) si une de ses
méthodes est abstraite. Une méthode abstraite ne peut pas être privée, ce qui est logique
puisque son corps sera définit 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 determineAge (int); //Erreur : nom argument fictif est obligatoire
public abstract void determineAge (int annee); //Correct

• 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.
5
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Règles

• Une classe abstraite est non instanciable (donc il n’est pas possible d’utiliser les
constructeurs de cette classe et donc on ne peut pas créer des objet de son type.)
• Une classe dérivée d'une classe abstraite ne devient concrète que si elle implémente
toutes les méthodes abstraites de sa classe de base.
• Une méthode abstraite ne possède pas de corps, mais doit être implémentée dans les
classes dérivées non abstraites : abstract fonction (arguments); ce n'est qu'une signature .
• Une classe abstraite peut contenir des méthodes non abstraites et des déclarations de
variables ordinaires.

6
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Intérêt


• Une classe abstraite peut être utile pour imposer l'existence de certaines méthodes dans
des classes, sans savoir comment elles seront implémentées.
public abstract class Personne {
public abstract void affiche();
}

public class Enseignant extends Personne{ public class Etudiant extends Personne{
public void affiche() { public void affiche() {
System.out.println("Je suis un System.out.println("Je suis
+ "enseignant.");} + "un étudiant.");}
} }

• Une classe qui hérite d'une classe abstraite doit redéfinir les méthodes abstraites, sinon elle
est abstraite également.
7
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Intérêt

• Les classes abstraites facilitent 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 lorsqu’ils sont communs à tous les descendants,
• Soit sous forme d’interface des méthodes abstraites dont on est alors sûr qu’elles existeront
dans toute classe dérivée instanciable.

8
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Exemple

• Considérons la hiérarchie des classes suivantes :

• On veut que les classes Cercle et Rectangle disposent de la méthode surface() retournant
la surface de la figure géométrique définie par la classe.
9
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Exemple


public abstract class Graphique {
private int x, y; //Voilà les champs à hériter

//Une classe abstraite ne peut pas être instanciée, mais elle peut avoir
//un constructeur :
public Graphique ( int x, int y) {
this.x = x ; this.y = y ;}

//Voilà la méthode abstraite à compléter :


public abstract double surface();

//Il peut y avoir des méthodes non abstraites


public void affiche() {
System.out.println("Le centre de l’objet se trouve dans :" + x + " et " + y);
System.out.println("La surface de l'objet est :" + this.surface());}
} 10
III. CONCEPTS DE LA POO EN JAVA

Classes abstraites: Exemple

public class Cercle extends Graphique { public class Rectangle extends Graphique {
private double rayon; private int largeur, longueur;

public Cercle(int x, int y, double r) { public Rectangle(int x, int y, int la, int lo){
super(x, y); super(x, y);
rayon = r;} this.longueur = lo;
this.largeur = la;}
public double surface() {
return (2 * 3.14 * rayon);} public double surface() {
} return (longueur * largeur);}
}

11
III. CONCEPTS DE LA POO EN JAVA

tab[0] = new Graphique (3,2);


Classes abstraites: Exemple Erreur, classe abstraite est non
instanciable.
public class TestGraphique { Il est tout de même possible de
public static void main(String[] args) { déclarer des variables de ce type qui
Graphique[] tab = new Graphique[6]; pourront recevoir des objets créés à
tab[0] = new Graphique (3,2); partir des sous-classes concrètes
tab[1] = new Cercle(10, 7, 3);
tab[2] = new Rectangle(4, 7, 8, 6);
Le centre de l’objet se trouve dans :10 et 7
tab[3] = new Rectangle(8, 10, 12, 10);
La surface de l'objet est :18.84
tab[4] = new Cercle(8, 5, 3);
Le centre de l’objet se trouve dans :4 et 7
tab[5] = new Rectangle(10, 17, 3, 8);
La surface de l'objet est :48.0
for (int i = 1;
0; i <= 5; i++) {
Le centre de l’objet se trouve dans :8 et 10
tab[i].affiche();
La surface de l'objet est :120.0
// Y-a-t-il
Quel est des
le résultat?
erreurs?
Le centre de l’objet se trouve dans :8 et 5
//
}} Quel est le résultat?
La surface de l'objet est :18.84
} }}
Le centre de l’objet se trouve dans :10 et 17
} 12
La surface de l'objet est :24.0
III. CONCEPTS DE LA POO EN JAVA

Interfaces: Concept

• Une interface est un ensemble d'opérations utilisées pour spécifier un service offert par
une classe.
• Elle peut être vue comme une classe sans attributs (sauf les constantes) et dont toutes
les opérations sont spécifiées mais pas définies à priori.
• Elle peut être vue comme un contrat ou un modèle que doivent offrir toutes les classes
qui se réclament (implémentent) de cette interface.
public interface Polygone {
int surface();
void deplace(int x, int y);
}
13
III. CONCEPTS DE LA POO EN JAVA

Interfaces vs classes abstraites


• Le corps d'une interface ressemble beaucoup à celui d'une classe abstraite avec cependant les
différences suivantes :
• Une interface ne peut définir que des méthodes abstraites. Le modificateur abstract n'est pas
nécessaire.
• Toutes les méthodes abstraites sont implicitement publiques même si le modificateur public est
omis.
• Une interface ne peut pas déclarer des méthodes statiques comme abstraites.
• Une interface ne peut pas définir de champs d'instance.
• Une interface peut cependant contenir des constantes déclarées static et final (tous les champs
sont implicitement static et final même si les modificateurs correspondants sont omis).
• Une interface ne définit pas de constructeur (on ne peut pas l'instancier et elle n'intervient pas
dans le chaînage des constructeurs).
14
III. CONCEPTS DE LA POO EN JAVA

Interfaces vs classes abstraites

• Si l’on considère une classe abstraite n’implémentant aucune méthode et aucun champ
(sauf les constantes), on aboutit à la notion d’interface.
• 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).
Interface I2 Interface I3
public class MaClasse implements I1, I2{}

MaClasse

public class MaClasse extends C1, C2{} // Pas possible


15
III. CONCEPTS DE LA POO EN JAVA

Interfaces vs classes abstraites

• L’interface est plus riche qu’un simple cas particulier des classes abstraites :
• Les interfaces peuvent se dériver et même utiliser l’héritage multiple:

public interface I1 extends I2, I3{……}

Interface I2 Interface I3

Interface I1
16
III. CONCEPTS DE LA POO EN JAVA

Interfaces vs classes abstraites


• L’interface est plus riche qu’un simple cas particulier des classes abstraites :
• 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.
class B extends A implements I1, I2, I3 {…}
Interface I3 class A implements I3{…}

Interface I1 Interface I2
Class A

Class B
class A implements I1{}
• On pourra utiliser des variables de type interface. I1 obj=new A(); 17
III. CONCEPTS DE LA POO EN JAVA

public interface Polygone { public interface Polygone {


int max = 100; public static final int max = 100;

int surface(); public abstract int surface();


void deplace(int x, int y);} public abstract void deplace(int x, int y);}
Une interface peut renfermer aussi des constantes
public class Cercle implements Affichable, Polygone {
private double rayon;
private Point centre; public interface Affichable {
void afficher();
public double surface() { }
return (double) (2 * 3.14 * rayon);}
public void deplace(int x, int y) { Lorsqu’on définit une classe, on peut préciser qu’elle
centre.setX(centre.getX()+x); implémente une ou plusieurs interface en utilisant le
centre.setY(centre.getY()+y);} mot clé « implements »
public void afficher() {
System.out.println("Je suis un cercle");}
} 18
III. CONCEPTS DE LA POO EN JAVA

Interfaces et dérivation

• L’interface est totalement indépendante de l’héritage : Une classe dérivée peut


implémenter une ou plusieurs interfaces.
• L'implémentation d'une ou plusieurs interfaces (implements) peut être combinée avec
l'héritage simple (extends).
• La clause implements doit suivre la clause extends.
public class Cercle extends Graphique implements Affichable, Polygone

19
III. CONCEPTS DE LA POO EN JAVA

Interfaces: Caractéristiques

• Lorsqu'une classe déclare une interface dans sa clause implements, elle indique ainsi
qu'elle s'engage à fournir une implémentation (c'est-à-dire un corps ) pour chacune des
méthodes de cette interface.
• Si une classe implémente une interface mais ne fournit pas d'implémentation pour toutes
les méthodes de l'interface, c-à-d elle hérite des méthodes (abstraites) non implémentées
, elle doit être déclarée abstract.
• Si une classe implémente plus d'une interface, elle doit implémenter toutes les méthodes
de chacune des interfaces mentionnées dans la clause implements (ou alors doit être
déclarée abstract).
20
III. CONCEPTS DE LA POO EN JAVA

public interface Polygone { public interface Affichable {


int max = 100; void afficher();
}
int surface();
void deplace(int x, int y);}
La classe Carre est déclarée abstract car elle
n’implémente pas toutes les méthodes des interfaces
implémentée
Toutes les public abstract class Carre implements Affichable, Polygone{
méthodes
abstraites sont abstract double surface();
implicitement abstract void deplace(int x, int y) ;
publique: Pas
besoin du mot clé public void afficher() {
public System.out.println("Je suis un carré.");}
}

21
III. CONCEPTS DE LA POO EN JAVA

Interfaces: Conflits des noms


class A implements I1, I2{
interface I1 { interface I2 {
void f(int n) {}
void f(int n) ; void f(float x);
void f(float x) {}
void g(); void g();
void g();
} }
}

A doit implémenter la méthode g() existante


dans les 2 interfaces une seule fois

class A implements I1, I2{


interface I1 { interface I2 {
void f(int n) {}
void f(int n) ; void f(float x);
void f(float x) {}
void g(); int g();
void g();
} }
int g();
}
la méthode « g () » est présentée de 2 façons Erreur car void g() et int g() ne peuvent pas 22
différentes dans I1 et I2 coexister au sein de la même classe
III. CONCEPTS DE LA POO EN JAVA

Méthodes génériques

• Les méthodes génériques sont celles


public static <E> void genericDisplay(E element){
qui sont écrites avec une seule System.out.println(element.getClass().getName()
déclaration et qui peuvent être +"="+element);
appelées avec des arguments de }
différents types. String str = "Type String";
Carre.genericDisplay(str);

• En fonction des types d’arguments Integer i = 25;


Carre.genericDisplay(i);
passés à la méthode générique, le
compilateur gère chaque appel de java.lang.String=Type String
java.lang.Integer=25
méthode de manière appropriée.
23
III. CONCEPTS DE LA POO EN JAVA

Méthodes génériques

• Voici les règles pour définir les méthodes génériques:


• Les méthodes génériques ont un type paramétré (qui représente un paramètre de
type générique) avant le type de retour de la déclaration de méthode.
public static <E> void genericDisplay(E element){
System.out.println(element.getClass().getName()
+"="+element);}

• Les méthodes génériques peuvent avoir différents types paramétrés séparés par
des virgules dans la signature de méthode.
public static <E,T> void affichage2(E element1, T element2){ affichage2(str,i);
System.out.println("element 1= "+element1+ ", element2=
"+element2);} 24
element 1= Type String, element2= 25
III. CONCEPTS DE LA POO EN JAVA

Méthodes génériques

Type paramétré
• Les conventions de dénomination de types paramétrés sont importantes pour apprendre
la généricité en Java. Ils doivent contenir une seule lettre en majuscule. Les types
paramétrés courants sont les suivants: T – Type, E – Element, K – Key, N – Number,
V – Value.
• Le type T, par exemple, indique que la méthode peut faire référence à n’importe quel
type objet (comme String, Integer et Personne) et non pas un type de base.
• On peut utiliser des types spécifiques héritant d’une classe spécifique. Exemple:
<N extends Number>, < T extends ClassA >
25
III. CONCEPTS DE LA POO EN JAVA

public class Main {


// méthode générique
public static <E> void display(E[] tab) {
for(E e : tab) {
System.out.printf("%s ", e);
}
System.out.println();
} Tableau des entiers:
public static void main(String args[]) { 1 2 3
Integer[] i = {1, 2, 3};
System.out.println("Tableau des entiers:"); Tableau des caractères:
display(i); // passer un tableau entier A B C
Character[] c = {'A', 'B', 'C'};
System.out.println("\nTableau des caractères:");
display(c); // passer un tableau de caractères
}
}
26
III. CONCEPTS DE LA POO EN JAVA

Classes génériques
• La déclaration d’une classe générique ressemble à une déclaration de classe non
générique, sauf que le nom de la classe est suivi du type paramétré. Exemple:
class MaClasse <T> {}
• Comme pour les méthodes génériques, la section des paramètres d’une classe générique
peut avoir un ou plusieurs paramètres de type séparés par des virgules.
class MaClasse <T,E> {}

• Ces classes sont appelées classes paramétrées ou types paramétrés car elles acceptent un
ou plusieurs paramètres.
• Une classe qui peut faire référence à n’importe quel type est appelée une classe
générique.
27
III. CONCEPTS DE LA POO EN JAVA

Classes génériques

• Exemple:
class MaClasse <T> { public class TestGen {
T obj;
public static void main(String args[]) {
void setObj(T obj){ MaClasse<Integer> obj = new MaClasse<Integer>();
this.obj = obj; obj.setObj(5);
} //obj.setObj("String"); // Erreur de compilation
System.out.println(obj.getObj());
T getObj(){ }
return obj; }
}
} 5

28
III. CONCEPTS DE LA POO EN JAVA

Interfaces génériques

• La généricité fonctionnent également avec les interfaces.


• Les interfaces génériques sont spécifiées tout comme les classes génériques.
interface MyInterface<T> { ... }

• Si une classe implémente une interface générique, on doit indiquer les types des
paramètres avec lesquels la classe fonctionne.
class Myclass implements MyInterface<Integer> {...} //On a spécifié la param à Integer;
• Sinon, cette classe est aussi générique.
class Myclass<T> implements MyInterface<T> {...}
29
III. CONCEPTS DE LA POO EN JAVA

L’interface Comparable
• Comparable est une interface générique définie dans l’API Java (package java.lang). Elle
impose aux classes qui vont l’implémenter la définition de la méthode compareTo():
public interface Comparable<T> {
public int compareTo(T o);
}
• La méthode compareTo() permet de comparer l’objet courant (this) à l’objet o reçu en argument
et de renvoyer un entier (dont la valeur exacte est sans importance) :
• négatif (la valeur -1) si l’on considère que l’objet courant est « inférieur » à l’objet o (au sens de
l’ordre qu’on veut définir),
• nul (la valeur 0) si l’on considère que l’objet courant est égal à l’objet o (il n’est ni inférieur, ni
supérieur),
• positif (la valeur 1) si l’on considère que l’objet courant est « supérieur » à l’objet o
30
III. CONCEPTS DE LA POO EN JAVA

Exercice

• Implémentez le code correspondant au diagramme de classes suivant et donnez un


programme de test.
IOperation Affichage {abstract}

Comparable + plus(Object obj) :Object + affiche(): String {abstract}


+ moins(Object obj) : Object

<<extends>>
<<implements>> <<implements>> <<implements>>
Complexe
- im : double Reel
- re: double - x : double
31
III. CONCEPTS DE LA POO EN JAVA

Exercice: Corrigé
public class Reel extends Affichage implements IOperation<Reel>{
private double x;
public interface IOperation <T>{
public Reel(double x) { public T plus(T nombre);
this.x = x;} public T moins(T nombre);
}
public String affiche() {
return Double.toString(x);} public abstract class Affichage {
public abstract String affiche();
public Reel plus(Reel r1) { }
Reel resultat= new Reel(this.x+r1.x);
return resultat;}

public Reel moins(Reel r1) {


Reel resultat= new Reel(this.x-r1.x);
32
return resultat;}}
III. CONCEPTS DE LA POO EN JAVA

public class Complexe implements IOperation<Complexe>, Comparable<Complexe>{


public int compareTo(Complexe o) {
private double im, re;
if(this.module()==o.module())
return 0;
public Complexe(double im, double re) {
if(this.module()<o.module())
this.im = im;
return -1;
this.re = re;}
else
return 1;}
public Complexe plus(Complexe nombre) {
Complexe resultat=new Complexe(this.im+nombre.im, this.re+nombre.re);
return resultat;}

public Complexe moins(Complexe nombre) {


Complexe resultat=new Complexe(this.im-nombre.im, this.re-nombre.re);
return resultat;}
public double module() {
return Math.sqrt(im*im+re*re);}
public String toString() {
return "Complexe [im=" + im + ", re=" + re + "]";}
} 33
III. CONCEPTS DE LA POO EN JAVA

Complexe c1=new Complexe(1,2); int a=c1.compareTo(c2);


Complexe c2=new Complexe(2,3); switch(a) {
case -1: System.out.println(c1.toString()+"
System.out.println(c1); est inférieur à "+c2.toString());
System.out.println(c2); break;
case 0: System.out.println(c1.toString()+"
est égal à "+c2.toString());
Reel r1=new Reel(1); break;
Reel r2=new Reel(2); case 1: System.out.println(c1.toString()+"
est supérieur à "+c2.toString());
System.out.println(r1.affiche()); break;
System.out.println(r2.affiche()); }
Complexe [im=1.0, re=2.0]
Complexe [im=2.0, re=3.0]
System.out.println(c1.plus(c2));
1.0
2.0
System.out.println(r1.moins(r2).affiche());
Complexe [im=3.0, re=5.0]
-1.0
Complexe [im=1.0, re=2.0] est inférieur
34 à
Complexe [im=2.0, re=3.0]

Vous aimerez peut-être aussi