Programmation orientée objet

TP 4

Interfaces et polymorphisme

Un peu plus de Java...

Types de relations entre classes

• Une interface est un cas particulier d’une classe qui ne peut contenir que des constantes et des signatures de méthodes.
• Il n’y a pas de niveau de protection à préciser :
  • Les constantes sont implicitement public static final
  • Les méthodes sont implicitement public
• Elle ne peut être qu’implémentée par des classes ou étendue par d’autres interfaces.
• En Java, une classe ne peut hériter que d’une autre classe mais peut implémenter plusieurs interfaces. De ce fait, un objet peut avoir plusieurs types : le type de sa classe et les types des interfaces que cette classe implémente.
• http://java.sun.com/docs/books/tutorial/java/IandI/createinterface.html

public interface MyInterface extends Interface1, Interface2 {
    double E = 2.718282;
    void doSomething (int i, double x);
    int doSomethingElse(String s);
}
public class MyClass implements MyInterface {
    public void doSomething(int i ,double x) {
        [...]
    }
    public int doSomethingElse(String s) {
        [...]
    }
    public static void main(String args[]) {
        MyInterface m = new MyClass(); //Interface utilisée comme type
        m.doSomething(4,2.1);
    }
}

• Le polymorphisme est un concept OO dont l’idée est d'autoriser le même code à être utilisé avec différents types, ce qui permet des implémentations plus abstraites et générales.
• Vous l’avez utilisé implicitement dans l’exercice précédent (TP3 2e partie) lorsque vous avez parcouru les formes d’une illustration :

ArrayList<Form> formList = new ArrayList<Form>();
formList.add(new Square(aPoint, 10));
formList.add(new Line(aPoint, anotherPoint));
[...]
foreach(Form f : formList) {
    f.doSomething(); // Appel polymorphique
}

• Une classe abstraite ne peut être instanciée mais peut être sous-classée. Elle peut contenir ou non des méthodes abstraites.
• Une méthode abstraite est une méthode déclarée mais non implémentée.
• Si une classe inclut des méthodes abstraites elle doit être abstraite.
• Une classe qui hérite d’une classe abstraite doit implémenter toutes les méthodes abstraites de la classe parente ou être elle-même abstraite.

public abstract class AnAbstractClass{
    private int aFied;
    [...]
    public void doSomething(){ [...] }
    public abstract void doAnotherThing();
}

• En Java, un objet peut être casté en un autre objet (typecasting ou transtypage) :
  • soit en un objet d’une sous-classe (downcasting)
  • soit en un objet d’une super-classe (upcasting)
• Une erreur de compilation aura lieu dans le cas d’un transtypage impossible (entre objets non liés par héritage, comme par exemple deux frères).
• Une exception sera déclenchée lors de l’exécution si l’objet casté n’est pas compatible avec le type dans lequel il a été casté.
• L’upcasting est automatique. Le downcasting nécessite un opérateur :

Person p = new Assistant([...]);
[...]
Assistant a = (Assistant)p;

• Une méthode qui redéfini une méthode d’une super-classe peut uniquement déclencher les exceptions prévues dans la méthode de la super-classe.
• Elle ne peut pas déclencher d’exception d’un type non compatible.

public class A {
    public A() {
        [...]
    }
}
public class B extends A {
    public B(){
        [...]
    }
}
public class C extends B {
    public C(){
        [...]
    }
}

Lors de la construction d’un objet de la classe C :

• le constructeur de C commence par appeler le construteur de B
  • le constructeur de B commence par appeler le constructeur de A
    • le constructeur de A appelle le constructeur d’Object
      • le constructeur d’Object s’exécute
    • le constructeur de A se termine
  • le constructeur de B se termine
• le constructeur de C se termine

• En Java, quand un objet n’est plus référencé, il est détruit par un ramasse-miettes ou garbage collector.
• Il ne faut donc pas utiliser l’instruction delete pour libérer la mémoire comme en C++.
• Avant la destruction d’un objet, sa méthode void finalize() est appellée.
• Cette méthode est souvent utilisée quand on utilise des ressources « non-Java » comme des fichiers ou un réseau et qu’il faut libérer ces ressources.
• Lorsque le garbage collector détruit C :
  • le finalize de C (ou le plus proche de C en montant la hiérarchie) est appellé
  • la mémoire est libérée

• Une bonne pratique est d’utiliser try-catch-finaly dans les finalize pour être certain de ne pas oublier de fermer les ressources réservées par les super-classes.

protected void finalize() throws Throwable {
    try {
    close(); // close open files
    } finally {
        super.finalize();
    }
}

• Si une exception est déclenchée dans un finalize, la finalisation est arretée mais l’exception est ignorée.
• finalize() n'est jamais appellé qu’une fois sur un objet.

• Une association est une relation sémantique entre des classes qui définit un ensemble de liens.
• Une agrégation est une association dans laquelle il y a un lien d’appartenance entre les deux objets associés (contenant/contenu, possession, ...).
  • Une agrégation est dite faible si l'objet référencé existe indépendamment de l'objet référent.
  • Une agrégation est dite forte si l'objet référencé n'existe que tant que le contenant existe. L'agrégation forte est aussi appelée composition.
  • Il s'agit d'une nuance sémantique : l'intention est différente et il faudra adapter le code pour le refléter.

• Dans un modèle OO où la classe Personne peut représenter la notion de mariage, quelle est la nature de la relation entre Personne et elle-même ? Entre une personne et son compte en banque ?
• Dans l'exercice Illustration du TP précédent, quelle est la nature de la relation entre Forme et Rectangle ? Entre Illustration et Forme ? Entre Forme et Point ?
• Sachant comment fonctionne le garbage collector, quelle différence voyez vous entre l’implémentation d’une agrégation et celle d’une composition ?