07-GraphischeObjekte Graphische Objekte in EMMA301Paint.

07-GraphischeObjekte

Graphische Objekte in EMMA301Paint

07-GraphischeObjekte 2

Interface vs. abstrakte Klassenhttp://java.sun.com/jdc/JDCTechTips/2001/tt1106.htmlEigenschaften 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.


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).


Interface + abstrakte KlasseDie 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.


Punkt

AbstrakterPunkt

EuklidischerPunkt

Farbe

AbstrakteFarbe

ExpFarbeEuklidischerExpFarbPunkt

FarbigerPunkt

AbstrakterFarbigerPunkt


Vererbung vs. KompositionVererbung:

•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.


Vererbungpublic 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;}}


Komposition/Delegationpublic 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();}}


Vorteile der KompositionImplementierungen können vollständig benutzt werden.Durch Delegation der Methoden kann die Kompositionstechnik vor dem Anwender verborgen werden.


0

Regeln1. 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.


1

Interface GraphicalObjectOberstes Interface aller graphischen Objekte in EMMA301PaintFrage: 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


2

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);

}


3

AbstractGraphicalObjectDie abstrakte Klasse AbstractGraphicalObject implementiert direkt das Interface GraphicalObject.

AbstractGraphicalObject kann einige Funktionalitäten endgültig implementieren:

•isVisible, setVisible, isSelected, setSelectedAndere können nicht implementiert werden:

•paintAndere wiederum provisorisch:

•paintRaw, paintSelectionPrivate Attribute können definiert werden:

•visible, selected


4

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){}

}


5

RectangularGraphicalObjectEine 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.


6

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);}}


7

LineLine 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.


8

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));}}


9

RectangleRechtecke 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.


0

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;

}


1

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));}}


2

ComposedGraphicalObjectEinfache 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.


3

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);}}


4

LayerLayer ist die Imlementierung eines ComposedGraphicalObject das eine Ebene von graphischen Objecten realisiert.

Hierarchie von Ebenen ist möglich.

public class Layer extends ComposedGraphicalObject

{

}


5

MultiPointGraphicalObjectViele 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


6

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.


7

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; }}}


8

PolylinePolyline 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.


9

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());}}


0

PolygonPolygon 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.


1

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);}


2

Struktur der GraphicalObjects

GraphicalObject

AbstractGraphicalObject

RectangularGraphicalObject

Line Rectangle Oval

ComposedGraphicalObject

Layer

MultiPointGraphicalObject

Polygon Polyline

Date post:	05-Apr-2015
Category:	Documents
Upload:	swanhilde-karger
View:	109 times
Download:	0 times

07-GraphischeObjekte Graphische Objekte in EMMA301Paint.

Documents