C. Recanati
InHM Java 
Master 1, 2012

TP 2

Exercice 1 Le but de cet exercice est de créer l’architecture nécessaire pour la mise en place d’un logiciel de dessin intitulé « Sketcher »  (pour croquis). Nous l’implanterons au fur et à mesure des TP. 
1) Reprendre les lignes de code données dans le cours (pp. 100 et 103) pour commencer l’implémentation  du logiciel Sketcher en définissant l’interface Constants dans un fichier séparé. 

Architecture : on prévoit une classe SketcherFrame (ou Cadre du croquis) qui introduira les éléments nécessaires à la gestion de la fenêtre dans laquelle sera affiché le croquis, et une classe SketcherModel (ou Modèle de croquis) qui définira les éléments nécessaires à la gestion du modèle de données de la feuille de dessin. L’application elle-même sera implémentée par une classe autonome appelée Sketcher. Chaque classe sera définie dans un fichier séparé.

2) Aujourd’hui le cadre SketcherFrame ne sera utilisé que pour mémoriser le titre de la fenêtre et le type de l’élément courant à dessiner. Cette classe aura donc trois membres (privés) : un membre elementType de type int, un membre elementColor de type Color, et un membre title de type String. Ecrire les différents membres de cette classe, et utiliser l’interface Constants pour en initialiser les valeurs (avec les constantes par défaut). Ecrire également un constructeur de la classe qui initialise  le champ title.

3) Ecrire le squelette de la classe d’application Sketcher. On fera un constructeur avec un argument de type String qui utilisera le constructeur à un argument de type String de la classe SketcherModel. La classe de l’application sera instanciée dans le main par un new. Une instance « mémorisera » dans deux variables privées, une instance de la classe du Cadre et une instance de la classe du Modèle.

4) Ecrire le squelette de la classe SketcherModel. Le modèle d’un dessin sera implémenté avec une liste chaînée de type LinkedList intilulée ListeElements et aura une méthode add et une méthode remove. La méthode add permet d’ajouter un élément à la liste, et la méthode remove retourne un booléen indiquant si l’élément existait dans la liste et s’il a pu en être retiré.

Exercice 2 (suite): On va définir une classe abstraite Element, et ses sous-classes internes qui seront des classes (statiques) implémentées (une sous-classe Ligne, une sous-classe Rectangle, etc.). Ces classes d’éléments (Ligne, Rectangle, etc.) -  seront définies dans la classe abstraite Element comme classes internes, et accessibles dans le code par l’opérateur point « . ». On aura ainsi accès à la classe Ligne en écrivant Element.Ligne, et à la classe Rectangle avec Element.Rectangle. 

Les constructeurs de ces classes d’éléments prendront 3 arguments : un début et une fin (de type Point) pour positionner la forme, et un argument couleur (de type Color). Ces constructeurs « mémoriseront » la forme créée dans un membre privé ayant un type spécifique (ex : Line2D.Double line pour une Ligne). Un objet de type Shape pourra néanmoins ensuite être retourné par l’accesseur getShape(), en castant la valeur de ce champ privé (car tous ces types de awt peuvent être subsumés par le type Shape de Swing).

// Element.java
import java.awt.*;
import java.awt.geom.*;

public abstract class Element {

    protected Color color;	// un élément a tjs une couleur
    
    public Element(Color color) {
        this.color = color;
    }
    
    public Color getColor() {
        return color;
    }
    	// un élément a une forme récupérable par getShape() :
    public abstract Shape getShape(); 
	// un élément a aussi un plus petit rectangle englobant 
	// récupérable par getBounds() :
    public abstract java.awt.Rectangle getBounds(); 
	// + une méthode modify pour positionner l’élément :
    public abstract void modify(Point debut, Point fin);

	// on définit ici une sous-classe « concrète » de Element
	// la sous-classe Ligne, accessible par Element.Ligne    
    public static class Ligne extends Element {
        
        private Line2D.Double  ligne;	// ça sera sa forme (Shape)
        
        public Ligne(Point debut, Point fin, Color couleur){
            super(couleur);
            ligne = new Line2D.Double(debut, fin);
        }
        
        public Shape getShape() {
            return ligne;
        }
        
        public java.awt.Rectangle getBounds() {
            return ligne.getBounds();
        }
        
        public void modify(Point debut, Point fin) {
            ligne.x1 = debut.x;
            ligne.y1 = debut.y;
            ligne.x2 = fin.x;
            ligne.y2 = fin.y;
        }
        
    }
	//  vient ensuite le code implémentant Element.Rectangle
	// etc. pour tous les types d’élements de dessin prévus
}

Commentaire : la classe abstraite Element inclut un membre de type Color (avec un accesseur getColor() et un constructeur qui initialise ce membre) et déclare des méthodes abstract getShape() et abstract getBounds() retournant respectivement la forme correspondant à l’élément  (un rectangle, cercle, etc.) et son rectangle englobant. Le rectangle retourné par getBounds servira lors de l’affichage d’un élément, à définir la zone impliquée dans l’affichage. 

1) Implémentez la sous-classe Element.Rectangle en vous inspirant du code de Element.Ligne.

// Eléments de correction pour SketcherFrame.java
public class SketcherFrame implements Constants {
	// type et couleur de l'element courant  
	private int elementType = ...;
	private Color elementColor = ... ;
	// titre de la fenetre
	private String title ;

// constructeur
	public SketcherFrame(String  titre) {
		...
	}
}

//  squelette de Sketcher.java  
public class Sketcher {
	private SketcherModel model;
	private static SketcherFrame window;
	private static Sketcher  theApp; 
	
	public SketcherFrame getWindow() {
		return window;
	}
	public SketcherModel getModel() {
		return model;
	}
	public void init() {
		window = new SketcherFrame("Dessin");
		model = new SketcherModel() ;
	}
	public static void main(String[] args) {
		theApp = new Sketcher();
		theApp.init();
	}
}

//  squelette de SketcherModel.java  
class SketcherModel {
	protected LinkedList ListeElements = new LinkedList();
        
        public boolean remove(Element element) {
boolean removed = 
ListeElements.remove(element);
            	return removed;
        }    
        public void add(Element element) {
            ListeElements.add(element);
        }
}