Cours

Attention Generification

Le but de cet exercice est d'introduire des types paramétrés (generics) dans un code existant sans en changer la sémantique.

import java.util.List;

public class Pair {
  private final Object first;
  private final Object second;

  public Pair(Object first,Object second) {
    this.first=first;
    this.second=second;
  }
  public Object getFirst() {
    return first;
  }
  public Object getSecond() {
    return second;
  }
  public boolean isContained(List list) {
    return list.contains(this);
  }
  public static void main(String[] args) {
    Pair p1=new Pair("toto",3);
    Pair p2=new Pair(p1,"titi");

    Pair p3=(Pair)p2.getFirst();
    String s=(String)p3.getFirst();
    System.out.println(p3+" "+s);

    Pair p4;
    if (args.length==0)
      p4=p1;
    else
      p4=new Pair("titi","tutu");
  }
}
    

Ré-écrire l'ensemble du code de pour que la classe Pair soit transformé en Pair<U,V>.
Penser à :

• ajouter des < et > là où il faut
• enlever les casts non nécessaire
• ajouter les wilcards là où c'est nécessaire.

David Vincent les a vus

Dans le but d'écrire un logiciel de synthèse d'images par lancé de rayon. Nous avons défini les classes Facet qui représente une facette, Sphere qui représente une boule et Box qui représente une boite rectangulaire en 3D.
Ces classes implantent déjà toute une méthode double intersect(Ray ray) qui caclul si le rayon intersecte l'objet et si oui quelle est la distance entre l'origine du rayon et le point d'intersection. La classe Ray représente un rayon(basiquement un vecteur et un point d'origine).

• Ecrire le code du supertype commun RayObject aux classes Facet, Sphere et Box.
• Ecrire une classe Scene stockant les objets RayObject dans une liste.
  • La classe devra posséder la méthode add(RayObject) permettant d'ajouter un objet à la liste
  • Une scéne devra pouvoir être utiliser dans une boucle for-each

           public static void main(String[] args) {
             Scene scene=new Scene();
  		   scene.add(new Box(/*...*/));
  		   scene.add(new Facet(/*...*/));
  		   scene.add(new Sphere(/*...*/));
  
  		   for(RayObject object:scene)
               System.out.println(object);
          

• On veut ajouter à la classe Scene une méthode iterator(RayObjectVisitor visitor) permettant d'itérer sur un sous-ensemble choisi des objets stockés dans la scène
  L'interface RayObjectVisitor utilise le design-pattern visitor pour permettre un choix d'un objet en fonction de son type. Chaque méthode de l'interface renvoie vrai ou faux pour indiquer si l'objet doit ou non être itéré.
  • Ecrire l'interface RayObjectVisitor.
  • Indiquer ce que l'on doit modifier dans la hiérachie des objets RayObject pour que le visiteur marche, en fournissant le ou les codes correspondant.
  • Ecrire le code de méthode iterator(RayObjectVisitor visitor)
• On cherche maintenant à obtenir à partir de l'objet scène, une liste des objets triés en fonction de leur distance à l'origine d'un certain rayon.
  • Ecrire le comparateur qui permet de comparer deux RayObject en fonction d'un rayon donné au comparateur lors de sa construction.
  • Ecrire la méthode List intersectionList(Ray ray) dans la classe scéne, qui renvoie une liste triée d'objets RayObject en fonction de leur distance d'intersection avec le rayon ray.
• Expliquer en quoi l'implantation du comparateur pourrait être plus efficace. Ré-ecrire le code de intersectionList.

Reflection & Annotation

On souhaite définir une nouvelle annotation nommée ThreadSafe indiquant si un code est ou non thread-safe ainsi qu'une méthode permettant d'exécuter de façon sûre un code.

• Ecrire le code de l'annotation ThreadSafe. Cette annotation doit être visible par la machine virtuelle et disponible par réflexion. Elle ne peut être associée qu'à des méthodes.
  Exemple d'utilisation

           classe Example {
             @ThreadSafe(true)
             void tutu() {... }
  
             @ThreadSafe(false)
             void tutu() {... }
  
             @ThreadSafe void toto() {..} // équivalent à true
           }
          

  
  Pour la suite, on considérera une méthode comme thread-safe si
  1. Celle-ci possède l'annotation ThreadSafe
  2. Cette annotation à pour valeur vrai.
• Ecrire une classe Invoker possédant une méthode statique Object safeCall(Object target,String name, Object... args) qui permet d'appeler une méthode non statique de façon sûre :
  1. dans la classe de l'objet target
  2. de nom name
  3. ayant pour types d'arguments les classes des objets contenus dans args
  Si la méthode est thread-safe, safeCall appele la méthode sinon safeCall exécute le code dans une section critique protégé par un jeton sur l'objet target.
  Faire en sorte que l'on ne puisse pas créer d'instance de la classe Invoker.