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