Structuration du code en utilisant les classes abstraites et les interfaces

Objectifs À la fin de ce cours, vous serez capables de : Définir des classes abstraites Définir des méthodes abstraites Définir des interfaces Implémenter des interfaces

Superclasse abstraite Sous-classes concrètes Vue d'ensemble Une classe abstraite ne peut pas être instanciée. Les méthodes abstraites doivent être implémentées par des sous-classes. Les interfaces supportent plusieurs héritages. Superclasse abstraite InventoryItem Sous-classes concrètes Car Movie VCR

Définition des classes abstraites dans Java Utilisez le mot-clé abstract pour déclarer une classe abstraite. public abstract class InventoryItem { private float price; public boolean isRentable()… } public class Movie extends InventoryItem { private String title; public int getLength()… public class Vcr extends InventoryItem { private int serialNbr; public void setTimer()…

Méthode abstraite Une méthode abstraite est un placeholder d'implémentation. Les méthodes abstraites appartiennent à une classe abstraite. Elles doivent être redéfinies par une sous-classe concrète. Chaque sous-classe concrète peut implémenter différemment la méthode.

Définition des méthodes abstraites dans Java Utilisez le mot-clé abstract pour déclarer une méthode abstraite. Procure uniquement la signature de la méthode. La classe doit aussi être abstraite. En quoi est-ce utile ? public abstract class InventoryItem { public abstract boolean isRentable(); …

Interfaces Une interface équivaut à une classe totalement abstraite : Toutes ses méthodes sont abstraites. Toutes les variables sont public static final. Une interface recense un ensemble de méthodes pouvant être implémentées par d'autres classes, mais ne fournit aucun code de méthode. Une classe peut implémenter de nombreuses interfaces, mais ne peut étendre qu'une seule classe.

Exemples d'interfaces Les interfaces décrivent un aspect du comportement requis par des classes différentes. Par exemple, les classes qui peuvent être dirigées supportent l'interface « dirigeable » (steerable). Les classes ne doivent pas nécessairement être connexes. Non dirigeable Dirigeable

Définition d'une interface Utilisez le mot-clé interface Toutes les méthodes sont public abstract Toutes les variables sont public static final public interface Steerable { int MAXTURN = 45; void turnLeft(int deg); void turnRight(int deg); }

Implémentation d'une interface Utilisez le mot-clé implements public class Yacht extends Boat implements Steerable public void turnLeft(int deg) {…} public void turnRight(int deg) {…} }

Sort (Tri) : exemple réel Utilisé par un certain nombre de classes non connexes Contient un ensemble connu de méthodes Requis pour trier tout type d'objet Les règles de comparaison sont connues uniquement pour l'objet à trier Bonne réutilisation du code

Vue d'ensemble des classes Créées par l'expert Sort public interface Sortable public abstract class Sort Créées par l'expert Movie public class Movie implements Sortable public class MyApplication

Mode de fonctionnement de Sort MyApplication MyApplication passe un array de Movies à Sort.sortObjects() sortObjects() renvoie la liste triée 4 1 Sort 3 2 sortObjects() demande à un Movie de se comparer avec un autre Movie Movie renvoie le résultat de la comparaison Movie

L'interface Sortable Spécifie la méthode compare() public interface Sortable { // compare(): Compare this object to another object // Returns: // 0 if this object is equal to obj2 // a value < 0 if this object < obj2 // a value > 0 if this object > obj2 int compare(Object obj2); }

La classe Sort Maintient sortObjects() public abstract class Sort { public static void sortObjects(Sortable[] items) { // Step through the array comparing and swapping; // do this length-1 times for (int i = 1; i < items.length; i++) { for (int j = 0; j < items.length - 1; j++) { if (items[j].compare(items[j+1]) > 0) { Sortable tempitem = items[j+1]; items[j+1] = items[j]; items[j] = tempitem; } } } } }

La classe Movie Implémente Sortable public class Movie extends InventoryItem implements Sortable { String title; public int compare(Object movie2) { String title1 = this.title; String title2 = ((Movie)movie2).getTitle(); return(title1.compareTo(title2)); }

Utilisation de Sort Appelle Sort.sortObjects(Sortable []) avec un array de Movie comme clause class myApplication { Movie[] movielist; … // build the array of Movie Sort.sortObjects(movielist); }

Utilisation de instanceof avec des interfaces Utilisez l'opérateur instanceof pour vérifier si un objet implémente une interface. Effectuez une conversion pour appeler les méthodes définies dans l'interface. public void aMethod(Object obj) { … if (obj instanceof Sortable) ((Sortable)obj).compare(obj2); }

Résumé Durant ce cours, vous devriez avoir retenu que : Une classe abstraite ne peut pas être instanciée. Une méthode abstraite possède une signature, mais pas de code. Une interface est une collection de méthodes abstraites devant être implémentées ailleurs. Une classe peut implémenter de nombreuses interfaces. L'implémentation de plusieurs interfaces est comparable à l'héritage multiple.