Programmation Orientée Objet – Java Rappel : Les objets et les

Programmation Orientée Objet – Java
Bertrand Estellon
Département Informatique et Interactions
Aix-Marseille Université
21 septembre 2016
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 1 / 171
Java Interfaces et polymorphisme
Rappel : Les objets et les classes
Un objet :
▶peut être construit
▶est structuré : il est constitué d’un ensemble de propriétés
▶possède un état : la valeur de ses propriétés
▶possède une interface : l’ensemble des méthodes et propriétés
accessibles par les utilisateurs de l’objet
Dans les langages orientés objet, une classe (d’objets) dénit :
▶une façon de construire des objets (constructeur)
▶la structure des objets de la classe (propriétés)
▶le comportement des objets de la classe (méthodes)
▶l’interface des objets de la classe (méth. et prop. non-privées)
▶un type “référence vers des objets de cette classe”
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 66 / 171
Java Interfaces et polymorphisme
Abstraction
Supposons que des classes implémentent un service de façons diérentes :
class SimplePrinter {
void print(String document) {
System.out.println(document);
}
}
class BracePrinter {
void print(String document) {
System.out.println("{"+document+"}");
}
}
Toutes les instances de ces classes possèdent la méthode print.
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 67 / 171
Java Interfaces et polymorphisme
Abstraction
Nous souhaiterions pouvoir facilement passer du code suivant :
Printer printer =new SimplePrinter();
printer.print("truc"); // →"truc";
au code suivant :
Printer printer =new BracePrinter();
printer.print("truc"); // →"{truc}";
Il nous faudrait dénir un type Printer qui oblige la variable à contenir
des références vers des objets qui implémentent la méthode print.
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 68 / 171

Java Interfaces et polymorphisme
Abstraction
On peut vouloir traiter des objets en utilisant les services qu’ils partagent :
for (int index =0;index <printers.length;index++)
printers[index].print(document);
On peut aussi vouloir écrire un programme en supposant que les objets
manipulés implémentent certains services :
boolean isSorted(Comparable[] array) {
for (int i= 0; i<array.length - 1; i++)
if (array[i].compareTo(array[i+1]) > 0) return false;
return true;
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 69 / 171
Java Interfaces et polymorphisme
Description d’une interface
Description d’une interface en Java :
public interface Printer {
/**
* Affiche la chaine de caracteres document.
* @param document la chaine a afficher.
*/
public void print(String document);
}
Une interface :
▶peut contenir une ou plusieurs méthodes
▶est un contrat
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 70 / 171
Java Interfaces et polymorphisme
Implémentation d’une interface
implements permet d’indiquer qu’une classe implémente une interface :
class SimplePrinter implements Printer {
void print(String document) {
System.out.println(document);
}
}
class BracePrinter implements Printer {
void print(String document) {
System.out.println("{"+document+"}");
}
}
Java vérie que toutes les méthodes de l’interface sont implémentées.
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 71 / 171
Java Interfaces et polymorphisme
Références et interfaces
Déclaration d’une variable de type référence vers une instance d’une classe
qui implémente l’interface Printer :
Printer printer;
Il n’est pas possible d’instancier une interface :
Printer printer =new Printer(); // interdit !
printer.print("toto"); // que faire ici ?
Il est possible d’instancier une classe qui implémente une interface :
SimplePrinter simplePrinter =new SimplePrinter();
et de mettre la référence dans une variable de type Printer :
Printer printer1 =simplePrinter;// upcasting
Printer printer2 =new BracePrinter();
Printer string =new String("c")// interdit !
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 72 / 171

Java Interfaces et polymorphisme
Références et interfaces
Utilisation d’objets qui implémentent l’interface :
class Utils {
static void printString(Printer[] printers,String doc) {
for (unsigned int i=0;i<printers.length;i++)
printers[i].print(doc);
}
static void printArray(String[] array,Printer printer) {
for (unsigned int i=0;i<array.length;i++)
printer.print(array[i]);
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 73 / 171
Java Interfaces et polymorphisme
Polymorphisme
Vérication à la compilation de l’existance des méthodes :
Printer printer =new SimplePrinter();
printer.println("msg"); // impossible !
Le choix de la méthode à exécuter ne peut être fait qu’à l’exécution :
Printer[] printers =new Printer[2];
printers[0] = new SimplePrinter();
printers[1] = new BracePrinter();
Random random =new Random(); // générateur aléatoire
int index =random.nextInt(2); // 0 et 1
printers[index].print("mon message");
index=0 →méthode de la classe SimplePrinter →mon message
index=1 →méthode de la classe BracePrinter →{mon message}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 74 / 171
Java Interfaces et polymorphisme
Résumé
▶Une interface est un ensemble de signatures de méthodes.
▶Une classe peut implémenter une interface : elle doit préciser le
comportement de chacune des méthodes de l’interface.
▶Il est possible de déclarer une variable pouvant contenir des références
vers des instances de classes qui implémentent l’interface.
▶Java vérie à la compilation que toutes les aectations et les appels
de méthodes sont corrects.
▶Le choix du code qui va être exécuté est décidé à l’exécution (en
fonction de l’instance pointée par la référence).
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 75 / 171
Java Interfaces et polymorphisme
Implémentations multiples
interface Printable {
public void print();
}
La méthode print permet d’acher l’objet.
interface Stack {
public void push(int value);
public int pop();
}
La méthode push permet d’empiler un entier.
La méthode pop dépile et retourne l’entier en haut de la pile.
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 76 / 171

Java Interfaces et polymorphisme
Implémentations multiples
Implémentation des deux interfaces précédentes :
public class PrintableStack implements Stack,Printable {
private int[] array;private int size;
public PrintableStack(int capacity) {
array =new int[capacity]; size = 0;
}
public void push(int v){array[size]=v;size++; }
public int pop() { size--; return array[size]; }
public void print() {
for (int i=0;i<size;i++)
System.out.print(array[i]+" ");
System.out.println();
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 77 / 171
Java Interfaces et polymorphisme
Implémentations multiples
Implémentation d’une des deux interfaces :
public class PrintableString implements Printable {
private String string;
public PrintableString(String string) {
this.string =string;
}
public void print() {
System.out.println(string);
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 78 / 171
Java Interfaces et polymorphisme
Implémentations multiples
Exemple d’utilisation des classes précédentes :
Printable[] printables =new Printable[3];
printables[0] = new PrintableString("bonjour");
PrintableStack stack =new PrintableStack(10);
printables[1] = stack;
printables[2] = new PrintableString("salut");
stack.push(10);
stack.push(30);
System.out.println(stack.pop());
stack.push(12);
for (int i=0;i<printables.length;i++)
printables[i].print();
Qu’écrit ce programme sur la sortie standard ?
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 79 / 171
Java Interfaces et polymorphisme
Vérication des types
Vérication des types à la compilation :
Stack[] arrayStack =new Stack[2];
arrayStack[0] = new PrintableStack();
arrayStack[1] = new PrintableString("t"); // Erreur !
PrintableString n’implémente pas Stack.
Stack stack =new PrintableStack();
Printable printable =stack;// Erreur !
Le type Stack n’est pas compatible avec le type Printable.
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 80 / 171

Java Interfaces et polymorphisme
Exemple : Arbre binaire
public interface Node {
public String convertToString();
}
public class Leaf implements Node {
private String name;
public Leaf(String name) { this.name =name; }
@Override
public String convertToString() { return name; }
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 81 / 171
Java Interfaces et polymorphisme
Exemple : Arbre binaire
public class InternalNode implements Node {
private Node left,right;// Agrégation
public InternalNode(Node left,Node right) {
this.left =left;
this.right =right;
}
@Override
public String convertToString() {
return "(" +left.convertToString() + "," +
right.convertToString() + ")";
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 82 / 171
Java Interfaces et polymorphisme
Exemple : Arbre binaire
public class Exemple {
public static void main(String[] args) {
Node a =new Leaf("a");
Node b =new Leaf("b");
Node c =new Leaf("c");
Node d =new Leaf("d");
Node ab =new InternalNode(a,b);
Node cd =new InternalNode(c,d);
Node abcd =new InternalNode(ab,cd);
System.out.println(abcd.convertToString());
}
}
Qu’ache ce programme ?
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 83 / 171
Java Interfaces et polymorphisme
Exemple : Arbre binaire et Printer
public interface Node {
public void print(Printer printer);
}
public class Leaf implements Node {
private String name;
public Leaf(String name) { this.name =name; }
@Override
public void print(Printer printer) {
printer.print(name);
}
}
Bertrand Estellon (DII – AMU) Programmation Orientée Objet – Java 21 septembre 2016 84 / 171