Georg Dick
UMLEDiTOR Anleitung
(Mai 2013)
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A2 -
Inhalt
Einführung ........................................................................................................................................... 4
Übersicht über die Eigenschaften des Editors ..................................................................................... 4
Aufbau der Programmoberfläche ....................................................................................................... 5
Entwurf einer Klasse ............................................................................................................................ 8
Erzeugen einer Klasse ...................................................................................................................... 8
Klassenrechteck positionieren und manuell dimensionieren ......................................................... 9
Attributeingabe ............................................................................................................................. 10
Anzeigereihenfolge der Attribute oder Methoden im Klassenrechteck ändern ........................... 11
Methodeneingabe ......................................................................................................................... 15
Ändern von Attributen und Methoden ......................................................................................... 17
Darstellung von Klassen, die im Modell bereits vorhanden sind. ................................................. 20
Speichern und Laden des Modells des Modells ................................................................................ 27
Assoziationen .................................................................................................................................... 28
Erstellen von Assoziationen ........................................................................................................... 28
Ändern der Attributanzeige ........................................................................................................... 31
Anzeige von Assoziationen zu vorhandenen Attributen ............................................................... 33
Pfad ändern ................................................................................................................................... 36
Vererbung .......................................................................................................................................... 37
Erzeugen einer Vererbungsbeziehung .......................................................................................... 37
Festlegung eines Sammlungstyps für eine Datenansammlung ......................................................... 40
Hinweise zu Datenansammlungen im UMLEDiTOR ...................................................................... 42
Anzeigevorgaben ............................................................................................................................... 45
Beispiel: Darstellung mit Standardoptionen ................................................................................. 49
Änderung der Schrift ..................................................................................................................... 51
Import von Klassen ............................................................................................................................ 51
Beispiel für einen Import ............................................................................................................... 53
Hinweis .......................................................................................................................................... 55
Entwurfs- und Implementationsdiagramme ..................................................................................... 65
Der Sonderfall Datenansammlung ................................................................................................ 66
Hinweis .......................................................................................................................................... 68
Umschalten zwischen Entwurfsdiagramm und Implementationsdiagramm ................................ 69
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A3 -
Der UMLEDiTOR als Plugin von BlueJ ................................................................................................ 72
Die Bedeutung der Menüpunkte ................................................................................................... 73
Schlussbemerkung ............................................................................................................................. 73
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A4 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A5 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A6 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A7 -
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A8 -
Entwurf einer Klasse
Erzeugen 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 später ändern.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A9 -
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.
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.
Oberklasse als externe
Klasse
Neue Klasse „A“ als
interne Klasse
Klassenrechteck für „A“
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A10 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A11 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A12 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A13 -
Beispiel:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A14 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A15 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A16 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A17 -
Ä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
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A18 -
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A19 -
Analog zur Änderung von Attributen erfolgt die der Methoden:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A20 -
Methodenänderungsdialog
Darstellung 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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A21 -
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.
Ausgabe erzeugen/bearbeiten
Bei der Ausgabe als Pixelgrafik (Bitmap) kann man zwei Optionen wählen.
- Ausgabe als Bitmap
- Ausgabe als Bitmap mit Punkten für fehlende Zeilen.
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A22 -
Ferner besteht die Möglichkeit einer einfachen Postscriptausgabe.
Nach Wahl der Bitmapausgabe öffnet sich ein Fenster mit der generierten Grafik.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A23 -
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.
Von dieser Grafik kann man mit Hilfe der Maus einen Ausschnitt bestimmen:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A24 -
Der Ausschnitt kann gespeichert, in die Zwischenablage kopiert, gedruckt oder gespeichert (jpg, gif
oder png) werden. Das Bild kann zudem auf den Ausschnitt zugeschnitten werden.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A25 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A26 -
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A27 -
Speichern und Laden des Modells des Modells
Speichern und Laden eines Modells erfolgt mit Hilfe des Dateimenüs:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A28 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A29 -
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A30 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A31 -
Ä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“
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A32 -
Möchte man das Attribut „bobjekt“ nicht anzeigen, so verschiebt man es mit der Maus vom rechten
ins linke Teilfenster.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A33 -
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“.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A34 -
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
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A35 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A36 -
(3) Assoziationen verbergen
Verbirgt alle Assoziationen.
Pfad ä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
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A37 -
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.
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 Entwurfssfenster angezeigt:
Man wählt die Auswahl „Vererbung“:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A38 -
Nun zieht man die Maus von der Unterklasse zur Oberklasse
Es wird anschließend die Vererbungsbeziehung erzeugt.
Zyklische Vererbungsbeziehungen werden zurückgewiesen.
Besteht bereits eine Vererbungsbeziehung zu einer anderen Klasse, so wird diese durch die neue
ersetzt:
Beispiel:
Wechsel von B nach C
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A39 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A40 -
Festlegung eines Sammlungstyps für eine Datenansammlung
Die folgende Beschreibung gilt nur für Implementationsdiagramme, in Entwurfsdiagrammen ist diese
Aufgliederung nicht vorgesehen.
Sollen Objekt der Klasse A mehrere Objekte der Klasse B verwenden und diese mit Hilfe einer
Datenansammlung (Liste, Keller, Baum etc.) 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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A41 -
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A42 -
Nach Verlassen des Dialogs mit OK wird der Sammlungstyp als Notiz dargestellt:
Hinweise zu Datenansammlungen 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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A43 -
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A44 -
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 ist 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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A45 -
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
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A46 -
Lokale an eine Klassenanzeige gebundene Vorgaben
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A47 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A48 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A49 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A50 -
Nach der Übernahme dieser Einstellungen präsentiert sich das Diagramm wie folgt:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A51 -
Ä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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A52 -
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.
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A53 -
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
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A54 -
man einen Klassenpfad zu den Dateien angeben, bzw. eine Jar-Datei, in der die Klassen enthalten
sind auflisten.
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A55 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A56 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A57 -
Über eine Baumauswahl können die Klassen für die Anzeige ausgewählt werden:
Die ausgewählten Klassen werden zunächst mit fester Größe in Reihen dargestellt. Sie müssen
anschließend mit der Maus arrangiert werden.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A58 -
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A59 -
Man kann sie beispielsweise zunächst auf der Arbeitsfläche verteilen und ihre Darstellungsgröße
minimieren:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A60 -
Mit Hilfe des Kontextmenüs kann man nun vorhandene Assoziationen anzeigen lassen:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A61 -
Aus dieser Anzeige kann man nun Hinweise für ein übersichtliches Layout gewinnen und mit der
Maus erstellen:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A62 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A63 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A64 -
Für eine optimierte Darstellung kann man jetzt den Inhalt dynamisch an die Größe anpassen und
dann die Ausgabe erzeugen:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A65 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A66 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A67 -
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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A68 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A69 -
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
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A70 -
Ä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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A71 -
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.
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A72 -
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|UMLEditor 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:
Aufgaben und Aufgabenideen zu Entwurfs- und Implementationsdiagrammen
- A73 -
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 „Modell in Projekt exportieren“ kann das Modell dann in BlueJ
weiterverarbeitet 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.
Schlussbemerkung
Die Anleitung berücksichtigt den Stand des Programms zum 13.5.2013. 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.
13.5.2013
Georg Dick
Top Related