Chap 6 VF

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

Programmation Orientée

Objet
3ème année Ingénieur en Informatique

Dr. Ing. Rihab BEN LAMINE


benlaminerihab@gmail.com

2023-2024
Chapitre 6: Les
Interfaces

2
Interface
 Une interface est une collection nommée de déclarations de méthodes (sans les
implémentations).

Elle permet à des classes qui ne sont pas liées d’avoir accès à des opérations similaires

 Une interface ne peut contenir ni variable d’instance, ni méthode implémentée.

 Une interface peut aussi déclarer des constantes. (tous les attributs d’une interface sont
par défaut public, static et final. )

 Les méthodes d’une interface sont par défaut public et abstract

 Le terme d’héritage n’est pas utilisé entre classes et interfaces : on dit qu’une classe
implémente une interface.
Interface
Une interface ne peut être instanciée.

Lorsqu’une classe implémente une interface, elle doit redéfinir toutes ses
méthodes abstraites ou bien être abstraite.

 Une interface peut hériter d’une autre interface.


Une classe peut implémenter plusieurs interfaces différentes.
Ceci permet d’assouplir une restriction portant sur l’héritage qui est qu’une
classe ne peut hériter que d’une seule autre classe.
Interface
A partir de Java 8, on peut ajouter deux éléments supplémentaires dans une
interface:
 des méthodes statiques
• Utilisées pour définir des « factory method » (design pattern)
 des méthodes par défaut qui sont des méthodes concrètes.
• Utilisées dans le cas où on veut faire évoluer une interface déjà exposée(java.util.List)
en ajoutant de nouvelles méthodes, sans imposer à tous ceux qui l’ont implémenté de
devoir obligatoirement retoucher le code
Interface
Exemple 1:
public interface Loisir{
public int distance = 21;
public void marcherOuCourir();
}

Noter le mot interface au lieu de class.


ici , distance est considérée comme variable final et ne peut être modifiée.
Interface
Exemple 2:

public interface Foo{


public default void foo(){
System.out.println("Implémentation par défaut");
}
}
Implémentation d’une interface
L'implémentation d'une interface, c'est à dire des méthodes déclarées, doit
être faite dans une classe séparée.
class Sportif implements Loisir {
//Implémentation de la méthode marcherOuCourir
public void marcherOuCourir(){
System.out.println("Je marche "+distance+" Km.");
}
}

class Test{
public static void main(String args[]){
Sportif s = new Sportif () ; Je marche 21 Km.
s.marcherOuCourir();
}}
Implémentation de plusieurs interfaces
public interface A{ public interface B{ public interface C{
void showA(); void showB(); void showC();
} } }

public class SimpleTesting implements A, B, C{


public void showA() { System.out.println("Interface A"); }
public void showB() { System.out.println("Interface B"); }
public void showC() { System.out.println("Interface C"); }
public static void main(String[] args){
SimpleTesting st = new SimpleTesting();
st.showA();
st.showB();
st.showC(); }
}
Héritage d’interfaces
 Une interface peut hériter d’autres interfaces.
 Contrairement aux classes qui ne peuvent avoir qu’une classe parente, une
interface peut avoir autant d’interfaces parentes que nécessaire.
 Pour déclarer un héritage, on utilise le mot-clé extends.
public interface Carnivore{ public interface Omnivore extends
void manger(Animal animal); Carnivore, Herbivore {
} }

public interface Herbivore {


void manger(Vegetal vegetal);
}
L’interface Comparable
Définition : L'interface Comparable permet de définir un ordre naturel sur les
objets d'une classe.
Utilisation : elle est utilisée pour comparer un objet de la même classe avec
une instance de cette classe. Elle fournit un tri unique séquence dans laquelle
la collection peut être triée via un seul élément comme l'identifiant, le nom ou
tout paramètre spécifique.
Méthode : int compareTo( Object o)
Un appel de a.compareTo(b) doit retourner:
 Une valeur <0 si a vient avant b dans l’ordre
Une valeur >0 si a vient après b dans l’ordre
Ou 0 si a et b sont considérés comme égaux dans l’ordre
Package : java.lang
Implémentation de l’interface Comparable
Syntaxe :
public class MaClasse implements Comparable {
// Variables d'instance et méthodes de la classe
// ...

@Override
public int compareTo(Object autreObjet) {
// Logique de comparaison
if(autreObjet instanceof MaClasse ) {
MaClasse sc=(MaClasse ) autreObjet;
……………………………….
}
}
Exemple
Exemple : Comparaison de fruits par poids
Classe Fruit implémentant Comparable.
Comparaison basée sur le poids.

Tri d'une Liste d'Objets


Utilisation de la méthode Collections.sort() ou Arrays.sort().
Tri des objets dans l'ordre naturel défini par compareTo().
Exemple
public class Fruit implements
@Override
public int compareTo(Object o) {
Comparable { // Comparaison basée sur le poids
private String nom; if(o instanceof Fruit) {
private double poids; Fruit f=(Fruit)o;
if(this.poids<f.getPoids())
public Fruit(String nom, double poids) return -1;
{ else
this.nom = nom; if(this.poids>f.getPoids())
this.poids = poids; return 1;
} return 0;
}
public String getNom() { return 0;
return nom; }
} @Override
public String toString() {
public double getPoids() { return nom + " : " + poids + "g";
return poids; }
} }
Exemple
public class TestComparable {//avec ArrayList
public static void main(String[] args) {
ArrayList fruits = new ArrayList();
fruits.add(new Fruit("orange",3.7));
fruits.add(new Fruit("pomme",2.5));
fruits.add(new Fruit("pastèque",200.2));
for(int i=0;i<fruits.size();i++) {
System.out.println("fruit : "+((Fruit)fruits.get(i)).getNom()+" de
poids "+((Fruit)fruits.get(i)).getPoids());
}
Collections.sort(fruits);
System.out.println("********************************");
for(int i=0;i<fruits.size();i++) {
System.out.println("fruit : "+((Fruit)fruits.get(i)).getNom()+" de
poids "+((Fruit)fruits.get(i)).getPoids());
}
}
}
Exemple
public class TestComparable {//avec tableau
public static void main(String[] args) {
System.out.println("tableau de fruits");
Fruit[]f=new Fruit[3];
f[0]=new Fruit("orange",3.7);
f[1]=new Fruit("pomme",2.5);
f[2]=new Fruit("pastèque",200.2);
for(int i=0;i<f.length;i++) {
System.out.println("fruit : "+f[i].getNom()+" de
poids"+f[i].getPoids());
}
Arrays.sort(f);
for(int i=0;i<f.length;i++) {
System.out.println("fruit : "+f[i].getNom()+" de
poids"+f[i].getPoids());
}
}
}
L’interface Comparator
 Définition : L'interface Comparator permet de trier des objets
selon un ordre personnalisé.
 Utilisation : Personnalisation de l'ordre de tri des objets.
elle fournit une séquence de tri multiple dans laquelle la collection peut
être triée via plusieurs éléments tels que l'identifiant, le nom ou tout
autre paramètre
 Méthodes : compare(), equals().
 Package: java.util
Implémentation de l’interface Comparator
Syntaxe:

public class MonComparator implements Comparator{


// Méthode de comparaison
@Override
public int compare(Object Objet1,Object objet2) {
// Logique de comparaison
// ...
}
}
Implémentation de l’interface Comparator
Exemple : Comparaison de Fruits par Nom
 Classe Comparateur pour comparer les fruits par nom.
 Personnalisation de l'ordre alphabétique.

Tri d'une Liste d'Objets


 Utilisation de la méthode Collections.sort() ou Arrays.sort() avec un
Comparator personnalisé.
 Tri des objets selon les critères définis dans le Comparator.
Exemple @Override
public class Fruit implements public int compareTo(Object o) {
Comparable { // Comparaison basée sur le poids
private String nom; if(o instanceof Fruit) {
private double poids; Fruit f=(Fruit)o;
if(this.poids<f.getPoids())
public Fruit(String nom, double poids) return -1;
{ else
this.nom = nom; if(this.poids>f.getPoids())
this.poids = poids; return 1;
} return 0;
}
public String getNom() { return 0;
return nom; }
} @Override
public String toString() {
public double getPoids() { return nom + " : " + poids + "g";
return poids; }
} }
Exemple

class ComparateurNom implements Comparator {


@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Fruit && o2 instanceof Fruit) {
Fruit obj1 = (Fruit) o1;
Fruit obj2 = (Fruit) o2;
return (obj1.getNom().compareTo(obj2.getNom()));
}
return 0;
}
}
public class TestComparateurFruit {//avec ArrayList
public static void main(String[] args) {

Exemple Fruit pomme = new Fruit("Pomme", 150);


Fruit orange = new Fruit("Orange", 200);
Fruit banane = new Fruit("Banane", 120);
ArrayList fruits = new ArrayList();
fruits.add(pomme);fruits.add(orange);fruits.add(banane);
// Affichage des fruits avant le tri
Fruits avant le tri: System.out.println("Fruits avant le tri:");
Pomme : 150.0g for (int i=0;i< fruits.size();i++) {
Orange : 200.0g
Fruit fruit=(Fruit) fruits.get(i);
Banane : 120.0g
System.out.println(fruit);
}
Fruits après le tri par // Tri des fruits par nom
nom: Collections.sort(fruits, new ComparateurNom());
Banane : 120.0g // Affichage des fruits après le tri
Orange : 200.0g System.out.println("\nFruits après le tri par nom:");
Pomme : 150.0g for (int i=0;i< fruits.size();i++) {
Fruit fruit=(Fruit) fruits.get(i);
System.out.println(fruit);
}}}
Exemple
public class TestComparateurFruit {//avec tableau
public static void main(String[] args) {
Fruit[]f=new Fruit[3];
f[0]=new Fruit("Pomme", 150);
f[1]=new Fruit("Orange", 200);
f[2]=new Fruit("Banane", 120);
Arrays.sort(f,new ComparateurNom() );
for (int i=0;i< f.length;i++) {
Fruit ff=f[i];
System.out.println(ff);
}

}}
Exercice 1
 Définir une interface nommée Convertible avec une méthode double convertTo(String targetType)
qui prend en paramètre une chaîne de caractères représentant l'échelle cible de la conversion.
 Implémenter une classe Temperature qui représente une température avec une valeur et une
échelle (Celsius ou Fahrenheit). La classe Temperature doit implémenter l'interface Convertible.
 Dans la classe Temperature, fournir une méthode convertTo(String targetType) qui convertit la
température actuelle en fonction de l'échelle cible spécifiée (Celsius ou Fahrenheit).
 Écrire une classe Main qui teste la conversion de température en créant une instance de
Temperature avec une valeur initiale et une échelle, puis en effectuant des conversions entre
Celsius et Fahrenheit.
 Celsius Fahrenheit: (température* 9 / 5) + 32
 Fahrenheit Celsius: (température - 32) * 5 / 9
Solution
public interface Convertible {
double convertTo(String targetType);
}
public class Temperature implements
Convertible {
private double value;
private String scale;

public Temperature(double value, String scale)


{
this.value = value;
this.scale = scale;
}
public double getValue() @Override
{ public double convertTo(String targetType) {
return value; if (scale.equals("Celsius") && targetType.equals("Fahrenheit"))
} {
public String getScale() return (value * 9 / 5) + 32;
{ }
return scale; else
} if (scale.equals("Fahrenheit") && targetType.equals("Celsius"))
{
return (value - 32) * 5 / 9;
}
else
return Double.NaN;
}}
public class Main {
public static void main(String[] args) {
Temperature tempCelsius = new Temperature(25, "Celsius");
System.out.println("Température en Celsius : " + tempCelsius.getValue());

// Conversion de Celsius en Fahrenheit


double tempFahrenheit = tempCelsius.convertTo("Fahrenheit");
System.out.println("Température en Fahrenheit : " + tempFahrenheit);

// Conversion de Fahrenheit en Celsius


double tempCelsius2 = tempCelsius.convertTo("Celsius");
System.out.println("Température en Celsius : " + tempCelsius2);
// Conversion de Fahrenheit en Celsius
Temperature tempFah = new Temperature(77, "Fahrenheit");
System.out.println("Température en Celsius : " + tempFah.convertTo("Celsius"));
}
}
Exercice 2
On désire créer une représentation simple de fonctions mathématiques en utilisant des interfaces et des classes
en Java.
1. Définir une interface MathFunction avec une méthode evaluate(double x) qui prend un paramètre x et
retourne le résultat de l'évaluation de la fonction à ce point.
2. Implémenter deux classes : LinearFunction et QuadraticFunction, qui représentent respectivement des
fonctions linéaires et quadratiques. Chaque classe doit implémenter l'interface MathFunction.
3. La classe LinearFunction doit avoir deux attributs : le coefficient de pente (slope) et l'ordonnée à l'origine
(intercept). Elle doit fournir une implémentation de la méthode evaluate(double x) qui évalue la fonction
linéaire selon la formule y = slope * x + intercept. (n’oubliez pas le constructeur)
4. La classe QuadraticFunction doit avoir trois attributs : les coefficients a, b et c de la forme quadratique
ax^2 + bx + c. Elle doit fournir une implémentation de la méthode evaluate(double x) qui évalue la fonction
quadratique selon la formule y = ax^2 + bx + c. (n’oubliez pas le constructeur)
5. Dans la méthode main, créer des instances de LinearFunction et QuadraticFunction, et les évaluer à
différentes valeurs de x. Afficher le résultat de chaque évaluation.

Vous aimerez peut-être aussi