Java Layout-Manager - hs-fulda. · PDF fileSeite: 3 / 16 Seminar: Java3D Java Layout-Manager...

Fachhochschule Fulda Fachbereich Angewandte Informatik

Hausarbeit Seminar: Java3D

Java Layout-Manager

WS 2002/2003

Verfasser: Marc Dziadek

[email protected]

Seite: 2 / 16

Seminar: Java3D Java Layout-Manager 20.10.2002

Marc Dziadek Memelstrasse 25a 36341 Lauterbach

Inhaltsverzeichnis

Inhaltsverzeichnis ....................................................................................................................... 2 1. Einleitung ............................................................................................................................... 3

1.1. Begriffsdefinitionen ........................................................................................................ 3 1.1.1. Oberfläche ................................................................................................................ 3 1.1.2. Komponente ............................................................................................................. 3 1.1.3. Anmerkung............................................................................................................... 3

1.2. Gründe für einen Layout-Manager.................................................................................. 3 1.3. Layout-Manager: Java-Packete....................................................................................... 4 1.4. Funktionsweise................................................................................................................ 4 1.5. Vorgehensweise .............................................................................................................. 5

2. Layout-Manager..................................................................................................................... 6 2.1. Flow-Layout .................................................................................................................... 6 2.2. Grid-Layout ..................................................................................................................... 7 2.3. Border-Layout ................................................................................................................. 8 2.4. GridBag-Layout .............................................................................................................. 9

2.4.1 GridBagConstraints ................................................................................................. 10 2.5. NULL-Layout ................................................................................................................ 13

3. Geschachtelte Layout-Manager............................................................................................ 14 4. Bewertung: ........................................................................................................................... 15 5. Quellen................................................................................................................................. 16

5.1. Literatur:........................................................................................................................ 16 5.2. Web-Quellen ................................................................................................................. 16

Seite: 3 / 16



1. Einleitung 1.1. Begriffsdefinitionen

1.1.1. Oberfläche In diesem Dokument werden unter dem Begriff Oberfläche alle Java-Objekte verstanden, die als Container für andere grafische Elemente (Komponenten) fungieren können und auf die Layoutmanager angewandt werden können. Dies sind beispielsweise JFrame, JWindow, JDialog, JPanel, etc.

1.1.2. Komponente Unter dem Begriff Komponente werden alle Java-Objekte verstanden, die auf einer Oberfläche registriert werden können. In diese Rubrik fallen unter anderem Dialogelemente (JButton, JTextField, JTextArea, JComboBox, etc.), grafische Gestaltungselemente (JLabel, JBorder, etc.) sowie Zeichenflächen (Graphics).

1.1.3. Anmerkung Oberflächen können ebenfalls bei anderen Oberflächen registriert werden. Aus Sicht der übergeordneten ist die zu registrierende Oberfläche eine Komponente. Aus Sicht der Komponente, die auf dieser Oberfläche registriert wird, weiterhin eine Oberfläche (vgl. geschachtelte Layout-Manager).

1.2. Gründe für einen Layout-Manager

In vielen grafischen Oberflächen wird die Anordnung der Elemente eines Dialoges durch Eingabe absoluter Koordinaten vorgenommen. Dabei wird für jede Komponente manuell oder mit Hilfe eines Ressourceneditors pixelgenau festgelegt, an welcher Stelle im Dialog sie zu erscheinen hat. Die Konzeption von Java, auf den unterschiedlichsten Plattformen mit den unterschiedlichsten Ausgabegeräten lauffähig zu sein, macht die oben genannte Vorgehensweise unbrauchbar. Die Größe der grafischen Elemente und der Schriften sind plattformabhängig. Eine feste Anordnung der Elemente würde zu einer uneinheitlichen, verzerrten und nicht nutzbaren Darstellung führen. Aus diesem Grund werden in Java Layout-Manager eingesetzt, die sich um die Anordnung der grafischen Elemente mit ihren zur Laufzeit spezifischen Größen und Formen kümmern. Somit ist gewährleistet, dass die grafische Oberfläche auf allen Systemen nutzbar und fehlerfrei dargestellt wird.

Ein einfacher Button in unterschiedlichen Layouts. Jeder Button hat eine unterschiedliche Größe.

Seite: 4 / 16



1.3. Layout-Manager: Java-Packete Sämtliche von Java bereitgestellten Layoutmanager befinden sich im Paket java.awt.* In einer Klasse lassen sie sich mit folgender Import-Anweisung einbinden: import java.awt.*; import java.awt.<<Layoutmanager>>; Diese Layoutmanager lassen sich sowohl beim AWT (Abstract Window Toolkit) als auch bei der Swing-Oberfläche verwenden.

1.4. Funktionsweise

Jeder Oberflächenkomponente wie JWindows, JPanel, etc. kann ein Layout-Manager zugeordnet werden. Dies geschieht über die Registrierungsmethode setLayout( Layout-Manager-Objekt ) des Oberflächenobjekts. Beim Einsatz unter swing ist zu beachten, dass die Methode setLayout() der contentPane (zu beschaffen über this.getContentPane()) benutzt werden muss, um den Layout-Manager zu registrieren. Einige Layout- Manager bieten zusätzlich die Möglichkeit individuell konfiguriert zu werden. Beispielsweise können Abstände, Ausrichtung, Aufteilung der Oberfläche, etc. angegeben werden. Wird jetzt eine grafische Komponente (JButton, JTextfield, etc.) bei der Oberfläche registriert, (add()-Methode) kümmert sich der zugewiesene Layout-Manager automatisch im Rahmen der angegebenen Regeln um die Anordnung der Komponente. Im Allgemeinen ist die Reihenfolge der Registrierung der grafischen Komponenten entscheidend für deren Anordnung durch den Layout-Manager. Nur bei Layout-Managern, bei denen zusätzlich Positionierungs-Informationen angegeben werden können, spielt die Reihenfolge der Registrierung keine Rolle. Wird die Fenstergröße zur Laufzeit vom Anwender geändert, wird der Layoutmanager wieder aktiv und ordnet die Komponenten erneut an, um immer die optimale Anordnung der Komponenten zu gewährleisten.

Seite: 5 / 16



1.5. Vorgehensweise Die Programmierung mit Layoutmanagern erfolgt in 3 Schritten, die bei allen zur Verfügung stehenden Layoutmanagern fast identisch sind. 1. Im ersten Schritt wird eine Instanz einer Layoutmanager-Klasse erzeugt. Die

meisten Layoutmanager-Klassen bieten Konstruktoren an, mit denen sich das Objekt bei der Instanzregierung mittels Übergabeparameter vorkonfigurieren lässt. Eine weitere Möglichkeit einen Layoutmanager zu konfigurie ren steht durch nachträgliches Setzen von Member-Variablen oder durch Nutzung von Member-Methoden zur Verfügung.

2. Dieses Objekt wird anschließend mittels der setLayout()-Methode des Oberflächenobjektes an die Oberfläche gebunden. Ab diesem Zeitpunkt kümmert sich der Layoutmanager um das Erscheinungsbild der Oberfläche.

3. Jetzt können Objekte von Komponenten erzeugt und über die Methode add( /*Komponentenreferenz*) bei der Oberfläche und damit auch beim Layoutmanager registriert werden. Eine explizite Registrierung beim Layoutmanager ist bis auf eine Ausnahme, dem GridBagLayout, nicht nötig.

4. Optional kann, wenn alle Komponenten registriert sind, der Layoutmanager über die Methode pack() des Oberflächenobjekts angewiesen werden, die Elemente am Platz sparendsten (unter Berücksichtigung aller Regeln) anzuordnen, um die kleinste mögliche Oberflächenausdehnung zu erreichen.

Beispiel: Es wird ein JFrame (Swing-Komponente) erzeugt, die den Layout-Manager „FlowLayout“ verwendet. Auf dem JFrame werden 2 JButton und 2 JTextField registriert, die dann vom Layout-Manager während der Laufzeit konkret p latziert werden.

Seite: 6 / 16



2. Layout-Manager

Java bietet zahlreiche Layout-Manager mit jeweils unterschiedlichen gestalterischen Fähigkeiten an. Welcher Layout-Manager verwendet werden soll, hängt von der konkreten Situation ab und ist vom Programmierer zu entscheiden. Um komplexere Layouts realisieren zu können, als die Layout-Manager sie einzeln zur Verfügung stellen, gibt es die Möglichkeit, Layout-Manager zu schachteln. Auf diese Weise kann auch ohne Vorgabe fester Koordinaten fast jede gewünschte Komponentenanordnung realisiert werden. Im Folgenden werden die in Java vorhandenen Layoutmanager vorgestellt.

2.1. Flow-Layout

Durch die Klasse Flow-Layout wird der einfachste Layout-Manager zur Verfügung gestellt. Dieser Manager ordnet die der Oberfläche zugewiesenen Komponenten der Reihe nach in einer Zeile an, bis der Platz nicht mehr ausreicht, eine weitere Komponente darzustellen. Die verbliebenen Komponenten werden nach dem gleichen Prinzip in der folgenden Zeile angeordnet. Die Reihenfolge in der die Elemente angeordnet werden, entspricht der Reihenfolge ihrer Registrierung. Dieser Layout-Manager bietet die Möglichkeit festzulegen, von welcher Seite aus eine Zeile aufgebaut wird (align) sowie wie viele Pixel der horizontale(hgap) und vertikalen(vgap) Abstand der einzelnen Komponenten mindestens zueinander betragen soll: Konstruktoren:

public FlowLayout() public FlowLayout(int align) public FlowLayout(int align, int hgap, int vgap)

Für den Übergabeparameter align bietet die Klasse FlowLayout die Konstanten FlowLayout.CENTER, FlowLayout.RIGHT, FlowLayout.LEFT, FlowLayout.LEADING, FlowLayout.TAILING an.

FlowLayoutExample.java 1. Der Layout-Manager ordnet die Komponenten gemäß den Regeln auf der Oberfläche an. 2. Wird die Größe der Oberfläche geändert, berechnet der Layout-Manager das Layout neu.

1.

2.

Seite: 7 / 16



2.2. Grid-Layout Dieser Layoutmanager bietet eine größere Kontrolle über die Anordnung der Elemente. Wie der Name schon vermuten lässt, wird mit Hilfe dieses Layoutmanagers die Oberfläche in ein Gitterraster aufgeteilt, wobei die einzelnen Zellen gleich groß sind. Die Zeilen- und Spaltenzahl können vom Programmierer vorgeben werden. Bei diesem Layoutmanager ist ebenfalls über die Parameter hgap und vgap festzulegen, wie viele Pixel Abstand zwischen den Komponenten mindestens eingehalten werden müssen. Der Nachteil dieses Layoutmanagers besteht darin, dass alle Zellen eine einheitliche Größe haben, und das Element einer Zelle auf die Größe der Zelle skaliert wird, und somit alle Elemente des Fensters die gleiche Größe besitzen. Wie im folgenden Beispiel zu sehen ist, ist die optische Wirkung unter Umständen sehr schlecht. Dieses Problem kann beispielsweise dadurch gelöst werden, das geschachtelte Layout-Manager verwendet werden (siehe Kapitel 3). Konstruktoren:

public GridLayout(); public GridLayout(int rows, int columns); public GridLayout(int rows, int columns, int hgap, int vgap);

GridLayoutExample.java Die erste Grafik zeigt das Fenster nach Erstellung. Die zweite Grafik zeigt das Fenster nach einer Größenänderung. Hier ist zu erkennen, dass die Buttons auf die Größe einer Zelle skalieren werden, was optisch schlecht aussieht.

Seite: 8 / 16



2.3. Border-Layout Der Layout-Manager Border-Layout unterteilt die ihm zugewiesene Oberfläche in fünf Bereiche und zwar die vier Ränder und das Zentrum, in denen Elemente platziert werden können. Diese Bereiche lassen sich mit folgenden Strings ansprechen:

• „North“ oberer Rand • „West“ linker Rand • „Center“ Mitte • „East“ rechter Rand • „South“ unterer Rand

Für die Spezifikation des Bereichs wird eine andere Version der überladenen add() Methode der Klasse Container verwendet:

add(String name, Component component) Da alle Oberflächenklassen von Container abgeleitet sind, stehen sie bei jeder Oberfläche direkt zur Verfügung. Dieser Layout-Manager hat ähnlich dem Grid-Layout die Eigenschaft, die in den jeweiligen Bereichen registrierte Komponente auf die gesamte Größe des Bereichs zu skalieren. Für den „North“ und „South“ Bereich gilt, dass die Originalhöhe der Komponenten erhalten bleibt und sie nur horizontal gestreckt werden; Für „East“ und „West“ bleibt die Breite erhalten, und die vertikale Ausdehnung wird angepasst. Der Bereich „Center“ verhält sich wie eine Zelle des Grid-Layouts und wird horizontal und vertikal skaliert. Aus diesem Grund wird dieser Layoutmanager, ebenso wie beim GridLayout, meist zusammen mit anderen Layoutmanagern verschachtelt eingesetzt. Konstruktoren:

public BorderLayout();

BorderLayoutExample.java Das erste Fenster zeigt die originale Anordnung der Komponenten mit minimaler Ausdehnung. Das zweite Fenster zeigt das Layout nach Skalieren. North- und South-Button behalten ihre Höhe, West- und East-Button behalten ihre Breite und der Center-Button wird horizontal und vertikal skaliert.

Seite: 9 / 16



2.4. GridBag-Layout Das GridBagLayout ist der aufwändigste Layoutmanager in Java. Mit ihm kann die Oberfläche sehr komplex und flexibel aufgebaut werden. Er erlaubt, im Gegensatz zu den anderen Layoutmanagern, eine sehr detaillierte Konfiguration der Komponenten bzw. der Oberfläche. Diese zusätzliche Leistungsfähigkeit hat aber auch ihren Preis. Der Einarbeitungsaufwand in diesen Layoutmanager ist um einiges höher, die Bedienung ist etwas umständlicher und komplizierter und um in der Praxis ein ansprechendes Layout erstellen zu können, ist einiges an Erfahrung nötig. Zu Beginn der Arbeit mit diesem Layoutmanager kommt es zu Ergebnissen, bei denen man nur in Staunen geraten kann. Meistens passt die angezeigte Darstellung in keinster Weise zu der, die man sich ausgedacht und geglaubt hat, programmiert zu haben. Man weiß gar nicht so recht wo die Probleme liegen, und es braucht einiges an Zeit, um durch Probieren zu dem Layout zu kommen, dass man von Anfang an programmieren wollte. Nach dieser Einarbeitungsphase bekommt man den Dreh schnell heraus und kann hervorragende Ergebnisse mit diesem Layoutmanager erzielen. Die Programmierung mit dem GridBagLayout unterteilt sich in die folgenden vier Schritte, wobei besonders auf die Schritte 2 und 3 zu achten ist, da sich diese Vorgehensweise im Vergleich zu den anderen Layoutmanagern unterscheidet:

1. Zunächst muss eine Instanz von GridBagLayout erzeugt und der Oberfläche zugewiesenen werden (wie gewohnt: setLayout()).

2. Für jede einzufügende Komponente muss ein Objekt des Typs GridBagConstraints erzeugt werden. Durch Setzen der Membervariablen dieses Objekts können die spezifischen Layouteigenschaften der assoziierten Komponente spezifiziert werden. Dies ist der Schritt, der die meisten Probleme und überraschende Layouts hervorruft und für einiges an Frustration sorgt.

3. Über die Methode setConstraints() des Layoutmanagers wird die Komponente und ihr Erscheinungsbild (Component, GridBagConstraints) beim Layoutmanager registriert.

4. Abschließend wird die Komponente, analog zu den anderen Layoutmanagern, mittels der add()-Methode der Oberfläche bei der Oberfläche registriert.

Konstruktoren:

public GridBagLayout() Arbeitsweise: Das GridBagLayout unterteilt die Oberfläche -ähnlich dem GridLayout- in ein Raster rechteckiger Zellen. Der Vorteil des GridBagLayouts besteht darin, dass die Zellen unterschiedliche Größen haben können. Ein weiterer Vorteil besteht darin, dass die Komponenten auf verschiedenste Weise in den Zellen platziert werden können und nicht zwangsläufig den gesamten Platz der Zellen einnehmen müssen. Des Weiteren können sich die Komponenten horizontal wie vertikal über mehrere Zeilen/Spalten erstrecken (siehe Beispiel).

Seite: 10 / 16



2.4.1 GridBagConstraints Wie zuvor schon erwähnt handelt es sich bei GridBagConstraints um die eigentliche komplizierte Klasse, die zu ungeahnten Frustrationen führen kann. Eine falsche Handhabung führt zu den kuriosesten Layouts, was in der Einarbeitungsphase nur durch stundenlanges Probieren in den Griff zu bekommen ist. Im Folgenden werden die einzelnen Konfigurationsparameter kurz vorgestellt. Ein sicherer Umgang mit ihnen ist nur durch praktische Anwendung und der daraus resultierenden Erfahrung zu erreichen. Konstruktoren: public GridBagConstraints() public GridBagConstraints(int gridx, int gridy, int gr idwidth, int gridheight, double weightx, double weighty, int anchor, int fill, Insets insets, int ipadx, int ipady) gridx gibt an, in welcher Spalte des logischen Gitters der linke Rand der

Komponente liegen soll. Die erste Spalte hat den Wert 0. gridy gibt an, in welcher Zeile des logischen Gitters der obere Rand der

Komponente liegen soll. Die erste Zeile hat den Wert 0. gridwidth gibt an, über wie viele Spalten sich eine Komponente erstrecken soll. gridhight gibt an, über wie viele Spalten sich eine Komponente erstrecken soll. wheightx/y diese Parameter sind etwas trickreich. Sie geben das Verhältnis an, in

dem überschüssiger Platz auf die Zellen einer Zeile bzw. einer Spalte verteilt wird. Ist der Wert 0, so bekommt die Zelle nichts von eventuell überschüssigen Platz ab. Es ist nicht die Größe des Wertes sondern das Verhältnis aller angegebenen Werte zueinander entscheidend. Sind beispielsweise alle Werte 0 und ein einziger 0.001, so bekommt diese Zelle dennoch den gesamten überschüssigen Platz.

anchor gibt an, wie eine Komponente innerhalb einer Zelle ausgerichtet wird. Die Klasse GridBagConstraints bietet für diese Parameter Konstanten an (EAST, WEST, NORTWEST...).

fill gibt an, in welche Richtung die zugeordnete Komponente skaliert werden darf. Hier stellt die Klasse GridBagConstraints ebenfalls Konstanten zur Verfügung (NONE, HORIZONTAL…).

insets gibt den Abstand in Pixel an, den die Komponente zu benachbarten Komponenten mindestens einhalten muss.

ipadx/y mit diesen Parametern kann ein konstanter Wert zur minimalen Breite und Höhe der Komponente hinzugefügt werden.

Seite: 11 / 16



Tipp: Um nicht immer den umständlichen Zugriff (siehe Beispiel-JavaKlasse) auf die Konstanten der Klasse durchführen zu müssen, bietet es sich an, die Klasse zu überschreiben und zusätzliche Konstruktoren hinzuzufügen, die an Stelle der Konstanten kurze Strings akzeptieren, und diese dann intern in die Konstanten übersetzen. Des weiteren bietet es sich an, Konstruktoren zu implementieren, die nur eine Auswahl der oben angeführten Parameter benötigen, um situationsgebunden nicht immer alle (inklusive der oft nicht benötigten) Parameter angeben zu müssen.

Seite: 12 / 16



Beispiel: Als Beispiel wird ein Fenster erzeugt, in dem 3 Komponenten (2 JButton, 1 JTextArea) mittels des Layoutmanagers GridBagLayout angeordnet werden. Der 1. JButton befindet sich in der ersten Zeile (Koordinaten 0/0), ist NORTHWEST ausgerichtet, erstreckt sich über drei Spalten und ist horizontal skalierbar. An Position (0/1) wird eine JTextArea platziert, die ebenfalls die Ausrichtung NORTHWEST besitzt und eine Ausdehnung von zwei Zeilen und zwei Spalten hat, sowie horizontal und vertikal skalierbar ist. Der 2. JButton befindet sich in Zelle (2/2), ist mit SOUTHEAST ausgerichtet, nicht skalierbar und nimmt nur den Platz einer Zelle ein. Die vom Layoutmanager automatisch angelegte Zelle (1/2) bleibt ungenutzt.

Schematische Darstellung:

logische Zellenbegrenzung: reale Zellenbegrenzung:

Menüleiste

--------------JButton, 3 Spalten-------------------

JButton, SOUTHEAST

unbenutzt JTextArea, 2 Spalten, 2 Zeilen

GridBagLayout.java Diese Grafiken zeigen das Originalfenster sowie das Fenster nach einer Größenänderung. Es ist zuerkennen, wie sich der erste JButton horizontal und sich die JTextArea horizontal und vertikal der veränderten Größe anpasst. Beide Komponenten bleiben links oben (NORTHWEST) verankert. Der 3. JButton behält seine Größe bei und bleibt rechts unten (SOUTHEAST) verankert.

0

1

2 0 1 2

Seite: 13 / 16



2.5. NULL-Layout Beim Null-Layout verwendet die Oberfläche keinen Layout-Manager. Für die Positionierung der Komponenten ist die Anwendung und damit der Programmierer selbst verantwortlich. Ein Null-Layout wird einer Oberfläche zugewiesen indem die Methode setLayout() mit dem Parameter null aufgerufen wird: setLayout(null); Beim Null Layout sind für jede Komponente vier Schritte auszuführen:

1. Erzeugen der Komponente 2. Festlegen der Position und der Größe 3. Registrieren der Komponente bei der Oberfläche 4. Explizite Angabe der Fenstergröße

Die Punkte 1. und 3. verhalten sich also analog zu der Vorgehensweise bei den bereits vorgestellten Layoutmanagern. Beim zweiten Schritt legt der Programmierer die exakte Größe und Position der Komponente fest. Dies kann über die Methode setSize() und setLocation() oder einfacher über die Methode setBounds() der Komponente erledigt werden. Schritt 4 ist nötig, da eine automatische Größenanpassung mittels pack() bei diesem Layout nicht funktioniert. Die Fenstergröße in Pixel muss mittels der Funktion this.setSize() manuell angegeben werden. Dieses Layout ist nur dann sinnvoll, wenn sichergestellt ist, dass die Darstellung auf allen Systemen korrekt funktioniert.

1.

3.

2.

NullLayoutExample.java Abbildung 1. zeigt das Fenster, dessen Größe durch pack() bestimmt wurde. Abbildung 2. zeigt das Fenster mit manuell vergebener Größe. Die registrierten Komponenten befinden sich an den vom Programmierer spezifizierten Positionen. Der Programmierer ist dafür verantwortlich, dass die Anfangsgröße so gewählt wird, dass alle Komponenten sichtbar sind. In Abbildung 3. ist zu erkennen, dass eine Größenänderung des Fensters keine Neuberechnung des Layouts bewirkt. Die Komponenten bleiben fest an den zugewiesenen Positionen und hängen ggf. außerhalb des Fensters.

Seite: 14 / 16



3. Geschachtelte Layout-Manager Wie oben schon angedeutet, ist es in den meisten Fällen sinnvoll, Layoutmanager zu schachteln. Im Folgenden soll kurz die prinzipielle Vorgehensweise verdeutlicht werden. Alle Layoutmanager unterteilen die ihnen zugewiesene Oberfläche in Bereiche. Sollen in einigen dieser Bereiche separate Layoutmanager eingesetzt werden, so muss diesen Bereichen zunächst ein neues Oberflächenobjekt in Form eines JPanels zugewiesen werden. Dieses Panel-Objekt kann dann wie ein unabhängiges Oberflächen-Objekt behandelt werden, das seinen eigenen Layoutmanager und seine eigenen Komponenten besitzt. Auf diesem Panel kann wiederum ein Layoutmanager geschachtelt werden, so dass prinzipiell beliebige Schachtelungstiefen möglich sind. Von einer zu tiefen Schachtelung ist allerdings abzuraten, da die Oberfläche sonst sehr Leistungshungrig und träge wird.

JFrame, GridLayout

JPanel, BorderLayout

JPanel, GridLayout

JPanel, GridBagLayout

Seite: 15 / 16



4. Bewertung: Um in der Eigenschaft von Java plattformunabhängig zu sein und auch der Darstellung der Oberfläche Rechnung zu tragen, sind die Layoutmanager ein exzellentes und unabdingbares Hilfsmittel. Mit ihnen wird erreicht, dass sich der Programmierer nicht allzu viele Sorgen um die Lauffähigkeit seiner Programme auf den unterschiedlichsten Systemen machen muss. Im Extremfall wäre es somit ohne Probleme möglich, die Applikation beispielsweise auf einem Java-fähigen Toaster laufen zu lassen. Die Nachteile dieser Technik sollen allerdings nicht verschwiegen werden: Der gravierendste Nachteil der Layoutmanager besteht darin, dass es viel Mühe und Zeit kostet, die Oberfläche so zu gestalten, wie sich der Programmierer das vorstellt. Im Vergleich zu der klassischen Oberflächengestaltung ist der zeitliche Mehraufwand nicht zu unterschätzen. Ein weiteres Problem tritt bei sehr komplexen Layouts auf. Durch das Schachteln vieler Layoutmanager, die alle miteinander interagieren müssen, wird die Oberfläche sehr träge. Durch geschickte Vorgehensweise, was wiederum einige Erfahrung voraussetzt, kann dieser Effekt stark minimiert werden. Der Einsatz von Layoutmanagern ersetzt allerdings nicht das Testen der Oberfläche auf den unterschiedlichen Einsatzsystemen. Was, subjektiv betrachtet, auf einem System hervorragend ausschaut, kann auf einem anderen System vollkommen unbrauchbar sein. Beispielsweise führen falsch eingeschätzte bzw. nicht erkannte Abhängigkeiten zu solch einem Ergebnis. Abschließend lässt sich sagen, dass die Vorteile die die Layoutmanager bieten, die höhere Einarbeitungs- und Designzeit auf jeden Fall rechtfertigen. Bei Programmen, die für plattformunabhängigen Betrieb konzipiert sind, ist der Einsatz unabdingbar! Sollte man bei solchen Programmen auf deren Einsatz verzichten, ist zu beachten, dass man für jedes Betriebssystem ein eigenes Layout erstellen muss. Die Zeitersparnis wäre also eher minimal. Oberflächen mit Layoutmanagern bieten dann aber den Vorteil, dass Änderungen prinzipiell nur an einer Stelle durchgeführt werden müssen, anstatt für jedes Betriebssystem das entsprechende Layout ändern zu müssen.

Seite: 16 / 16



5. Quellen

5.1. Literatur: GoTo Java 2, 2. Auflage, Guido Krüger, Addison-Wesley Java professionell, Gerhard Wilhelms, Markus Kopp, MITP-Verlag

5.2. Web-Quellen http://java.sun.com http://www.java3d.org

Java Layout-Manager - hs-fulda. · PDF fileSeite: 3 / 16 Seminar: Java3D Java Layout-Manager...

Documents

Transcript of Java Layout-Manager - hs-fulda. · PDF fileSeite: 3 / 16 Seminar: Java3D Java Layout-Manager...