Georg Dick
UMLEDiTOR Anleitung
(November 2015)
2
Inhaltsverzeichnis Einführung ........................................................................................................................................... 4
Übersicht über die Eigenschaften des Editors ..................................................................................... 4
Aufbau der Programmoberfläche ....................................................................................................... 5
Entwurf einer Klasse ............................................................................................................................ 8
Entwurf einer Klasse ....................................................................................................................... 8
Klassenrechteck positionieren und manuell dimensionieren ....................................................... 10
Attributeingabe ............................................................................................................................. 11
Anzeigereihenfolge der Attribute oder Methoden im Klassenrechteck ändern ........................... 12
Datentypeingabe ....................................................................................................................... 13
Methodeneingabe ......................................................................................................................... 16
Ändern von Attributen und Methoden ......................................................................................... 18
Anzeige von Klassen, die im Modell bereits vorhanden sind. ....................................................... 20
Ausgabe des Diagramms als Grafik ................................................................................................... 22
Speichern und Laden des Modells ..................................................................................................... 28
Assoziationen .................................................................................................................................... 29
Erstellen von Assoziationen ........................................................................................................... 29
Ändern der Attributanzeige ........................................................................................................... 32
Anzeige von Assoziationen zu vorhandenen Attributen ............................................................... 34
Pfad bearbeiten ............................................................................................................................. 37
Verlauf ändern ........................................................................................................................... 37
Einstellen der Linienbreite für Pfade ......................................................................................... 38
Vererbung .......................................................................................................................................... 39
Erzeugen einer Vererbungsbeziehung .......................................................................................... 39
Ändern einer Vererbungsbeziehung ............................................................................................. 40
Löschen einer Vererbungsbeziehung ............................................................................................ 41
Datensammlungen ............................................................................................................................ 43
Festlegung des Sammlungstyps für eine nicht typisierte Datensammlung .................................. 43
Festlegung eines Sammlungstyps für eine typisierte Datensammlung ........................................ 45
Zusätzliche Hinweise zu Datensammlungen im UMLEDiTOR ........................................................ 46
Anzeigevorgaben ............................................................................................................................... 49
Beispiel: Darstellung mit Standardoptionen ................................................................................. 52
Änderung der Schrift ..................................................................................................................... 54
Import von Klassen ............................................................................................................................ 54
3
Beispiel für einen Import ............................................................................................................... 56
Hinweis .......................................................................................................................................... 58
Entwurfs- und Implementationsdiagramme ..................................................................................... 67
Der Sonderfall Datenansammlung ................................................................................................ 68
Hinweis .......................................................................................................................................... 70
Umschalten zwischen Entwurfsdiagramm und Implementationsdiagramm ................................ 71
Umschaltung Entwurfsdiagramm Implementationsdiagramm ............................................ 71
Umschaltung Implementationsdiagramm Entwurfsdiagramm ............................................ 73
Der UMLEDiTOR als Plugin von BlueJ ................................................................................................ 74
Die Bedeutung der Menüpunkte ................................................................................................... 75
Schlussbemerkung ............................................................................................................................. 76
4
Einführung
Der Editor dient dem Entwurf von Klassen und Beziehungen. Die Darstellung ist an UML angelehnt
und berücksichtigt die Vorgaben für das ZA in NRW bezüglich der Unterscheidung von Entwurfs- und
Implementationsdiagramm. Der Editor läuft als selbstständige Anwendung oder als Plugin von BlueJ.
Übersicht über die Eigenschaften des Editors In erster Linie dient der Editor der Erstellung von Klassen, ihren Assoziationen und
Vererbungsbeziehungen. Die Modelle können gespeichert und zur Weiterbearbeitung geladen
werden.
Es können Quelltexte generiert und gespeichert werden. Wenn der Editor als Plugin für BlueJ benutzt
wird werden die Quelltexte auf Wunsch in ein BlueJ-Projekt exportiert und im Editor von BlueJ
geöffnet.
Bereits vorhandene Klassen können aus JAVA-Quellen (nur, wenn die Anwendung unter der
Laufzeitumgebung JAVA 7 läuft) oder class-Dateien importiert und in UML-Diagrammen verwendet
werden.
Assoziationen und Vererbungsbeziehungen zwischen den Klassen des Modells können automatisiert
oder manuell angezeigt werden.
Das Programm unterstützt die Ausgabe der UML-Klassendiagramme als Bitmap-Grafiken und -
rudimentär - als Vektorgrafiken im EPS (Postscript)-Format.
Das Klassendiagramm kann flexibel layoutet werden:
Der Verlauf von Assoziations- und Vererbungspfaden kann manuell verändert werden. Knickpunkte
können ergänzt oder entfernt werden. Ansatzpunkte können verschoben werden. Assoziationspfade
können auf Wunsch ausgeblendet werden, die am Pfad angezeigten Attribute werden dann im
Klassenrechteck angezeigt.
Klassenrechtecke können frei positioniert werden. Ihre Größe kann automatisch durch den Inhalt
festgelegt oder fixiert werden.
Die Anzeigereihenfolge der Attribute und Methoden kann durch Verschieben mit der Maus verändert
werden.
5
Aufbau der Programmoberfläche
Das Hauptfenster ist der zentrale Anlaufpunkt für die Erstellung der Diagramme. Es enthält
zumindest ein Unterfenster, in dem der Diagrammentwurf stattfindet. In diesem werden Klassen
entworfen, sowie Vererbungsbeziehungen und Assoziationen festgelegt. Für jedes Package können
separate UML-Diagramme entworfen werden. Im Modellfenster werden in einem linken Teilfenster
alle vorhandenen Klassen des Modells einschließlich der Packagestruktur angezeigt, im rechten
Teilfenster wird eine ausgewählte Klasse angezeigt.
Beispiel:
6
Das Modellfenster gibt eine Übersicht über die im Modell erstellten oder referenzierten Klassen. Im
linken Fenster wird die Paketstruktur mit den zugehörigen Klassen angezeigt. Wählt man mit der
Maus eine der Klassen aus, so werden im rechten Teilfenster die Eigenschaften der Klasse angezeigt.
Dort können die Eigenschaften auch verändert werden. Der Zugriff auf die Änderungsmöglichkeiten
erfolgt über Kontextmenüs, die mit der rechten Maustaste aufgerufen werden. Die gleichen
Änderungen kann man auch über die Kontextmenüs des Entwurfsfensters vornehmen.
7
8
Entwurf einer Klasse
Entwurf einer Klasse
Man startet den Klassenentwurf, indem man entweder aus der Symbolleiste eines Entwurffensters
das Symbol für den Klassenentwurf auswählt und dann in einen freien Bereich des Fensters mit der
Maus klickt, oder indem man mit der rechten Maustaste in eine freien Bereich des Fensters klickt und
das Kontextmenü aufruft und dort den Punkt Klasse erstellen wählt. Die angeklickte Position ergibt
die linke obere Ecke des Klassenrechtecks.
Im folgenden Menü gibt man einen Klassennamen ein und gegebenenfalls eine Oberklasse. Die
Oberklassenangabe erfolgt voll qualifiziert, d.h. mit Angabe der Packages. Default-Wert ist
java.lang.Object. Ferner kann man wählen, ob ein Interface erstellt werden soll. Da jedes
Entwurfsfenster einem Package zugeordnet ist, wird die erstellte Klasse diesem Package zugeordnet.
Diese Zuordnung lässt sich im Nachhinein jederzeit ändern.
9
Wurde bei der Erstellung einer Klasse eine Oberklasse angegeben, die im Modell nicht enthalten ist,
so wird diese dem Modell hinzugefügt und zunächst als externe Klasse gekennzeichnet. Externe
Klassen sind vor Veränderung geschützt, man kann sie in interne Klassen wandeln und so den Schutz
aufheben (Menüpunkt Modell im Hauptfenster). Man erkennt externe Klassen an der roten Schrift,
die für den Klassennamen verwendet wird. Interne Klassen werden mit schwarzer Schrift dargestellt.
Interfaces werden in der Modellübersicht mit dem Kürzel I gekennzeichnet. In der Titelleiste des
Klassenrechtecks steht zudem der Schriftzug <<interface>> in der ersten Zeile.
:
Oberklasse als externe
Klasse
Neue Klasse „A“ als
interne Klasse
Klassenrechteck für „A“
10
Klassenrechteck positionieren und manuell dimensionieren
Mit der linken Maustaste kann das Klassenrechteck an der oberen grauen Leiste, in
der der Namen der Klasse steht, angefasst und dann verschoben werden. Klickt
man mit der Maus auf diese Leiste, so kann man anschließend das Rechteck an
beliebiger Stelle anfassen und verschieben und an den zusätzlich erscheinenden
Anfassern seine Größe verändern. Nochmaliges Klicken auf die Rechteckfläche versetzt das
Diagramm wieder in den Ausgangszustand.
11
Attributeingabe
Die Attributeingabe startet man durch Aufruf eines Kontextmenüs durch Klick mit der rechten
Maustaste auf die graue Titelleiste des Klassenrechtecks.
Nach Wahl des entsprechenden Menüpunktes erscheint ein Eingabedialog, über den man die
Eigenschaften des Attributes festlegt. Hier kann man auch Hole- und Setze-Methoden generieren
lassen.
Das Resultat erscheint anschließend sowohl im Klassenrechteck als auch im Modellfenster:
12
Anzeigereihenfolge der Attribute oder Methoden im Klassenrechteck ändern
Hat man mehrere Attribute oder Methoden erzeugt, kann man deren Anzeigereihenfolge im
Klassenrechteck durch Verschieben mit der Maus verändern.
13
Datentypeingabe
Die Eingabe des Datentyps kann direkt über das Feld „Datentypeingabe“ oder über einen Dialog
erfolgen. Neben der Eingabe einfacher Datentypen wie int, double etc. sind Klassenbezeichner mit
oder ohne Packageangaben möglich. Hat man einen Array als Datentyp, so gibt hängt man Paare
eckiger Klammern an den Grundtyp (Beispiel int[][] für ein zweidimensionales int-Feld). Inhaltstypen
einer Sammlung(Sammlungstypen, generische Typen) gibt man mit spitzen Klammern an
(ArrayList<B>). Auch Schachtelungen der beschriebenen Typen sind erlaubt (ArrayList<B[]>). Sobald
ein Datentyp eingegeben wird, der nicht zu den einfachen Datentypen von JAVA gehört und der
keiner der bisher im Modell auftretenden Klassen entspricht, wird eine zusätzliche Klasse im Modell
erzeugt. Diese wird als externe Klasse eingestuft. Bei Bedarf kann sie in eine interne umgewandelt
werden.
14
Beispiel:
15
Alternativ kann man den folgenden Dialog benutzen:
Im Feld Direkteingabe kann der Datentyp, wie oben für das Eingabefeld „Datentypeingabe“
beschrieben, dargestellt. Im unteren Dialogbereich kann man die Eigenschaften des Datentyps
zusammensetzen: Eingabe des Grundtyps, Festlegung, ob es sich um ein Feld handelt.
Gegebenenfalls kann man einen Sammlungstyp (=generischen Typ) angeben.
Die Grundtypen kann man aus einer Liste wählen. In dieser Liste sind die bisher im Modell erfassten
Klassen und die einfachen Datentypen von JAVA enthalten.
Hier kann man auch eine neue Klasse in das Modell einführen, für die zunächst noch kein
Klassendiagramm erstellt wird.
Die Angabe des generischen Typs erfolgt entweder per Direkteingabe über einen weiteren
Datentypeingabe-Dialog.
16
Methodeneingabe
Die Methodenerstellung erfolgt analog zur Erzeugung der Attribute. Im Kontextmenü des
Klassenrechtecks wählt man den Punkt „Methode hinzufügen“.
Es öffnet sich der folgende Dialog:
In der oberen Eingabezeile gibt man den Methodenbezeichner ein, für einen Konstruktor ist das nicht
erforderlich.
Anschließend legt man Sichtbarkeit, Modifikatoren und Typ der Methode fest. Über die Knöpfe
Kommentar und Quelltext kann man Methodenkommentare und den Quelltext für den
Methodenrumpf angeben. Der Quelltext für den Methodenkopf wird automatisch erzeugt.
Wählt man als Methodentyp eine Anfrage, so wird der Dialog um die Eingabemöglichkeit für die
Rückgabe ergänzt:
17
Die Eingabe des Rückgabetyps erfolgt über den bereits oben beschriebenen Datentypeingabe-Dialog.
Die Festlegung von neuen Parametern und deren Reihenfolge geschieht im unteren Dialogbereich.
Nach Druck auf „Hinzufügen“ öffnet sich ein Dialog, der die Angabe eines Parameterbezeichners und
des Datentyps erlaubt.
18
Ändern von Attributen und Methoden
Nach Klick mit der rechten Maustaste auf ein Attribut im Klassenrechteck oder der Baumanzeige der
Klasse im Modellfenster öffnet sich ein Kontextmenü, mit dessen Hilfe man Attribute ändern oder
löschen kann, zugehörige Setze- und Holemethoden werden nicht verändert:
Änderungsdialog
19
Analog zur Änderung von Attributen erfolgt die der Methoden:
20
Methodenänderungsdialog
Anzeige von Klassen, die im Modell bereits vorhanden sind.
Die Anzeige von Klassen, die im Modell vorhanden sind aber im Entwurfsfenster nicht angezeigt
werden, erfolgt über das Kontextmenü im freien Bereich des Entwurfsfensters. Man kann entweder
eine einzelne Klasse oder mehrere Klassen für die Darstellung auswählen. Letzteres ist beispielsweise
vorteilhaft, wenn mehrere Klassen ins Modell über den Dateidialog importiert wurden. In diesem
Falle werden die Klassen nicht im Entwurfsfenster dargestellt, sondern nur im Modellfenster gelistet.
21
Hinweis:
Bei Bedarf können Sie mehrere Klassenrechtecke derselben Klasse darstellen.
Um eine Klassenanzeige zu verbergen wählt man den entsprechenden Menüpunkt aus dem
Kontextmenü des Klassenrechtecks.
22
Ausgabe des Diagramms als Grafik
Bei der Ausgabe als Pixelgrafik (Bitmap) kann man zwei Optionen wählen.
- Ausgabe als Bitmap
- Ausgabe als Bitmap mit Auslassungspunkten für fehlende Zeilen.
Ferner kann man die Linienbreite für die Zeichnung der Rechtecksrahmen festlegen.
Im ersten Fall entspricht die Grafik in der Darstellung weitgehend der Darstellung im
Modellierungsfenster. Im zweiten Fall werden für Klassen, bei denen Attribute oder Methodenlisten
nicht vollständig dargestellt werden, Auslassungspunkte am Ende der Attribut- oder Methodenlisten
generiert.
Ferner besteht die Möglichkeit einer einfachen Postscriptausgabe.
Nach Wahl der Bitmapausgabe öffnet sich ein Fenster mit der generierten Grafik.
23
24
25
Von dieser Grafik kann man mit Hilfe der Maus einen Ausschnitt bestimmen oder einen rechteckigen
Bereich mit einem Rahmen versehen. Der Ausschnitt oder Rahmen wird erst übernommen, wenn die
OK-Taste gedrückt wurde oder die Auswahl über das Kontextmenü bestätigt wird.
26
Der Ausschnitt kann in die Zwischenablage kopiert, gedruckt oder gespeichert (jpg, gif oder png)
werden. Das Bild kann zudem auf den Ausschnitt zugeschnitten werden.
Ferner besteht die Möglichkeit einer einfachen Postscriptausgabe.
Die Postscriptanweisungen werden als Textdatei in ein Fenster geschrieben und können dort
gegebenenfalls modifiziert und gespeichert werden.
27
28
Speichern und Laden des Modells
Speichern und Laden eines Modells erfolgt mit Hilfe des Dateimenüs:
Arbeitet man mit dem UMLEDiTOR als Plugin von BlueJ, so kann man das Modell direkt in einen
Projektordner abspeichern oder aus diesem laden ohne über das Dateimenü erst den gewünschten
Ordner zu suchen.
Hinweis:
Das Speichern des Modells hat nichts mit der Speicherung des Quelltextes zu tun. Es werden alle
Informationen abgespeichert, die zum UML-Diagramm gehören, beispielsweise Informationen zu den
Klassen, aber auch Informationen zu Größe und Lage der Anzeigen, so wie sie zum Zeitpunkt des
Abspeicherns waren. Erzeugter Quelltext enthält diese Informationen nicht. Will man also das UML-
Diagramm im Editor wieder zur Verfügung haben, muss man das Modell abspeichern.
29
Assoziation erstellen
Assoziationen
Erstellen von Assoziationen
Eine Möglichkeit besteht darin, zwischen zwei Klassen, für die bereits Klassendiagramme vorhanden
sind, eine Assoziation zu definieren.
Zunächst wählt man im Entwurfsfenster das Symbol zur Erstellung von Assoziationen.
Die Klassendiagramme im Entwurfsfenster werden daraufhin mit einem zweifarbigen Rahmen
versehen.
Nun platziert man die Maus im Klassenrechteck, von dem die Assoziation ausgeht, drückt die linke
Maustaste – das Startrechteck ändert die Farbe des inneren Randes auf Grün - und zieht die Maus
zum Zielrechteck, dessen Farbe nun hellrot wird.
Sobald man die linke Maustaste loslässt wird ein Assoziationspfeil erzeugt. Lässt man die Maus über
dem Startrechteck los, so erzeugt man eine „rekursive“ Assoziation. Es öffnet sich ein Auswahlmenü,
mit dessen Hilfe man die zur Assoziation passenden Attribute festlegen kann. Alternativ kann man
auch nur eine Multiplizität (Kardinalität) angeben.
30
31
Die Position und Dimension der Attributanzeige der Assoziation kann man verändern, indem man
analog zur Dimensionierung der Klassenrechtecke vorgeht.
Das Pfadlayout erfolgt automatisch und passt sich an, wenn man die Klassenrechtecke verschiebt
oder ihre Größe ändert.
32
Ändern der Attributanzeige
Eine Möglichkeit zur Änderung der Anzeige besteht darin, den Assoziationspfad mit der linken
Maustaste auszuwählen und anschließend das Kontextmenü des Pfades aufzurufen (Rechtsklick auf
schwarze dicke Linie):
„Attribute hinzufügen oder entfernen“
33
Möchte man das Attribut „bobjekt“ nicht anzeigen, so verschiebt man es mit der Maus vom rechten
ins linke Teilfenster.
34
Daraufhin ändert sich die Klassenanzeige
Anzeige von Assoziationen zu vorhandenen Attributen
Für eine Klasse
Hat eine Klasse Attribute, die nicht zu einem einfachen Datentyp gehören, so kann man die
zugehörigen Assoziationsanzeigen vom Editor generieren lassen.
Im Kontextmenü des Klassenrechtecks (Rechtsklick auf oberes graues Rechteck) wählt man den
Menüpunkt „Assoziationen anzeigen“.
35
Im folgenden Menü kann man festlegen, ob die Anzeige von Assoziationen nur erfolgen soll, wenn
die beteiligten Klassen bereits im Entwurfsfenster dargestellt sind. Andernfalls werden die
Klassenrechtecke für die fehlenden Klassen automatisch erzeugt. Die Auswahl der Attribute kann
automatisch erfolgen.
Bedeutung der Optionen
(1) Assoziationen auf bereits angezeigt Klassen beschränken
Falls dieser Punkt ausgewählt ist, werden Assoziationspfade zu Klassen erzeugt, die im Fenster
dargestellt sind. Attribute, die sich auf andere Klassen beziehen, bleiben unberücksichtigt.
Falls dieser Punkt abgewählt ist, werden zusätzlich Assoziationspfade zu Klassen erzeugt, die im
Fenster nicht dargestellt sind. Fehlende Klassenrechtecke werden ergänzt.
(2) Auswahldialog für Attribute einblenden
Bei der Erstellung einer Assoziation, kann man die anzuzeigenden Attribute festlegen.
(3) Felder bei Assoziationen berücksichtigen
36
Hier kann man festlegen, ob auch Felder an Assoziationen angezeigt werden sollen. Diese
Möglichkeit ist für Zentralabitur-konforme Diagramme nicht zulässig.
(4) Attribute automatisch auswählen
Die Auswahl der Attribute erfolgt ohne Auswahldiagramm durch die Anwendung. Alle erlaubten
Attribute werden verwendet.
Hinweise
Sind weder (2) noch (4) ausgewählt, so wird kein Attribut an den Pfeil geschrieben. Es
werden nur Pfeile erzeugt, zu denen es ein Attribut gibt.
(2) und (4) können nicht zugleich ausgewählt werden
Assoziationen, für die bereits ein Pfeil existiert, bleiben unberücksichtigt.
Für alle Klassen des Fensters
Über das Kontextmenü des Entwurfsfensters kann man für alle oder ausgewählte Klassen die
Assoziationen anzeigen lassen.
(1) Assoziationen zwischen angezeigten Klassen anzeigen
Falls dieser Punkt ausgewählt ist, werden Assoziationspfade zwischen Klassen erzeugt, die im Fenster
dargestellt sind. Attribute, die sich auf andere Klassen beziehen, bleiben unberücksichtigt. Es werden
keine Attribute an den Pfaden angezeigt.
(2) Assoziationen anzeigen (Optionen)
Dies entspricht dem oben beschriebenen Auswahldialog, der gleichzeitig auf alle dargestellten
Klassen angewendet wird.
(3) Assoziationen verbergen
37
Verbirgt alle Assoziationen.
Pfad bearbeiten
Verlauf ändern
Klickt man einen Pfad an, so wird dieser hervorgehoben dargestellt. Ferner sieht man an Knick- und
Ansatzstellen quadratische Anfasser.
Diese Anfasser kann man mit der Maus positionieren, wenn das automatische Layout des Pfades
nicht zum gewünschten Ergebnis führt. Sobald man einen der Ansatzpunkte manuell verändert hat,
bleiben die Ansatzpunkte auch bei einer Lageveränderung der Klassenrechtecke fest. Hat man einen
inneren Punkt verändert, so bleiben alle Punkte fest.
Klickt man mit der rechten Maustaste auf einen Anfasser für einen inneren Punkt, so kann man den
Punkt entfernen:
Ansatzstellen
innere Punkte
38
Klickt man mit der rechten Maustaste auf einen markierten Pfad außerhalb der Anfasser, so kann
man mit Hilfe eines Kontextmenüs das Verhalten des Layouts festlegen und so beispielsweise das
automatische Layout wieder einstellen.
Ferner kann man weitere Punkte auf dem Pfad generieren, mit deren Hilfe man komplexere
Pfadverläufe gestalten kann. Die Pfadauswahl hebt man durch einen Mausklick abseits des Pfades
auf.
Einstellen der Linienbreite für Pfade
Die Einstellung der Linienbreite kann insbesondere für die Ausgabe als Grafik sinnvoll sein, wenn dort
breiter Linien etwa für einen Ausdruck erforderlich sind.
Aus dem Menü Darstellung wählt man den Punkt „Linienbreite der Pfeile einstellen“.
Über die beiden Regler des folgenden Dialogs stellt man die Breite des Pfades in Normaldarstellung
und die Breite des Pfades, wenn er per Maus ausgewählt ist, ein. Der erste Regler bestimmt
unmittelbar die Linienbreite für die Normaldarstellung, mit dem zweiten wählt man, um wie viel der
ausgewählte Pfeil breiter als der nichtausgewählte ist.
39
Bei der obigen Einstellung werden nicht ausgewählte Pfeile 1 Pixel breit ausgewählte 3 Pixel breit.
Die Auswahl wirkt sich auf alle im Fenster angezeigten Pfade aus.
Vererbung
Erzeugen einer Vererbungsbeziehung
Bereits bei der Erzeugung einer Klasse kann man eine Oberklasse angeben. Jede im Modell erzeugte
Klasse hat eine Oberklasse, im Zweifelsfalls java.lang.Object.
Will man die Oberklasse ändern so gibt es dazu folgende Möglichkeit:
Unter- und Oberklasse werden im Entwurfsfenster angezeigt:
Man wählt die Auswahl „Vererbung“:
Nun zieht man die Maus von der Unterklasse zur Oberklasse
40
Es wird anschließend die Vererbungsbeziehung erzeugt.
Zyklische Vererbungsbeziehungen werden zurückgewiesen.
Ändern einer Vererbungsbeziehung
Besteht bereits eine Vererbungsbeziehung zu einer anderen Klasse, so wird diese durch die neue
ersetzt:
Beispiel:
Wechsel von B nach C
41
Vererbungsbeziehungen („Implementieren“) zu Interfaces werden analog erzeugt. Natürlich sind
Vererbungsbeziehungen einer Klasse zu mehreren Interfaces möglich. Zwischen Interfaces gibt es
dagegen nur eine eindeutige Beziehung.
Löschen einer Vererbungsbeziehung
Das Löschen einer Vererbungsbeziehung zwischen Klassen kann man über verschieden
Kontextmenüs im Editor unmittelbar erledigen. Das Löschen einer Vererbung zwischen Klassen
bewirkt, dass java.lang.Object zur neuen Oberklasse wird.
Nach der Markierung des Verbindungspfeils der zu der zu löschenden Vererbung gehört,
wählt man aus dem Kontextmenü den Menüpunkt„Vererbung/Implementierung:
Das Kontetxmenü der Klassenazeige enthält den Menüpunkt „Oberklasse entfernen“
42
In der Modellansicht kann man in der Baumanzeige den Knoten Oberklasse wählen und dort
im Kontextmenü „Oberklasse entfernen“ wählen.
43
Datensammlungen
Werden Objekte eines Typs über eine Datensammlung (z.B. Liste verwaltet) so, kann man dies im
Implementationsdiagramm in besonderer Weise darstellen. Bei der Darstellung wird unterschieden,
ob die Datensammlung typisiert werden kann oder nicht. In JAVA kann man bei der Deklaration von
Klassen Typparameter definieren, dies ist etwa bei der Klasse ArrayList der Fall: Arraylist<T>. Diese
Typparameter werden bei der Deklaration eines Objektes der Klasse durch eine konkretisiert:
ArrayList<String> liste = new ArrayList<String>();
Die Objekte, die jetzt in liste untergebracht werden können, müssen der Klasse String oder einer
ihrer Unterklassen angehören. Die Anfrage liste.get(i) liefert das i-te Element der Liste und zwar als
String. Eine Typzusicherung ist nicht erforderlich. Nicht typisiertbare Datensammlungen verwalten
Objekte ohne zusätzliche Typinformationen. Die Implementationsdiagramme unterscheiden
zwischen typisierten und nichttypisierten Datensammlungen.
Festlegung des Sammlungstyps für eine nicht typisierte Datensammlung
Sollen Objekt der Klasse A mehrere Objekte der Klasse B verwenden und diese mit Hilfe einer
verwalten so wird dies in einem zweistufigen Prozess dargestellt:
Die Klasse A erhält einen Bezug zur Klasse der Datenansammlung (Liste ..) und an dieser wird eine
Notiz mit dem Typ der Sammlungsobjekte angeheftet.
Vorgehensweise im UMLEDiTOR:
Zunächst wird eine Assoziation zwischen A und der Sammlungsklasse erstellt
Im nächsten Schritt ruft man das Kontextmeü der Klasse List auf und wählt den Punkt
„Sammlungstyp bestimmen“
Es öffnet sich der Dialog für die Datenypeingabe, mit dessen Hilfe der Sammlungstyp – im Beispiel
„B“ – festgelegt wird.
44
Nach Verlassen des Dialogs mit OK wird der Sammlungstyp als Notiz dargestellt:
45
Festlegung eines Sammlungstyps für eine typisierte Datensammlung
Der Unterschied zur Vorgehensweise für nicht typisierte Datensammlungen besteht in der Auswahl
des Menüpunktes ContentType festlegen an Stelle von Sammlunsgstyp festlegen:
Nach Verlassen des Dialogs für die Datenypeingabe (s.o.) mit OK wird der Sammlungstyp als Rechteck
dargestellt:
46
Zusätzliche Hinweise zu Datensammlungen im UMLEDiTOR
Entfernt man die Darstellung der Assoziationspfeile (Kontextmenü, das durch Drücken der rechten
Maustaste im freien Bereich des Entwurfsfensters aufgerufen wird), so wird das Attribut als
generischer Datentyp mit dem Inhaltstyp B dargestellt:
Wenn man den Typ des Inhaltsobjekts ändert, werden alle am Pfeil dargestellten Attribute
angepasst.
47
Die Ausführungen gelten analog für typisierte Datensammlungen.
48
Achtung
Bei der Auswahl der Attribute, die am Assoziationspfeil angezeigt werden können, werden alle
Attribute mit dem Grundtyp der Sammlung angeboten, selbst, wenn der Sammlungstyp mit dem
angezeigten nicht übereinstimmt. Für die korrekte Auswahl der möglichen Typen wäre eine
umfangreiche Überprüfung im allgemeinen Falle erforderlich. Beispielsweise wäre es korrekt, wenn
der Sammlungstyp des Attributs Unterklasse des angezeigten Sammlungstyps ist. Diese Überprüfung
nimmt das Programm nicht vor. Sie wäre auch nur sinnvoll, wenn eine Änderung im
Beziehungsgefüge der Klassen zu einer automatischen Reorganisation führte. Dies ist im
augenblicklichen Entwicklungsstand der Anwendung nicht vorgesehen.
49
Anzeigevorgaben
In einem gewissen Umfang kann man die Darstellung der Klassen verändern. Zum einen kann man
Vorgaben für die Darstellung festlegen, die für alle neuen Klassenrechtecke gelten soll, zum anderen
kann man individuelle Einstellungen für bereits erzeugte Klassenrechtecke vornehmen.
Globale Vorgaben
Die Optionen in der Übersicht mit den Programmvorgaben
50
Lokale an eine Klassenanzeige gebundene Vorgaben
51
Die Mehrzahl der Optionen ist selbsterklärend. Will man die Auswirkungen einer Option testen, so
kann man die Optionen für eine einzelne Klassenanzeige ändern und gegebenenfalls mit Hilfe des
Menüpunktes „Globale Einstellungen übernehmen“ auf die globale Vorgabe zurücksetzen.
Dies kann man für alle Klassenanzeigen einer Paketanzeige über den Menüpunkt ebenfalls erreichen:
Tipp:
Möchte man die Anzeigeeinstellungen für alle Klassenanzeigeneiner Paketanzeige in gleicher Weise
ändern, so ändere man zunächst die globalen Einstellungen über das Optionen-Menü (s.o.) und
übernehme diese Einstellungen für die Klassenanzeigen über den gerade erwähnten Menüpunkt.
Hinweise zu speziellen Optionen
Üblicherweise erfolgt die Anzeige Klassennamen ohne die Paketangaben, beispielsweise „Object“ an
Stelle von „java.lang.Object“. Dies kann man für Datentypen ändern. Die Änderung betrifft dann die
Attribute. Wird eine Klasse in einer Paketanzeige angezeigt, die selbst nicht aus dem Paket stammt,
so kann man die Klassenanzeige mit Paketangaben versehen lassen.
Man kann die Sichtbarkeit von Attributen und Methoden mit Hilfe von Symbolen (+,-,#) oder textuell
(private, public …) darstellen. Wählt man den Menüpunkt „Sichtbarkeit durch Symbole anzeigen“ ab,
so erfolgt die textuelle Anzeige.
Der Menüpunkt „Multiplizitäten anzeigen“ wirkt sich nur auf Implementationsdiagramme aus, bei
denen gemäß der ZA-Vorgaben die Multiplizitäten an Pfaden nicht angezeigt werden. Dies kann man
durch Setzen dieser Option ändern.
Das Optionenmenü für die Klasseanzeige ändert dies nur für die von der Klasseanzeige ausgehenden
Assoziationen.
52
Beispiel: Darstellung mit Standardoptionen
Es wird nun die Java-Notation gewählt, die Paketnamenanzeige für Klassen und Datentypen und die
Markierungen von Aufträgen, Anfragen und Konstruktoren über „!“ , „?“ und „C“ werden
eingeschaltet. Die anderen Optionen bleiben bestehen.
53
Nach der Übernahme dieser Einstellungen präsentiert sich das Diagramm wie folgt:
54
Änderung der Schrift
Will man nur die Schrift ändern, so kann man dies über den Menüpunkt „Schrift ändern“ des
Optionen-Menüs. Dieser Punkt ist deshalb gesondert angelegt, weil es für die Ausgabe eines
Diagramms hilfreich sein kann, wenn größere Schriftarten verwendet werden. Dies kann man dann
ohne größere Umwege erledigen.
Import von Klassen
Klassen können sowohl aus Quelltexten als auch über Kompilate in Form von class-Dateien importiert
werden.
Hinweis: Der Import aus Quelltexten setzt voraus, dass der Editor unter JAVA 7 läuft, für den Import
von class-Dateien genügt JAVA 6.
Notwendige Voraussetzung für einen erfolgreichen Import von JAVA-Quelltexten ist, dass diese
syntaktisch korrekt sind. Nach Möglichkeit sollten die Java-Quellen auch in einer den
Packageanweisungen entsprechenden Ordnerhierarchie untergebracht sein.
Nach Auswahl des entsprechenden Menüpunktes öffnet sich der Auswahldialog, mit dessen Hilfe
man die gewünschten Klassen bestimmt und Zusatzoptionen festlegt:
55
Für die Analyse des Quelltextes ist die Zeichencodierung von Bedeutung. BlueJ benutzt
beispielsweise UTF-8 in der aktuellen Version. Für einen korrekten Import sollte die
Zeichencodierung entsprechend ausgewählt werden. Problematisch bei falscher Wahl sind Umlaute
und Sonderzeichen. In der Liste fehlende Zeichencodierungen können auch als Text eingegeben
werden. Für die häufig genutzten Codierungen Windows 1251 und UTF-8 können die „Direkt“-Knöpfe
unter Umgehung der Auswahlliste genutzt werden.
Tipp:
Sollte ein Import erfolglos bleiben, so kann man in der Fehleranzeige
möglicherweise einen indirekten Hinweis auf die falsche Codierung finden. Die Fehleranzeige enthält
ein Protokoll aller Fehlermeldungen, die während des Programmablaufs generiert werden. Diese
können gegebenenfalls für den Programmautor hilfreich bei der Analyse von Programmfehlern sein.
56
Beispiel für einen Import
In den Optionen ist festgelegt, dass Quellen aus erreichbaren Paketen mit importiert werden. Hierbei
wird davon ausgegangen, dass die Quelltexte in der der Packagestruktur korrekten Ordnerhierarchie
untergebracht und syntaktisch korrekt sind. Das Programm bearbeitet nun die angegebene Klasse,
fügt alle Klassen des gleichen Pakets hinzu, sucht den Root-Ordner der Packagestruktur und
untersucht von da aus rekursiv alle Unterordner.
Werden in den zu importierenden Klassen weitere Klassen benutzt, die nicht unter den gewählten als
Dateien vorliegen, so werden diese im Normalfall als zusätzliche Klassen in das Modell aufgenommen
und dem Standardpackage zugeordnet. Die Klassen selbst enthalten keine Attribute oder Methoden.
Möchte man diese Klassen dagegen mit ihrer korrekten Signatur in das Modell aufnehmen, so kann
man einen Klassenpfad zu den Dateien angeben, bzw. eine Jar-Datei, in der die Klassen enthalten
sind auflisten.
57
Der Import kann einige Zeit in Anspruch nehmen. Das Ergebnis ist im Modellfenster sichtbar
(gegebenenfalls das Modellfenster über „Modell|Modellübersicht anzeigen“ anzeigen). Es wird kein
UML-Diagramm erzeugt.
Sollte eine Klasse bereits im Modell vorhanden sein, so kann man den Import unterbinden, die
vorhandene durch den Import ersetzen oder solche Attribute und Methoden der Importklasse, die in
der vorhandenen Klasse nicht enthalten sind, ergänzen:
58
Hinweis Einen Import mit sofortiger Erzeugung eines UML-Diagramms startet man über das
Kontextmenü einer Paketanzeige.
Die importierten Klassen und Interfaces werden rot angezeigt, da sie als externe Klassen vor
Veränderung geschützt sind.
Diese Zuordnung kann man bei Bedarf über das Kontextmenü einer zugehörigen Klassenanzeige für
eine einzelne Klasse ändern oder über das Menü „Modell|Externe Klassen in interne wandeln“ für
mehrere Klassen in einem Schritt durchführen:
Die Klassen werden in einer Baumstruktur gemäß der Pakethierarchie aufgelistet. Jetzt kann man die
Klassen einzeln, für ein Paket oder für ein Paket inklusiver aller untergeordneten Pakete auswählen.
Will man alle Klassen eines Paketes mit Ausnahme einer Klasse umwandeln, so kann man zunächst
das Paket wählen und das Häkchen neben der Klasse, die nicht berücksichtigt werden soll, wieder
entfernen. Im folgenden Bespiel wurden alle Klassen des Pakets XMLIO ausgewählt.
59
Im Modellfenster werden die Klassen entsprechend markiert:
Die umgewandelten Klassen können jetzt im Editor bearbeitet werden.
Achtung: Beim Abspeichern als Java-Quelltexte werden die ursprünglich vorhandenen
Implementierungen nicht übernommen, es werden lediglich „Gerüste“ erstellt. Allerdings werden die
ursprünglichen Javaquellen, wenn sie sich im gleichen Verzeichnis wie die Exporte befinden,
umbenannt: sie erhalten den Zusatz „.kopie“ und eine Nummer.
Um die Klassen in einem UML-Diagramm anzuzeigen, kann man über das Kontextmenü einer
Paketanzeige eine Auswahl vornehmen:
Über eine Baumauswahl können die Klassen für die Anzeige ausgewählt werden:
60
Die ausgewählten Klassen werden zunächst mit fester Größe in Reihen dargestellt. Sie müssen
anschließend mit der Maus arrangiert werden.
61
Man kann sie beispielsweise zunächst auf der Arbeitsfläche verteilen und ihre Darstellungsgröße
minimieren:
62
Mit Hilfe des Kontextmenüs kann man nun vorhandene Assoziationen anzeigen lassen:
63
Aus dieser Anzeige kann man nun Hinweise für ein übersichtliches Layout gewinnen und mit der
Maus erstellen:
64
Will man Klassen mit Methoden und Attributen darstellen, so kann mand die Größenfixierung für
einzelne Klassen aufheben, indem man auf den Fixieknopf „F“ oben rechts in der Klassenanzeige
drückt. Danach muss man das Layout gegebenenfalls anpassen. Möchte man alle Klassen mit
kompletter Anzeige sehen, so wählt man aus dem Menü Darstellung den Punkt „Dynamisch an Inhalt
anpassen“.
Für den vorliegenden Fall ist das jedoch keine gute Option:
Man kann sie über „Darstellung| Alle minimieren“ rückgängig machen.
Erzeugt man nun eine Ausgabe („Ausgabe|Ausgabe als Bitmap“), so werden einige Attribute oder
Methoden teilweise mitangezeigt, soweit sie eben in die Rechtecke passen:
65
Dies dürfte in diesem Falle nicht erwünscht sein. Um das zu umgehen, sollten die
Klassenanzeigeoptionen angepasst werden, in diesem Beispiel werden Attribute und Methoden
ausgeblendet.
66
Für eine optimierte Darstellung kann man jetzt den Inhalt dynamisch an die Größe anpassen und
dann die Ausgabe erzeugen:
67
Entwurfs- und Implementationsdiagramme Der UMLEDiTOR unterstützt beide für das ZA in NRW vorgesehenen Diagrammtypen. Die bisher
beschriebenen Vorgehensweisen gelten mit einer Ausnahme für beide Diagrammtypen. Die Beispiele
wurden jeweils mit den Einstellungen für Implementationsdiagramme erzeugt. Die genannte
Ausnahme betrifft die Anzeige von Sammlungsobjekten. Diese ist für Entwurfsdiagramme nicht
vorgesehen.
Um ein Entwurfsdiagramm zu erstellen, setzt man zunächst das Häkchen in der Paketanzeige neben
Entwurfsdiagramm.
Das Erzeugen von Klassen, Attributen, Methoden, Assoziationen und Vererbungsbeziehungen erfolgt
wie oben beschrieben. Im Detail ändern sich die Verhaltensweisen einiger Dialoge. Bei der Eingabe
eines Datentyps werden an Stelle der JAVA-Typen int, double, ..,boolean und String die Typen Zahl,
Wahrheitswert und Text angeboten. Gibt man bei der Direkteingabe dennoch einen der genannten
Datentypen ein, so wird dieser in der Anzeige durch den passenden Typ für Entwurfsdiagramme
ersetzt:
Anzeige:
68
Der Sonderfall Datenansammlung
Wenn Objekte der Klasse A mehrere Objekte einer Klasse B mit Hilfe einer Datenansammlung über
ein Objektattribut bobjekte verwalten sollen, so kann man die wie folgt umsetzen:
Man wählt „Attribut hinzufügen“ aus dem Kontextmenü der Klassenanzeige.
Im Eingabedialog gibt man den Bezeichner ein und als Datentyp den Typ „Datenansammlung“ gefolgt
von dem Sammlungstyp, der in spitze Klammern eingeschlossen wird. Im Grunde handelt es sich um
die JAVA-Notation, die für die Typfestlegung bei generischen Datentypen verwendet wird.
Nach Druck auf OK werden nun zwei Klassen dem Modell hinzugefügt (falls noch nicht vohanden):
die Klasse Datenansammlung und die Klasse B.
69
Der Bezug zur Klasse B kann mit Hilfe einer Assoziation dargestellt werden. Dies ist ein Unterschied
zum Implementationsdiagramm, bei dem eine Assoziation zur Klassen Datenansammlung erstellt
wird und an der Datenansammlung das Inhaltsobjekt vom Typ B notiert wird.
Im vorliegenden Beispiel kann man zunächst die Klasse B anzeigen und dann einen Assoziationspfeil
von A nach B ziehen:
70
Im linken Teil des Auswahlfensters wird das Attribut bobjekte zur Anzeige am Pfeil angeboten. Dieses
zieht man mit der Maus in das rechte Fenster (linker Rand der Textes muss im Fenster liegen). Nach
Druck auf OK kann man die Multiplizität bestimmen. Hier sollte man die Multiplizität für die
Sammlungsobjekte - hier also Objekte des Typs B - und nicht für die Datenansammlung, auf die sich
ja eigentlich der Bezeichner bezieht, angeben.
Das Ergebnis präsentiert sich dann so:
Hinweis
Gibt man im Datentypdialog an Stelle des Bezeichners Datenansammlung irgendeinen anderen
Klassennamen, beispielsweise Schlange, an, so wird dieser in der Anzeige durch Datenansammlung
ersetzt.
71
Umschalten zwischen Entwurfsdiagramm und Implementationsdiagramm
Man kann jederzeit eine Paketanzeige zwischen Entwurfsdiagramm und Implementationsdiagramm
umschalten, indem man das Häkchen neben der entsprechenden Option setzt oder entfernt.
Um Missverständnissen vorzubeugen:
Dies hat nicht zur Folge, dass aus einem Implementationsdiagramm ein Entwurfsdiagramm wird oder
umgekehrt.
Dennoch, die Umschaltung unterstützt die Konvertierung der Diagrammtypen ein wenig:
Umschaltung Entwurfsdiagramm Implementationsdiagramm
Die Anzeige des Typs Zahl wird durch den ursprünglich eingegebene einfachen Datentyp ersetzt (s.o.)
bzw. durch „int“, wenn direkt Zahl eingegeben wurde. Im letzteren Fall kann man durch Änderung
des Attributs oder der Methode eine geeignete Implementierung vornehmen.
Text wird durch String und Wahrheitswert durch boolean ersetzt.
Datenansammlung wird durch den ursprünglich angegeben Typ ersetzt, ansonsten bleibt
Datenansammlung bestehen. Dieser Typ kann über die Attributänderung ersetzt werden.
Bei Assoziationen wird die Anzeige der Multiplizitäten ausgeblendet.
Was manuell angepasst werden muss:
Assoziationen zu Sammlungstypen müssen verborgen werden:
Pfad aktivieren durch anklicken und Kontextmenü des Pfades aufrufen
72
Ändern des Typs der Datenansammlung in List:
Dialog mit OK quittieren
Jetzt wird die Klasse List angezeigt und ein Assoziationspfeil von A nach List gezogen.
73
Schließlich wird der Sammlungstyp bei List notiert:
Die Umschaltung des Entwurfsdiagramms in ein Implementationsdiagramm kann ein erster Schritt
bei der Erstellung des Implementationsdiagramms sein. Es ist dann nicht erfordelich bereits
vorhandene Klassen und Beziehungen komplett neu zu modellieren. Man sollte jedoch das Modell
mit dem Entwurfsdiagramm unter einem eigenen Namen abspeichern, bevor man an die
Umwandlung in Angriff nimmt.
Umschaltung Implementationsdiagramm Entwurfsdiagramm
Die Anzeige primitiver Zahltypenwird durch den Typ Zahl ersetzt. String wird durch Text und boolean
durch Wahrheitswert ersetzt.
Die Anzeige von Sammlungstypen wird durch Datenansammlung ersetzt.
Bei Assoziationen wird die Anzeige der Multiplizitäten eingeblendet, sie muss gegebenenfalls
angepasst werden.
Der Umgang mit den Datenansammlungen erfordert manuelles Eingreifen. Kurz die Schritte:
Ist eine Assoziation zu einer Datenansammlung dargestellt, sollte der zugehörige Pfeil zum Typ der
Datenansammlung entfernt werden. Anschließend wird der Inhaltstyp angezeigt und ein Pfeil zum
Inhaltstyp erzeugt.
Die Generierung eines Entwurfsdiagramms aus einem Implementationsdiagramm entspricht
natürlich nicht der Vorgehensweise bei der Modellierung. Sie kann jedoch hilfreich sein,
beispielsweise wenn man Klassen importiert hat und für unterrichtliche Zwecke Entwurfsdiagramme
dazu benötigt.
74
Der UMLEDiTOR als Plugin von BlueJ
Der UMLEDiTOR kann in BlueJ als Plugin benutzt werden. Dazu wird die zugehörige Datei in das
Verzeichnis lib/extensions von BlueJ kopiert.
Der Editor wird über den Menüpunkt Werkzeuge|UMLEditorJ82017 gestartet:
Die Benutzung des Editors bezüglich der Entwürfe unterscheidet sich nicht von der der Anwendung.
Es kommt jedoch ein neues Menü „BlueJ“ hinzu, der die Kommunikation mit Bluej betrifft:
Bei Auswahl dieses Menüs wird eine Reihe von Menüpunkten angezeigt:
75
Die Bedeutung der Menüpunkte
Neues Projekt erzeugt ein neues BlueJ-Projekt.
Projekt öffnen erlaubt es, ein vorhandenes BlueJ-Projekt in BlueJ zu öffnen.
Die beiden Menüpunkt dienen dem Zweck, das zu den Modellquellen passende Projekt in BlueJ zur
Verfügung zu haben.
Über den dritten Menüpunkt „Klassen des Modells im Projekt erstellen“ können Quelltexte zu dem
Modell einem BlueJ-Projekt hinzugefügt werden. Bei Auswahl dieses Menüpunktes werden alle
zurzeit in BlueJ geöffneten Projekte angezeigt. Nach Auswahl eines Projektes werden zu allen Klassen
des Modells JAVA-Quelltexte erzeugt und in dem gewählten Projekt abgelegt. Die Quelltexte werden
zur unmittelbaren Bearbeitung in BlueJ-Editorfenstern angezeigt.
Modellbeschreibung in Projektordner exportieren exportiert die Modellbeschreibung direkt in den
Ordner des gewünschten Projekts. Somit entfällt ein umständliche Ordnersuche, die bei Wahl des
entsprechenden Untermenüs von „Datei“ erforderlich wäre..
Modellbeschreibung aus Projektordner importieren ermöglicht den Import einer
Modellbeschreibung aus dem Ordner des gewünschten Projekts, falls sich dort eine befindet.
Import von JAVA Dateien aus Projekt erlaubt die direkte Anwahl von JAVA-Dateien aus einem
offenen Projekt für einen Import in das Modell.
Import von Class Dateien aus Projekt erlaubt die direkte Anwahl von Class-Dateien aus einem
offenen Projekt für einen Import in das Modell.
76
Schlussbemerkung
Die Anleitung berücksichtigt den Stand des Programms zum 11.11.2015. Es werden nicht alle Aspekte
aber doch die für einen Einsatz des Programmes grundlegenden beschrieben. Im Laufe der Zeit wird
die Anleitung ergänzt und bei Programmänderungen angepasst werden. Zur Weiterentwicklung des
Programms und – noch wichtiger – zur Fehlerbeseitigung bitte ich um Rückmeldungen und Hinweise.
Ich würde mich freuen, wenn Ihnen das Programm gefällt und es hilfreich für Ihre Arbeit ist.
Wesel 11.11.2015
Georg Dick