07-GraphischeObjekte Graphische Objekte in EMMA301Paint

07-GraphischeObjekte2 Interface vs. abstrakte Klassen Eigenschaften von Interfacen: Interface enthalten nur die Schnittstellen und keine Implementierungen. Nutzer des Interfaces werden nicht durch Änderungen der Implementierung betroffen. In Interfacen können nur public Methoden und public final Attribute definiert werden. In Interfacen können keine Konstruktoren definiert werden. Erweiterung des Interfaces macht den ganzen abgeleiteten Baum unbrauchbar, da die Erweiterung erst implementiert werden muss. Interface können keine anderen Interface implementieren. Z.B. möchte man, dass alle abgeleiteten Klassen das Interface Serializable implementieren.

07-GraphischeObjekte3 Eigenschaften abstrakter Klassen: Abstrakte Klassen können Implementierungen enthalten. In abstrakten Klassen können beliebige Zugriffsrechte benutzt werden. Es können beliebige Attribute definiert werden. Es können Konstruktoren definiert werden. Es können Interface implementiert werden (z.B. Serializable).

07-GraphischeObjekte4 Interface + abstrakte Klasse Die Vorteile von Interfacen und abstrakten Klassen können kombiniert werden: In einem Interface werden die Schnittstellen und Konstanten definiert, die vom Anwender verwendet werden sollen. In einer abstrakten Klasse, die das Interface implementiert, werden ggf. zusätzliche Attribute, Konstruktoren, Methoden und Klassen definiert und ggf. implementiert, die nicht im Interface enthalten sein können bzw. sollen. Außerdem werden alle Interface angegeben, die implementiert von allen abgeleiteten Klassen implementiert werden sollen (z.B. Serializable, Cloneable u.s.w.) Damit ergibt sich die Möglichkeit Änderungen am Interface vorzunehmen ohne dass alle abgeleiteten Klassen unbrauchbar werden. Außerdem ist eine Änderung der Implementierungen möglich, ohne dass sich das Interface und damit die Anwenderschnittstelle ändert.

07-GraphischeObjekte5 Punkt AbstrakterPunkt EuklidischerPunkt Farbe AbstrakteFarbe ExpFarbeEuklidischerExpFarbPunkt FarbigerPunkt AbstrakterFarbigerPunkt

07-GraphischeObjekte6 Vererbung vs. Komposition Vererbung: Entsteht durch Ableitung einer Klasse von einer anderen Schnittstellen und Implementation werden vererbt Implementation kann überschrieben werden Mehrfachvererbung nur mit Hilfe von Interfacen möglich. Implementation kann nicht geerbt werden. Komposition: Entsteht dadurch, dass in einer Klasse ein Attribut definiert wird Schnittstellen und Implementation des Attributes werden genutzt, können aber nicht verändert werden. Zur Vereinfachung des Zugriffs des Attributes können die Methode delegiert werden.

07-GraphischeObjekte7 Vererbung public class Punkt{ private double x, y; public Punkt(double x, double y){this.x=x; this.y=y;} public double getX(){return x;} public double getY(){return y;} } interface Farbe { int getR(); int getG(); int getB(); } class FarbigerPunkt extends Punkt implements Farbe { private int r, g, b; public FarbigerPunkt(double x, double y, int r, int g, int b) {super(x, y);this.r=r;this.g=g;this.b=b;} public int getR(){return r;} public int getG(){return g;} public int getB(){return b;} }

07-GraphischeObjekte8 Komposition/Delegation public class Punkt { private double x, y; public Punkt(double x, double y){this.x=x; this.y=y; } public double getX(){return x;} public double getY(){return y;} } public class Farbe { private int r,g,b; public Farbe(int r, int g, int b){this.r=r;this.g=g;this.b=b;} int getR(){return r;} int getG(){return g;} int getB(){return b;} } class FarbigerPunkt extends Punkt{ Farbe f; public FarbigerPunkt(double x, double y, int r, int g, int b){ super(x, y);f = new Farbe(r, g, b);} public int getF(){return f;} public int getR(){return f.getR();} public int getG(){return f.getG();} public int getB(){return f.getB();} }

07-GraphischeObjekte9 Vorteile der Komposition Implementierungen können vollständig benutzt werden. Durch Delegation der Methoden kann die Kompositionstechnik vor dem Anwender verborgen werden.

07-GraphischeObjekte10 Regeln 1. Oberste Klasse eines Klassenbaums ist immer ein Interface. 2. Anwender nutzen so weit wie möglich dieses Interface. 3. Jedes Interface wird nach unten durch eine abstrakte Klasse abgesichert. 4. Konkrete Klassen werden so weit wie möglich von der abstrakten Klasse abgeleitet. 5. Mehrfachvererbungen werden so weit wie möglich vermieden. Statt dessen setzt man die Kompositionstechnik ggf. mit Delegation der Methoden ein.

07-GraphischeObjekte11 Interface GraphicalObject Oberstes Interface aller graphischen Objekte in EMMA301Paint Frage: Welche Methoden sollen alle graphischen Objekte dem Nutzer zur Verfügung stellen, d.h. welche Eigenschaften sollen alle graphischen Objekte gemeinsam haben? Alle graphischen Objekte müssen in einem vorgegebenen graphischen Kontext gezeichnet werden können. paint Alle graphischen Objekte sollen die Eigenschaft haben sichtbar oder unsichtbar zu sein. setVisible, isVisible Alle graphischen Objekte können selektiert werden oder nicht selektiert sein. setSelected, isSelected Selektierte graphische Objekte sollen markiert werden. paintSelection Alle graphischen Objekte sollten eine grobe graphische Darstellung besitzen, damit eine Vorschau schneller realisiert werden kann. paintRaw

07-GraphischeObjekte12 import java.awt.Graphics2D; interface GraphicalObject { void paint(Graphics2D g); void paintRaw(Graphics2D g); void paintSelection(Graphics2D g); boolean isVisible(); void setVisible(boolean visible); boolean isSelected(); void setSelected(boolean selected); }

07-GraphischeObjekte13 AbstractGraphicalObject Die abstrakte Klasse AbstractGraphicalObject implementiert direkt das Interface GraphicalObject. AbstractGraphicalObject kann einige Funktionalitäten endgültig implementieren: isVisible, setVisible, isSelected, setSelected Andere können nicht implementiert werden: paint Andere wiederum provisorisch: paintRaw, paintSelection Private Attribute können definiert werden: visible, selected

07-GraphischeObjekte14 import java.awt.Graphics2D; public abstract class AbstractGraphicalObject implements GraphicalObject { boolean visible = true; boolean selected = false; public boolean isVisible(){return visible;} public void setVisible(boolean visible){ this.visible=visible;} public boolean isSelected(){return selected;} public void setSelected(boolean selected){ this.selected=selected;} public void paintRaw(Graphics2D g){paint(g);} public void paintSelection(Graphics2D g){} }

07-GraphischeObjekte15 RectangularGraphicalObject Eine Reihe von graphischen Objekten sind durch zwei Punkte gekennzeichnet: Linien, Rechtecke, Ellipsen, Bilder u.s.w. Es ist sinnvoll, eine gemeinsame abstrakte Klasse zu definieren in der gemeinsame Attribute und Konstruktoren definiert werden. abstrakte Klasse RectangularGraphicalObject Gemeinsame Attribute: x1s, y1s und x2s,y2s sind die Koordinaten der beiden beschreibenden Punkte, wie sie bei der Erzeugung des Objektes angegeben werden. Die meisten Objekte erfordern die Eigenschaft x1<=x2 und y1<=y2. Daher werden die Attribute x1=min(x1s,x2s), y1=min(y1s,y2s), x2=max(x1s,x2s), y2=max(y1s,y2s) definiert. Die Werte werden im Konstruktor berechnet und gespeichert. Bei von dieser Klasse abgeleiteten Klassen sollte unbedingt der super-Konstruktor verwendet werden. Die Attribute können in abgeleiteten Klassen direkt verwendet werden.

07-GraphischeObjekte16 public abstract class RectangularGraphicalObject extends AbstractGraphicalObject { double x1, y1, x2, y2; double x1s, y1s, x2s, y2s; public RectangularGraphicalObject (double x1, double y1, double x2, double y2) { this.x1s=x1; this.y1s=y1; this.x2s=x2; this.y2s=y2; this.x1=(x1<x2?x1:x2); this.y1=(y1<y2?y1:y2); this.x2=(x1<x2?x2:x1); this.y2=(y1<y2?y2:y1); } }

07-GraphischeObjekte17 Line Line ist die erste reale Klasse. Eine Linie wird durch die beiden Endpunkte beschrieben. Line wird von RectangularGraphicalObject abgeleitet. Die Endpunkte müssen keine besonderen Bedingungen erfüllen. Wir verwenden die Attribute (x1s,y1s) und (x2s,y2s). Um die Linie zeichnen zu können, müssen sowohl die Linienfarbe (Color- Objekt) als auch die Linienart (Stroke-Objekt) bekannt sein.

07-GraphischeObjekte18 import java.awt.Graphics2D;... public class Line extends RectangularGraphicalObject { Stroke stroke; Color color; public Line (Stroke stroke, Color color, double x1, double y1, double x2, double y2) { super(x1, y1, x2, y2); this.stroke=stroke; this.color=color; } public void paint(Graphics2D g) { if (visible) { g.setStroke(stroke); g.setColor(color); g.draw(new Line2D.Double(x1s, y1s, x2s, y2s)); } } public void paintRaw(Graphics2D g) { g.setStroke(new BasicStroke()); g.setColor(color); g.setXORMode(Color.white); g.draw(new Line2D.Double(x1s, y1s, x2s, y2s)); } }

07-GraphischeObjekte19 Rectangle Rechtecke sind flächige Objekte. Sie werden beschrieben durch: Linke obere Ecke (x1,y1) Breite x2-x1 und Höhe y2-y1 Linienfarbe für den Rand Color-Objekt Linienart für den Rand Stroke-Objekt Füllmuster Paint-Objekt, Sonderfall paint==null Rechteck besteht nur aus Rand Völlig analog ist die Klasse Oval zu definieren.

07-GraphischeObjekte20 import... public class Rectangle extends RectangularGraphicalObject { Stroke stroke; Color color; Paint paint; public Rectangle (Paint paint, Stroke stroke, Color color, double x1, double y1, double x2, double y2) { super(x1, y1, x2, y2); this.paint=paint; this.stroke=stroke; this.color=color; }

07-GraphischeObjekte21 public void paint(Graphics2D g) { if (visible) { if (paint!=null) { g.setPaint(paint); g.fill(new Rectangle2D.Double(x1, y1, x2-x1, y2-y1)); } g.setStroke(stroke); g.setColor(color); g.draw(new Rectangle2D.Double(x1, y1, x2-x1, y2-y1)); } } public void paintRaw(Graphics2D g) { g.setStroke(new BasicStroke()); g.setColor(color); g.setXORMode(Color.white); g.draw(new Rectangle2D.Double(x1, y1, x2-x1, y2-y1)); } }

07-GraphischeObjekte22 ComposedGraphicalObject Einfache GraphicalObject können zusammengesetzt werden um komplexe Objekte zu erstellen. Z.B. Ebenen (Layer) und Gruppen. In der abstrakten Klasse ComposedGraphicalObject können folgende Fähigkeiten implementiert werden: Liste in der die graphischen Objekte (GraphicalObject) gespeichert und verwaltet werden. ArrayList ist geeignet, da beliebig viele Element hinzugefügt werden können, auch mehrfach und die Reihenfolge garantiert wird. Die Zeichenmethoden können auf die Methoden der einfachen Objekte zurückgeführt werden. Da ComposedGraphicalObject selbst von GraphicalObject abgeleitet ist können in einem ComposedGraphicalObject wieder ComposedGraphicalObjecte enthalten sein. Hierarchie von Ebenen oder Gruppen ist möglich. ComposedGraphicalObject enthält keine abstrakten Methoden mehr. Die Klasse ist als abstract definiert, damit die Flexibilität erhalten bleibt.

07-GraphischeObjekte23 public abstract class ComposedGraphicalObject extends AbstractGraphicalObject { ArrayList objectList = new ArrayList(); public void add(GraphicalObject graphicalObject) { objectList.add(graphicalObject); } public void remove(GraphicalObject graphicalObject) { int ind = objectList.indexOf(graphicalObject); if (ind>=0) objectList.remove(ind); } public void paint(Graphics2D g) { if (visible) { for (int i=0;i<objectList.size();i++) ((GraphicalObject)objectList.get(i)).paint(g); } } public void paintRaw(Graphics2D g) { for (int i=0;i<objectList.size();i++) ((GraphicalObject)objectList.get(i)).paintRaw(g); } public void paintSelection(Graphics2D g) { for (int i=0;i<objectList.size();i++) ((GraphicalObject)objectList.get(i)).paintSelection(g); } }

07-GraphischeObjekte24 Layer Layer ist die Imlementierung eines ComposedGraphicalObject das eine Ebene von graphischen Objecten realisiert. Hierarchie von Ebenen ist möglich. public class Layer extends ComposedGraphicalObject { }

07-GraphischeObjekte25 MultiPointGraphicalObject Viele graphische Objekte werden durch eine beliebige Anzahl von Punkten beschrieben. Polygonzüge (Polyline) Polygonal berandete Flächen (Polygon) Punktwolken Freihändig gezeichnete Kurven Flächen, die durch freihändig gezeichnete Kurven berandet sind

07-GraphischeObjekte26 Folgende Fähigkeiten können implementiert werden: ArrayList für die Speicherung der Punkte Es ist eine interne Klasse für Punkte erforderlich. Hinzufügen eines Punktes. Ersetzen des letzten Punktes. Wird für die Vorschau benötigt. Umwandeln der Punktmenge in ein GeneralPath-Objekt, das zum zeichnen mit den Methoden draw bzw. fill der Klasse Graphics2D gut geeignet ist. Die Klasse muss abstrakt sein, da die Methode draw nicht allgemein implementiert werden kann.

07-GraphischeObjekte27 public abstract class MultiPointGraphicalObject extends AbstractGraphicalObject { ArrayList points = new ArrayList(); public void appendPoint(float x, float y) { points.add(new Point(x, y)); } public void replaceLast(float x, float y) { if (points.size()>0) points.set(points.size()-1,new Point(x, y)); } public GeneralPath toGeneralPath() { GeneralPath gp = new GeneralPath(); if (points.size()>0) { Point pp = (Point)points.get(0); gp.moveTo(pp.x, pp.y); } for (int i=1;i<points.size();i++) { Point pp = (Point)points.get(i); gp.lineTo(pp.x, pp.y); } return gp; } class Point implements { float x, y; Point(float x, float y) { this.x=x; this.y=y; } } }

07-GraphischeObjekte28 Polyline Polyline beschreibt einen aus mehreren zusammenhängenden Strcken bestehenden Streckenzug. Er muss nicht geschlossen sein. Für die Beschreibung werden ein Stroke-Objekt (Linienart) und ein Color- Objekt (Farbe) benötigt. Das Stroke-Objekt, das Color-Objekt und die Koordinaten des Startpunktes werden dem Konstruktor als Parameter übergeben. In der paintRaw-Methode wird als XOR-Farbe new Color(color.getRGB()^0x00FFFFFF) verwendet.

07-GraphischeObjekte29 public class Polyline extends MultiPointGraphicalObject { Stroke stroke; Color color; public Polyline (Stroke stroke, Color color, float x, float y) { this.stroke=stroke; this.color=color; appendPoint(x, y); } public void paint(Graphics2D g) { if (visible) { g.setStroke(stroke); g.setColor(color); g.draw(toGeneralPath()); } } public void paintRaw(Graphics2D g) { g.setStroke(new BasicStroke()); g.setColor(color); g.setXORMode(new Color(color.getRGB()^0x00FFFFFF)); g.draw(toGeneralPath()); } }

07-GraphischeObjekte30 Polygon Polygon beschreibt eine Fläche, die von einem geschlossenen Polygon- Zug berandet wird. Zusätzlich zu Polyline wird ein Paint-Objekt (Füllmuster) benötigt. Außerdem unterscheiden sich die paint-Methoden.

07-GraphischeObjekte31 public void paint(Graphics2D g) { if (visible) { GeneralPath gp = toGeneralPath(); if (paint!=null) { g.setPaint(paint); g.fill(gp); } g.setStroke(stroke); g.setColor(color); gp.closePath(); g.draw(gp); } } public void paintRaw(Graphics2D g) { g.setStroke(new BasicStroke()); g.setColor(color); g.setXORMode(new Color(color.getRGB()^0x00FFFFFF)); GeneralPath gp = toGeneralPath(); gp.closePath(); g.draw(gp); }

07-GraphischeObjekte32 Struktur der GraphicalObjects GraphicalObject AbstractGraphicalObject RectangularGraphicalObject LineRectangleOval ComposedGraphicalObject Layer MultiPointGraphicalObject Polygon Polyline