Object-Oriented Design & Patterns

Cay S. Horstmann

Chapitre 6

Héritage et classes abstraites

Matière du chapitre

• Le concept d'héritage
  
• Programmation graphique avec l'héritage
  
• Classes abstraites
• Le patron TEMPLATE METHOD
• Interfaces protégées
  
• La hiérarchie des composants Swing
• La hiérarchie des formes géométriques standards
  
• La hiérarchie des classes d'exception
• Quand ne pas utiliser l'héritage
  

Représenter la spécialisation

• Commencer avec la simple classe Employee
  public class Employee
  {
     public Employee(String aName) { name = aName; }
     public void setSalary(double aSalary) { salary = aSalary; }
     public String getName() { return name; }
     public double getSalary() { return salary; }
  
     private String name;
     private double salary;
  }
• Manager est une sous classe

Représenter la spécialisation

• La classe Manager ajoute une nouvelle méthode : setBonus
• La classe Manager redéfinit une méthode existante : getSalary
• Ajoute le salaire et le bonus
  
• public class Manager extends Employee
  {
     public Manager(String aName) { ... }
     public void setBonus(double aBonus) { bonus = aBonus; } // new method
     public double getSalary() { ... } // overrides Employee method
  
     private double bonus; // new field
  }

Représenter la spécialisation

Méthodes et attributs de Manager

• méthodes setSalary, getname (héritées d'Employee)
• méthodes getSalary (redéfinie dans Manager)
• méthode setBonus (définie dans Manager)
• attributs name et salary (définis dans Employee)
• attribut bonus (défini dans Manager)
  

La terminologie Super/Sous

• Pourquoi Manager est une sous classe?
• Le Manager est supérieur, n'est-ce pas?
• L'objet Manager a plus d'attributs, n'est-ce pas?
• L'ensemble des managers est un sous ensemble de l'ensemble des employés

La terminologie Super/Sous

Hiérarchies d'héritage

• Monde réel : Les hiérarchies décrivent des relations générale/spécifique
  • Le concept général est la racine de l'arbre
  • Les concepts plus spécifiques sont les enfants
• En programmation: hiérarchie d'héritage
  • La superclasse générale est la racine de l'arbre
  • Les sous classes plus spécifiques sont les enfants

Hiérarchies d'héritage

Principe de substitution

• Formulé par Barbara Liskov
• On peut utiliser une sous classe partout où une superclasse est attendue
• Exemple:
  Employee e;
  ...
  System.out.println("salary=" + e.getSalary());
• On peut établir e comme une référence à un Manager
• Polymorphisme : La bonne méthode getSalary est invoquée

Invoquer les méthodes d'une superclasse

• On ne peut pas accéder aux attributs privés d'une superclasse
  public class Manager extends Employee
  {
     public double getSalary()
     {
        return salary + bonus;  // ERROR--private field
     }
     ...
  }
• Soyez prudent lorsque vous appelez une méthode d'une superclasse
     public double getSalary()
     {
        return getSalary() + bonus;  // ERROR--recursive call
     }
  

Invoquer les méthodes d'une superclasse

• Utiliser le mot réservé super
     public double getSalary()
     {
        return super.getSalary() + bonus; 
     }
• super n'est pas une référence
• super empêche l'appel polymorphique
  

Invoquer le construction d'une superclasse

• Utiliser le mot réservé super dans le constructeur de la sous classe :
  public Manager(String aName)
  {
     super(aName); // calls superclass constructor
     bonus = 0;
  }
  
• L'appel à super doit être la première instruction dans le constructeur de la sous classe
• Si le constructeur de la sous classe n'appelle pas super, la superclasse doit avoir un constructeur sans paramètre

Pré-conditions

• Une pré-condition d'une méthode redéfinie est aussi forte ou plus faible

• public class Employee
  {
     /**
        Sets the employee salary to a given value. 
        @param aSalary the new salary 
        @precondition aSalary > 0 
     */ 
     public void setSalary(double aSalary) { ... }
  }
  

• Peut-on redéfinir Manager.setSalary avec une pré-condition
  salary > 100000?
• Non -- Elle pourrait être défaite :
  

  Manager m = new Manager();
  Employee e = m;
  e.setSalary(50000);

Post-conditions, visibilité, exceptions

• La post-condition d'une méthode redéfinie est aussi forte ou plus forte
• Exemple: Employee.setSalary promet de ne pas diminuer le salaire
• Alors Then Manager.setSalary doit respecter la post-condition
  
• Une méthode redéfinie ne pas pas est plus private.
  (Erreur commune : oublier public quand on redéfinie)
• Une méthode redéfinie ne peut pas lever plus d'exceptions

Programmation graphique avec l'héritage

• Chapitre 4: Créer des dessins en implémentant le type interface Icon
• Maintenant : Créer une sous classe de JComponent
  public class MyComponent extends JComponent
  {
     public void paintComponent(Graphics g)
     {
        drawing instructions go here
     }
     ...
  }
• Avantage : Hériter des comportements de JComponent
• Exemple: On peut attacher un observateur de souris (« mouse listener ») à un JComponent

Observateurs de souris (« Mouse Listeners »)

• Attacher un « mouse listener » à un composant
• On peut capter les évènements provenant de la souris (clique, déplacement)
  

  public interface MouseListener 
  { 
     void mouseClicked(MouseEvent event); 
     void mousePressed(MouseEvent event); 
     void mouseReleased(MouseEvent event); 
     void mouseEntered(MouseEvent event); 
     void mouseExited(MouseEvent event); 
  }
   
  public interface MouseMotionListener 
  { 
     void mouseMoved(MouseEvent event); 
     void mouseDragged(MouseEvent event); 
  } 
  

Adaptateurs de souris « Mouse Adapters  »

• Et si vous vouliez seulement capter mousePressed?
• Étendre MouseAdapter
  

  public class MouseAdapter implements MouseListener
  { 
     public void mouseClicked(MouseEvent event) {} 
     public void mousePressed(MouseEvent event) {}
     public void mouseReleased(MouseEvent event) {}
     public void mouseEntered(MouseEvent event) {} 
     public void mouseExited(MouseEvent event) {} 
  }
  

• Le constructeur du composant ajoute le « listener » :
  

  addMouseListener(new
     MouseAdapter()
     {
        public void mousePressed(MouseEvent event) 
        {
           mouse action goes here
        }
     });

Programme déplaçant une voiture

• Utiliser la souris pour déplacer la forme d'une voiture
• Le panneau de la voiture a un « mouse listener » et un « mouse motion listener »
• mousePressed retient les coordonnées où la souris a été enfoncée
• mouseDragged déplace la forme de la voiture
• Ch6/car/CarComponent.java
• Ch6/car/CarMover.java
• Ch6/car/CarShape.java

Programme déplaçant une voiture

Rédacteur de scène

• Dessine des formes variées
• L'usager peut ajouter, supprimer et déplacer les formes
• L'usager sélectionne la forme avec la souris
• La forme sélectionnée est mise en surbrillance

Rédacteur de scène

Le type interface SceneShape

• Suivre l'état de la sélection
• Dessine une nouvelle forme ou la forme sélectionnée
• Déplace la forme
• Critère pour sélectionner : est-ce qu'un point (position de souris) est dedans ?

Type interface SceneShape

Type interface SceneShape

Classes CarShape et HouseShape

public class CarShape implements SceneShape 
{ 
   ... 
   public void setSelected(boolean b) { selected = b; } 
   public boolean isSelected() { return selected; }
   private boolean selected; 
} 

public class HouseShape implements SceneShape
{ 
   ... 
   public void setSelected(boolean b) { selected = b; } 
   public boolean isSelected() { return selected; }
   private boolean selected; 
}

Classes abstraites

• Factorise les comportements communs
  (setSelected, isSelected)
• Les sous classes héritent du comportement commun
• Quelques méthodes ne sont pas définies
  (draw, drawSelection, translate, contains)

public class SelectableShape implements Item 
{ 
   public void setSelected(boolean b) { selected = b; } 
   public boolean isSelected() { return selected; }
   private boolean selected; 
}

Classes abstraites

Classes abstraites

• SelectableShape  ne définit pas toute les méthodes de SceneShape
• Elle est abstraite
• public abstract class SelectableShape implements SceneShape
• HouseShape et CarShape sont concrètes
• On ne peut pas instancier une classe abstraite :
  

  SelectableShape s = new SelectableShape(); // NO
  

• On peut avoir des variables ayant comme type une classe abstraite :
  

  SelectableShape s = new HouseShape(); // OK

Classes abstraites et type interface

• Les classes abstraites peuvent avoir des attributs
• Les types interface peuvent avoir seulement des constantes (public static final)
• Les classes abstraites peuvent définir des méthodes
• Les types interface peuvent seulement déclarer des méthodes
• Une classe implémente un nombre quelconque de types interface
• Dans Java, une classe peut étendre une seule autre classe

Rédacteur de scène

• Le « mouse listener » sélectionne/relâche une forme
• Le « mouse motion listener » déplace une forme
• Le bouton-supprime supprime les formes sélectionnées
• Ch6/scene1/SceneComponent.java
• Ch6/scene1/SceneEditor.java
• Ch6/scene1/HouseShape.java

Technique de surbrillance uniforme

• Technique originale : chaque forme se dessine selon son état de sélection
• Incommode
• Meilleure technique : déplacer, dessiner, déplacer, dessiner, placer à la position originale
  
• Définir dans SelectableShape
  public void drawSelection(Graphics2D g2)
  {
     translate(1, 1);
     draw(g2);
     translate(1, 1);
     draw(g2);
     translate(-2, -2);
  }

Technique de surbrillance uniforme

Méthode modèle

• drawSelection appelle draw
• On doit déclarer draw dans SelectableShape
• Pas d'implémentation à ce niveau !
• Déclarer comme une méthode abstraite
  public abstract void draw(Graphics2D g2)
• Définie dans CarShape, HouseShape
• La méthode drawSelection appelle draw, translate
• drawSelection ne connaît pas quelles méthodes -- polymorphisme
• drawSelection est une méthode modèle (template method)
• Ch6/scene2/SelectableShape.java
• Ch6/scene2/HouseShape.java

Patron TEMPLATE METHOD

Contexte

1. Un algorithme est applicable pour plusieurs types.
2. L'algorithme peut être divisé en plusieurs opérations primitives. Les opérations primitives peuvent être différentes pour chaque type
3. L'ordre des opérations primitives ne dépend pas du type

Patron TEMPLATE METHOD

Solution

1. Définir une superclasse qui a une méthode pour l'algorithme et des méthodes abstraites pour les opérations primitives.
2. Implémenter l'algorithme en appelant les opérations primitives dans l'ordre approprié.
3. Ne pas définir les opérations primitives dans la superclasse ou bien, les définir pour avoir un comportement par défaut approprié.
4. Chaque sous classe définit les opérations primitives mais pas l'algorithme.

Patron TEMPLATE METHOD

Patron TEMPLATE METHOD

Formes composées

• GeneralPath: séquence de formes
  

  GeneralPath path = new GeneralPath(); 
  path.append(new Rectangle(...), false); 
  path.append(new Triangle(...), false); 
  g2.draw(path); 

• Avantage : Facile de vérifier si la séquence de formes contient un point
  path.contains(aPoint);
• Ch6/scene3/CompoundShape.java
• Ch6/scene3/HouseShape.java

Formes composées

Accès aux éléments d'une superclasse

• Pourquoi le constructeur de HouseShape appelle add ?
  

  public HouseShape()
  {
     add(new Rectangle(...));
     add(new Triangle(...));
  }
  

• Pourquoi ne pas faire seulement
  path.append(new Rectangle(...));
• HouseShape hérite de l'attribut path
• HouseShape ne peut pas accéder à path
• path est privé à la superclasse

Accès protégé

• Faire de CompoundShape.add une méthode protégée
• Protège HouseShape : les autres classes ne peuvent pas ajouter des graffitis
• Les éléments protégés peuvent être accédés par les méthodes des sous classes...
• ...et par les méthodes situées dans le même paquetage
• Mauvaise idée de protéger les attributs
  protected GeneralPath path; // DON'T
• Mais ça va pour les méthodes
  protected void add(Shape s) // GOOD
• Interface protégée séparée de l'interface publique

Hiérarchie des composants de Swing

• Base de la hiérarchie : Component
• Un nombre important de méthodes communes :
  

  int getWidth()
  int getHeight()
  Dimension getPreferredSize()
  void setBackground(Color c)
  . . .

• La sous classe la plus importante : Container

Hiérarchie des composants de Swing

Hiérarchie des composants de Swing

• Historique : AWT fut le premier, Abstract Window Toolkit
• Utilisait les composants natifs
• Il y avait des incohérences subtiles entre les plateformes
• Écrire une fois, exécuter partout ->
  Écrire une fois, déverminer partout
• Swing dessine les composants sur des fenêtres blanches
• Supporte de multiple implémentations de l'aspect et la convivialité (« look and feel »)

L'aspect et la convivialité (« look and feel »)

Hiérarchie des composants de Swing

• Base des composants Swing : JComponent
• Sous classe de Container
• Quelques composants Swing sont des containers
• Java n'a pas d'héritage multiple
• JLabel, JButton, ... sont des sous classes de JComponent
• Classes intermédiaires AbstractButton, JTextComponent

Hiérarchie des formes géométriques

• Première version de Java : peu de formes, coordonnées entières
  

  Point
  Rectangle
  Polygon

• Java 2: formes sophistiquées, coordonnées réelles
  

  Point2D
  Rectangle2D
  RoundRectangle2D
  Line2D
  Ellipse2D
  Arc2D
  QuadCurve2D
  CubicCurve2D
  GeneralPath
  Area

• Tous sauf Point2D implémentent le type interface Shape
  

Hiérarchie des formes géométriques

Formes rectangulaires

• Sous classes de RectangularShape:
  

  Rectangle2D
  RoundRectangle2D
  Ellipse2D
  Arc2D

• RectangularShape a des méthodes utiles
  

  getCenterX/getCenterY
  getMinX/getMinY
  getMaxX/getMaxY
  getWidth/getHeight
  setFrameFromCenter/setFrameFromDiagonal

Classes Float/Double

• Chaque classe a deux sous classes
  

  Rectangle2D.Double
  Rectangle2D.Float

• Ce sont des classes imbriquées (inner classes) !
  (Juste pour éviter des noms de classe trop longs)
• Les implémentations ont les attributs double/float
• La plupart des méthodes ont comme paramètres et valeur de retour un double

Classes Float/Double

Classes Float/Double

public class Rectangle2D 
{ 
   public static class Float extends Rectangle2D 
   { 
      public double getX() { return x; } 
      public double getY() { return y; }
      public double getWidth() { return width; }
      public double getHeight() { return height;} 
      public void setRect(float x, float y, float w, float h) 
      { 
         this.x = x; this.y = y; 
         this.width = w; this.height = h; 
      } 
      public void setRect(double x, double y, 
         double w, double h) 
      { 
         this.x = (float)x; this.y = (float)y; 
         this.width = (float)w; this.height = (float)h; 
      } 
      ... 
      public float x; 
      public float y; 
      public float width; 
      public float height; 
   } 
   . . .

Classes Float/Double

   . . .
   public static class Double extends Rectangle2D 
      public double getX() { return x; } 
      public double getY() { return y; }
      public double getWidth() { return width; }
      public double getHeight() { return height;} 
      public void setRect(double x, double y, 
         double w, double h) 
      { 
         this.x = x; this.y = y; 
         this.width = w; this.height = h; 
      } 
      ... 
      public double x; 
      public double y; 
      public double width; 
      public double height; 
   }
   ...
}

Float/Double Classes

• La classe Rectangle2D n'a pas de variables d'instance
• Le patron Template Method au travail :
  

  public boolean contains(double x, double y)
  {
     double x0 = getX();
     double y0 = getY();
     return x >= x0 && y >= y0 &&
        x < x0 + getWidth() &&
        y < y0 + getHeight();
  }
  

• Pas besoin d'utiliser une classe imbriquée après la construction
  Rectangle2D rect
     = new Rectangle2D.Double(5, 10, 20, 30);
  

Le pattern TEMPLATE METHOD

Hiérarchie des classes d'exception

• Base de la hiérarchie : Throwable
• Deux sous classes : Error, Exception
• Sous classes de Error : fatal
  (mémoire saturée, échec d'assertion)
• Sous classes de Exception :
  • Beaucoup d'exceptions vérifiées (« checked exceptions »)
    (I/O, class not found)
  • RuntimeException -- Ces sous classes ne sont pas vérifiées
    (null pointer, index out of bounds)

Hiérarchie des classes d'exception

Traiter les exceptions

• On peut avoir plusieurs clauses catch :
  

  try
  {
        code that may throw exceptions
  }
  catch (ExceptionType1 exception1)
  {
     handler for ExceptionType1
  }
  catch (ExceptionType2 exception1)
  {
     handler for ExceptionType2
  }
  . . .
      

• On peut la traiter dans la superclasse:
  catch (IOException exception)
  traite FileNotFoundException

Définir des classes d'exception

• Décider que l'exception devrait être vérifiée
• Sous classe de Exception ou de RuntimeException
• Définir deux constructeurs
  

  public class IllegalFormatException extends Exception
  { 
     public IllegalFormatException() {} 
     public IllegalFormatException(String reason) 
     { super(reason); } 
  }

• Lever l'exception lorsque nécessaire :
  throw new IllegalFormatException("number expected");

Quand ne pas utiliser l'héritage

• Provenant d'un tutoriel pour un compilateur C++ :

public class Point 
{ 
   public Point(int anX, int aY) { ... } 
   public void translate(int dx, int dy) { ... } 
   private int x; 
   private int y; 
} 

public class Circle extends Point // DON'T 
{ 
   public Circle(Point center, int radius) { ... } 
   public void draw(Graphics g) { ... } 
   private int radius; 
}

Quand ne pas utiliser l'héritage

• Hein ?  Un cercle n'est pas un point!
• Par accident, la méthode héritée translate fonctionne pour les cercles
• Le même tutoriel propose un Rectangle comme une sous classe de Point:
  

  public class Rectangle extends Point // DON'T 
  {
     public Rectangle(Point corner1, Point corner2) { ... } 
     public void draw(Graphics g) { ... } 
     public void translate(int dx, int dy) { ... } 
     private Point other; 
  }

Quand ne pas utiliser l'héritage

• Ceci est encore plus bizarre :
  

  public void translate(int dx, int dy)
  {
     super.translate(dx, dy);
     other.translate(dx, dy);
  }
  

• Pourquoi ont-ils fait ça ?
• Ils voulaient éviter la classe abstraite Shape
• Solution : utiliser l'agrégation.
• Les classes Cercle et Rectanble ont des points

Quand ne pas utiliser l'héritage

• Librairie standard Java :
  

  public class Stack<T> extends Vector<T> // DON'T
  {
     T pop() { ... }
     void push(T item) { ... }
     ...
  }

• Mauvaise idée : Hérite de toutes les méthodes de Vector
• On peut insérer et supprimer au milieu d'une pile
• Solution : utiliser l'agrégation
  

  public class Stack<T>
  {
     ...
     private ArrayList<T> elements;
  }