Chapitre3 - Part2
Chapitre3 - Part2
Chapitre3 - Part2
2
III. CONCEPTS DE LA POO EN JAVA
• 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
• 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
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
8
III. CONCEPTS DE LA POO EN JAVA
• 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
//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 ;}
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
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
• 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
• 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:
Interface I2 Interface I3
Interface I1
16
III. CONCEPTS DE LA POO EN JAVA
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
Interfaces et dérivation
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
21
III. CONCEPTS DE LA POO EN JAVA
Méthodes génériques
Méthodes génériques
• 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
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
• 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
<<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;}