![Page 1: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/1.jpg)
Interface et Classe
IFT1025, Programmation 2
Jian-Yun Nie
![Page 2: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/2.jpg)
Concepts importants
• Interface: un contrat qu’une classe doit se conformer– Favorise la réutilisation des codes– Il suffit de savoir qu’une classe se conforme à une
interface pour pouvoir l’utiliser (sans connaître les détails de son implantation)
• Classe normale: une classe implantée (dont les méthodes sont toutes définies)
• Classe abstraite: une classe qui n’est pas complètement implantée– Mi-chemin entre classe normale et interface
![Page 3: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/3.jpg)
Utilisation des classe
• Soit la classe BankAccount et les sous-classes CheckingAccount et SavingsAccount
• On peut faire des opérations en commun sur l’ensemble d’objets de la classe BankAccount (y compris ceux des sous-classe),
• Principe:– Pour tout objet ref de BankAccount:
• ref.operation– Conditions:
• operation est définie pour la classe mère (pour que ref.operation ne gégère pas une erreur de compilation)
• Operation est héritée ou redéfinie dans les sous-classes (polymorphisme)
• Polymorphisme assure qu’on utilise la version de l’instance
![Page 4: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/4.jpg)
Exemple trivial: trouver balance maxpublic BankAccount maxAccount(BankAccount [] compte){
BankAccount ref, refMax;int i;double max = 0;for (i=0; i<compte.length; i++){
ref = compte[i];if (ref.getBalance() > max) {
max = ref.getBalance(); refMax=ref;
}}return refMax;
}
• C’est possible grâce à getBalance() dans la classe BankAccount (et héritée dans les sous-classes)
Utilisation:BankAcount meilleurClient;BankAccount [] clients = {new BankAccount(100), new CheckingAccount(10), //Petit tableau de 3 éléments
new SavingsAccount(0.05)}… // des manipulations sur ces comptesmeilleirClient = maxAccount(clients);
• Avantage de l’héritage et l’homogénéité dans une classe
![Page 5: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/5.jpg)
Cas non trivial
• On ne peut pas implanter une méthode pour la classe mère, mais seulement dans les sous-classes
• Exemple:– Classe: Forme: draw() non implantables– Sous-classes: Rectangle: draw() implanté
Rond: draw() implantée
• Mais on veut quand même utiliser la référence ref de classe Forme pour ref.draw()
![Page 6: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/6.jpg)
Généralisation
• On veut créer des opérations applicables pour toutes les instances d’une classe
• Si une méthode est implantée pour la classe mère et toutes les sous-classe (héritée ou redéfinie)– Cas trivial: la méthode est applicable
• Deux cas non triviaux:1. La méthode ne peut pas être implantée pour la
classe mère, mais elle le peut pour les sous-classes
2. On désire appeler la même méthode pour différentes classes (non reliées)
![Page 7: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/7.jpg)
Premier cas: classe abstraite• On veut définir une classe correspondant un
concept (abstraite) englobant toutes les formes (rectangle, triangle, etc.)
• On sait que chaque forme a une surface• On souhaite définir une méthode getSurface
pour chaque forme • Problème:
– Il existe pas une façon générale pour calculer la surface pour une forme
– Le calcul est possible seulement pour les sous-classes (Rectangle, Triangle, Rond, etc.)
![Page 8: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/8.jpg)
Hiérarchie
Forme: getSurface()
Rectangle Triangle Rond …
getSurface() getSurface() getSurface()
• On ne veut pas créer une instance de Forme• Solution: classe abstraite pour la classe mère
Non implantable
![Page 9: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/9.jpg)
Deuxième cas
• On veut pouvoir appliquer une opération sur des objets– Ex: comparer les objets de la même classe pour
connaître un ordre: <, >, etc.
• Cette comparaison doit s’appliquer sur des classes très différentes– BankAccount, Rectangle, etc. avec des critères
différents
• Impossible d’utiliser classes abstraite pour ce cas– Les classe ne sont pas sous la même classe mère
![Page 10: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/10.jpg)
Illustration
Object
BankAccount Mot Personne Forme
CheckingAccount Rectangle Triangle Rond
SavingsAccount
Classes pour lesquelles on veut définir l’ordre• Impossible de regrouper les classes sous une autre classe mère
– Héritage simple
• Solution: interface
Ordre
![Page 11: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/11.jpg)
Classe abstraite
• Déclarationabstract public class Nom { … }
• Exempleabstract class Forme
{
int x, y; // coordonnée du début de la forme
abstract float getSurface();
}
![Page 12: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/12.jpg)
Caractéristiques de classe abstraite
• Déclaration de classe avec abstract• Dans le corps {…}:
– On peut définir une méthode abstraite• abstract float getSurface();• Méthode abstraite n’a pas de corps (non implantée)
– Mais une classe abstraite peut ne pas avoir de méthode abstraite
– On peut déclarer des attributs et implanter des méthodes
• On ne peut pas créer d’instance d’une classe abstraite– new Forme(): Erreur de compilation
![Page 13: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/13.jpg)
Sous-classes d’une classe abstraite
• class SousClasse extends Classe
• Si une sous-classe n’est pas abstraite– Toutes les méthodes abstraites héritées
doivent être implantées (avec un corps)– Sinon, la sous-classe doit aussi être abstraite
• Instance possible pour une sous-classe non abstraite
![Page 14: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/14.jpg)
Exempleabstract class Forme
{int x, y; // coordonnée repère de la formeabstract float getSurface();abstract void draw();
}
public class Rectangle extends Forme{
int longueur, largeur;public float getSurface(){
return (float) longueur * largeur;}public void draw(){ … // dessiner le rectangle}
}
• Une sous-classe concrète doit implanter toutes les méthodes abstraites héritées
![Page 15: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/15.jpg)
Exemple (cont.)public class Rond extends Forme{
int rayon;public float getSurface(){
…}
}
// Une forme composée de deux autres formesabstract class FormeComposee extends Forme{
Forme f1, f2;}
• Si une sous-classe n’implante pas toutes les méthodes abstraite, elle continue à être abstract
Hérités:int x, y; abstract float getSurface();abstract void draw();
![Page 16: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/16.jpg)
Interface• Interface = contrat = exigence de certains types
de comportements• Exigences applicables sur des classes
différentes: BankAccount, Mot, …– Exemple: ordonner les objets
• BankAccount: selon la balance• Mot: selon l’ordre de mot, …
• Si on utilise seulement classe (abstraite):– On doit définir ces comportements séparément dans
chaque classe – Pas moyen de regrouper ces objets
![Page 17: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/17.jpg)
Utilisation désirée (exemple)
• Pour un groupe d’objets avec un comportement commun: ordre(Objet)– Faire le même traitement de tri– Programme général qui fonctionne sur tous les objets
possédant ordre(Objet)• Pour tous ref1 et ref2 de ce type
– ref1.ordre(ref2) >0, ref1.ordre(ref2) =0, ref1.ordre(ref2) <0
– Réordonner selon leur comparaison
– Ce programme ne doit pas seulement fonctionner pour une classe
– Solution: interface
![Page 18: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/18.jpg)
interface
• Une interface permet de regrouper les objets qui peuvent manifester le même type de comportement (mêmes méthodes)
• Interface n’a pas la même contrainte de héritage simple pour les classe– Une classe peut se conformer à plusieurs interfaces– Ex:
• Mot peut se comparer par ordre(…) et peut être mesuré en longueur, etc.
• Interface 1 pour ordre, interface 2 pour longueur, …
![Page 19: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/19.jpg)
Définition d’une interface
• public interface Measurable
{
double getMeasure();
} • Lister toutes les méthodes (comportements)
désirées sans implantation (juste la signature)– Méthodes sont automatiquement abstract et public
• Pas d’attribut (sauf constante)
![Page 20: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/20.jpg)
Utiliser une interface
• Une classe se conforme à une interface:– class BankAccount implements Measurable
{ …public double getMeasure() {
return value; }
• La classe doit implanter toutes les méthodes exigées par l’interface
![Page 21: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/21.jpg)
Utiliser une interface
• Une autre classe peut se conformer à la même interface• public class Coin implements Measurable
{ public double getMeasure() {
return value; } . . .
} • Mécanisme similaire à un héritage multiple, mais
différent
![Page 22: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/22.jpg)
Utiliser une interface• On peut utiliser une interface comme un type• Ex: déterminer le max et la somme:public class DataSet { . . .
public void add(Measurable x) {
sum = sum + x.getMeasure(); if (count == 0 || maximum.getMeasure() < x.getMeasure())
maximum = x; count++; } public Measurable getMaximum() {
return maximum; } private double sum; private Measurable maximum; private int count;
}
x est du type Measurable:- possède getMeasure()
![Page 23: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/23.jpg)
Utiliser une interface• 01: /**• 02: This program tests the DataSet class.• 03: */• 04: public class DataSetTester• 05: {• 06: public static void main(String[] args)• 07: {• 08: DataSet bankData = new DataSet();• 09: • 10: bankData.add(new BankAccount(0));• 11: bankData.add(new BankAccount(10000));• 12: bankData.add(new BankAccount(2000));• 13: • 14: System.out.println("Average balance = " • 15: + bankData.getAverage());• 16: Measurable max = bankData.getMaximum();• 17: System.out.println("Highest balance = " • 18: + max.getMeasure());• 19: • 20: DataSet coinData = new DataSet();• 21: • 22: coinData.add(new Coin(0.25, "quarter"));• 23: coinData.add(new Coin(0.1, "dime"));• 24: coinData.add(new Coin(0.05, "nickel"));• 25: • 26: System.out.println("Average coin value = " • 27: + coinData.getAverage());• 28: max = coinData.getMaximum();• 29: System.out.println("Highest coin value = " • 30: + max.getMeasure());• 31: }• 32: }
Average balance = 4000.0 Highest balance = 10000.0 Average coin value = 0.13333333333333333 Highest coin value = 0.25
![Page 24: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/24.jpg)
Relation entre classe et interface
class BankAccount implements Measuarable• Convertir le type d’une classe à une interface
– BankAccount account = new BankAccount(10000);Measurable x = account; // OK System.out.println(x.getMeasure());
• Casting une référence du type interface en une classe– Ajouter un objet à DataSet
DataSet coinData = new DataSet();coinData.add(new Coin(0.25, "quarter"));coinData.add(new Coin(0.1, "dime"));. . .Measurable max = coinData.getMaximum(); // Get the largest coin
– String name = max.getName(); // ERROR – Coin maxCoin = (Coin) max;
String name = maxCoin.getName(); // OK
![Page 25: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/25.jpg)
Utilisation d’interface générale
• Interface comme un type abstrait de données– Liste– Arbre binaire– …
• Chaque type abstrait possède des méthodes « standard »
• Interface: exiger ces méthodes
![Page 26: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/26.jpg)
Classe abstraite vs. Interface• Classe abstraite
– Certaines méthodes peuvent être abstraites– Peut contenir des attributs– Peut implanter des méthodes– Héritage simple
• Interface = contrat– Aucune implantation de méthode– Différentes classes peuvent signer le même contrat
• Classe = famille – posséder le même nom de famille– a la même habileté (peut être une méthode abstraite)
• Interface = contrat– Contrat commun pour différentes familles
![Page 27: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/27.jpg)
Exemple: Interface Movable
Movable
Potion
«interface»
SwordRing
Gnomemoves
![Page 28: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/28.jpg)
Interface Weapon
Weapon
Pen
«interface»
MissileLauncherSword
Explorerwields
![Page 29: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/29.jpg)
“Héritage” Multiple d’interfaces par une classe
Weapon
«interface»
Sword
Movable
«interface»
class Sword implements Weapon, Movable {…}
![Page 30: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/30.jpg)
Extension d’interface• Assume all weapons are movable:
Weapon
Pen
«interface»
MissleLauncherSword
Movable
Potion
«interface»
Ring
interface Weapon extends Movable {…}
Interface
![Page 31: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/31.jpg)
Modifier une interface?
• Si une classe définie n’est plus suffisante– Ajouter des attributs et des méthodes– Les autres classes utilisant cette classe continuent à
fonctionner
• Si une interface n’est plus suffisante – Ne pas ajouter des méthodes abstraites– Sinon, les classe qui sont conformes à l’interface ne
le seront plus (très coûteux à modifier toutes ces classes!)
– On définit plutôt une sous-interface– interface SousInterface extends SuperInterface
![Page 32: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/32.jpg)
Extension multiple d’interface
• Une interface peut extends plusieurs autres interfaces
DataInput
«interface»
DataOutput
«interface»
DataIO
«interface»
interface DataIO extends DataInput, DataOutput { }
![Page 33: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/33.jpg)
instanceOf
• Tester si une instance est d’une classe (sous-classe)• Fonctionne aussi pour tester si une instance est du type
d’une interface (se conforme à une interface)• Exemple:
interface DataIO extends DataInput, DataOutput { }DataIO refInterface;BankAccount compte;
…
if (refInterface instanceOf DataOutput) …
if (compte instanceOf Movable) …
![Page 34: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/34.jpg)
Utilisation d’interface et de classe
• Interface comme type de donnée – Partagent les méthodes
• Classe comme type de données – Partagent les méthodes et attributs
• Les deux peuvent se convertir– refInterface instance – refClasse instance– Casting:
• (Interface).refClasse: utile?– refClasse peut faire la même chose que (Interface).refClasse.
• (Classe).refInterface: utile!– Accéder à d’autres attributs et méthodes de la Classe
![Page 35: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/35.jpg)
Exemple d’interface en Java
• Collection
![Page 36: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/36.jpg)
Collectionpublic interface Collection<E> extends Iterable<E> { //Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator iterator(); //Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); //optional boolean removeAll(Collection<?> c); //optional boolean retainAll(Collection<?> c); //optional void clear(); //optional //Array operations Object[] toArray(); <T> T[] toArray(T[] a);}
<E>: Genetic
![Page 37: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/37.jpg)
Traverser une collection (aperçu)
public interface Iterator<E> { boolean hasNext(); E next(); void remove(); //optional}
Utilisation:Supposons: boolean cond(Object)
static void filter(Collection c) { for (Iterator i = c.iterator(); i.hasNext(); ) if (!cond(i.next())) i.remove();}
![Page 38: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/38.jpg)
Listpublic interface List<E> extends Collection<E> { //Positional access E get(int index); E set(int index, E element); //optional boolean add(E element); //optional void add(int index, E element); //optional E remove(int index); //optional abstract boolean addAll(int index, Collection<? extends E> c); //optional
//Search int indexOf(Object o); int lastIndexOf(Object o);
//Iteration ListIterator<E> listIterator(); ListIterator<E> listIterator(int index);
//Range-view List<E> subList(int from, int to);}
![Page 39: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/39.jpg)
ArrayList
java.util Class ArrayList<E>
java.lang.Object java.util.AbstractCollection<E> java.util.AbstractList<E> java.util.ArrayList<E>
All Implemented Interfaces:
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
Hiérarchie des classes
![Page 40: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/40.jpg)
Comparaison avec AbstractListpublic abstract class AbstractList<E>extends AbstractCollection<E>implements List<E>
{
// Méthodes implantées:
void add(int index, E element) {…}
void clear() {…}
int hashCode() …
}
![Page 41: Interface et Classe IFT1025, Programmation 2 Jian-Yun Nie](https://reader036.vdocuments.mx/reader036/viewer/2022062622/551d9da5497959293b8d69d3/html5/thumbnails/41.jpg)
Inner class: concept• Définir une classe qui a une utilité locale comme inner classs:• public class DataSetTester3
{ public static void main(String[] args) {
class RectangleMeasurer implements Measurer { . . . }
Measurer m = new RectangleMeasurer(); DataSet data = new DataSet(m);. . . }
} • Dans une inner class, on peut accéder aux méthodes et attributs de la
classe qui l’englobe (DataSetTesters)