web-dev-qa-db-de.com

Sollte ich die Verwendung von set (Preferred | Maximum | Minimum) Size-Methoden in Java Swing vermeiden?

Ich wurde mehrmals kritisiert, weil ich vorgeschlagen habe, folgende Methoden anzuwenden:

  1. setPreferredSize
  2. setMinimumSize
  3. setMaximumSize

auf Swing Komponenten. Ich sehe keine Alternative zu ihrer Verwendung, wenn ich Proportionen zwischen angezeigten Komponenten definieren möchte. Mir wurde das gesagt:

Bei Layouts ist die Antwort immer gleich: Verwenden Sie ein geeignetes LayoutManager

Ich habe das Internet ein wenig durchsucht, aber keine umfassende Analyse des Themas gefunden. Ich habe also folgende Fragen:

  1. Sollte ich die Verwendung dieser Methoden vollständig vermeiden?
  2. Die Methoden wurden aus einem bestimmten Grund definiert. Wann soll ich sie benutzen? In welchem ​​Zusammenhang? Zu welchen Zwecken? 
  3. Was genau sind die negativen Folgen dieser Methoden? (Ich kann mir nur vorstellen, Portabilität zwischen Systemen mit unterschiedlicher Bildschirmauflösung hinzuzufügen).
  4. Ich glaube nicht, dass ein LayoutManager alle gewünschten Layout-Anforderungen exakt erfüllen kann. Muss ich wirklich einen neuen LayoutManager für jede kleine Variation meines Layouts implementieren? 
  5. Wenn die Antwort auf 4 "ja" ist, führt dies nicht zu einer zunehmenden Verbreitung von LayoutManager-Klassen, deren Pflege schwierig wird.
  6. Kann ich in einer Situation, in der ich die Proportionen zwischen untergeordneten Elementen einer Komponente definieren muss (z. B. child1 sollte 10% des Speicherplatzes verwenden, child2 40%, child3 50%), dies erreichen, ohne einen benutzerdefinierten LayoutManager zu implementieren?
457
Heisenbug
  1. Sollte ich die Verwendung dieser Methoden vollständig vermeiden?

    Ja für den Anwendungscode.

  2. Die Methoden wurden aus einem bestimmten Grund definiert. Wann soll ich sie benutzen? In welchem ​​Zusammenhang? Zu welchen Zwecken?

    Ich weiß es nicht, persönlich halte ich es für einen API-Design-Unfall. Leichter Zwang durch zusammengesetzte Komponenten, die spezielle Vorstellungen von Kindergrößen haben. "Leicht", weil sie ihre Anforderungen mit einem benutzerdefinierten LayoutManager hätte implementieren sollen.

  3. Was genau sind die negativen Folgen dieser Methoden? (Ich kann mir nur vorstellen, Portabilität zwischen Systemen mit unterschiedlicher Bildschirmauflösung hinzuzufügen.)

    Einige (unvollständige und leider durch die Migration von SwingLabs zu Java.net bestehende Links) werden aus technischen Gründen beispielsweise in den Rules (hehe) oder in den link @bendicott in/gefunden. ihr Kommentar zu meiner Antwort . Stellen Sie sich sozial auf, dass Sie Ihrem unglücklichen Kollegen, der den Code aufrechterhalten und ein defektes Layout aufspüren muss, tonnenweise Arbeit stellen.

  4. Ich glaube nicht, dass ein LayoutManager alle gewünschten Layout-Anforderungen exakt erfüllen kann. Muss ich wirklich einen neuen LayoutManager für jede kleine Variation meines Layouts implementieren?

    Ja, es gibt LayoutManager, die stark genug sind, um eine sehr gute Annäherung an "alle Layoutanforderungen" zu erfüllen. Die großen drei sind JGoodies FormLayout, MigLayout und DesignGridLayout. Nein, in der Praxis schreiben Sie selten LayoutManager mit Ausnahme von einfachen hochspezialisierten Umgebungen.

  5. Wenn die Antwort auf 4 "ja" ist, führt dies nicht zu einer zunehmenden Verbreitung von LayoutManager-Klassen, deren Pflege schwierig wird. 

    (Die Antwort auf 4 lautet "Nein".)

  6. Kann ich dies in einer Situation, in der ich die Proportionen zwischen den untergeordneten Elementen einer Komponente definieren muss (z. B. 10% des Platzes, 2 40% des Kindes, 3% des Kindes 3%), ohne Implementierung eines benutzerdefinierten LayoutManagers erreichen?

    Jeder der Großen Drei kann, kann nicht einmal GridBag (nie wirklich zu meistern, zu viel Ärger für zu wenig Leistung).

231
kleopatra

Einige Heuristiken:

  • Verwenden Sie set[Preferred|Maximum|Minimum]Size() nicht, wenn Sie get[Preferred|Maximum|Minimum]Size() wirklich überschreiben wollen, wie Sie dies beim Erstellen Ihrer eigenen Komponente tun können (hier hier ).

  • Verwenden Sie set[Preferred|Maximum|Minimum]Size() nicht, wenn Sie sich auf den sorgfältig überschriebenen getPreferred|Maximum|Minimum]Size einer Komponente verlassen könnten, wie hier hier und unten gezeigt.

  • Verwenden Sie set[Preferred|Maximum|Minimum]Size(), um die post -validate()-Geometrie abzuleiten, wie unten gezeigt, und here .

  • Wenn eine Komponente keine bevorzugte Größe hat, z. Bei JDesktopPane müssen Sie möglicherweise die Größe des Containers ändern, aber diese Auswahl ist beliebig. Ein Kommentar kann helfen, die Absicht zu klären.

  • Erwägen Sie alternative oder benutzerdefinierte Layouts, wenn Sie feststellen, dass Sie viele Komponenten durchlaufen müssen, um abgeleitete Größen zu erhalten, wie in diesen comments erwähnt.

enter image description here

import Java.awt.Component;
import Java.awt.Dimension;
import Java.awt.EventQueue;
import Java.awt.GridLayout;
import Java.awt.KeyboardFocusManager;
import Java.beans.PropertyChangeEvent;
import Java.beans.PropertyChangeListener;
import Java.util.ArrayList;
import Java.util.List;
import javax.swing.JComponent;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

/**
 * @see https://stackoverflow.com/questions/7229226
 * @see https://stackoverflow.com/questions/7228843
 */
public class DesignTest {

    private List<JTextField> list = new ArrayList<JTextField>();
    private JPanel panel = new JPanel();
    private JScrollPane sp = new JScrollPane(panel);

    public static void main(String args[]) {
        EventQueue.invokeLater(new Runnable() {

            @Override
            public void run() {
                DesignTest id = new DesignTest();
                id.create("My Project");
            }
        });
    }

    private void addField(String name) {
        JTextField jtf = new JTextField(16);
        panel.add(new JLabel(name, JLabel.LEFT));
        panel.add(jtf);
        list.add(jtf);
    }

    private void create(String strProjectName) {
        panel.setLayout(new GridLayout(0, 1));
        addField("First Name:");
        addField("Last Name:");
        addField("Address:");
        addField("City:");
        addField("Zip Code:");
        addField("Phone:");
        addField("Email Id:");
        KeyboardFocusManager.getCurrentKeyboardFocusManager()
            .addPropertyChangeListener("permanentFocusOwner",
            new FocusDrivenScroller(panel));
        // Show half the fields
        sp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
        sp.validate();
        Dimension d = sp.getPreferredSize();
        d.setSize(d.width, d.height / 2);
        sp.setPreferredSize(d);

        JInternalFrame internaFrame = new JInternalFrame();
        internaFrame.add(sp);
        internaFrame.pack();
        internaFrame.setVisible(true);

        JDesktopPane desktopPane = new JDesktopPane();
        desktopPane.add(internaFrame);

        JFrame frmtest = new JFrame();
        frmtest.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frmtest.add(desktopPane);
        frmtest.pack();
        // User's preference should be read from Java.util.prefs.Preferences
        frmtest.setSize(400, 300);
        frmtest.setLocationRelativeTo(null);
        frmtest.setVisible(true);
        list.get(0).requestFocusInWindow();
    }

    private static class FocusDrivenScroller implements PropertyChangeListener {

        private JComponent parent;

        public FocusDrivenScroller(JComponent parent) {
            this.parent = parent;
        }

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            Component focused = (Component) evt.getNewValue();
            if (focused != null
                && SwingUtilities.isDescendingFrom(focused, parent)) {
                parent.scrollRectToVisible(focused.getBounds());
            }
        }
    }
}
97
trashgod

Sollte ich die Verwendung dieser Methoden vollständig vermeiden?

Nein, es gibt keine formellen Beweise dafür, dass das Aufrufen oder Überschreiben dieser Methoden nicht zulässig ist. In der Tat sagt Oracle, dass diese Methoden zum Angeben von Größenhinweisen verwendet werden: http://docs.Oracle.com/javase/tutorial/uiswing/layout/using.html#sizealignment .

Sie können auch überschrieben werden (dies ist die bewährte Methode für Swing), wenn Erweitern eine Swing-Komponente ist (anstatt die Methode in der benutzerdefinierten Komponenteninstanz aufzurufen).

Unabhängig davon, wie Sie die Größe Ihrer Komponente festlegen, müssen Sie sicherstellen, dass der Container der Komponente einen Layout-Manager verwendet, der die angeforderte Größe der Komponente berücksichtigt. 

Die Methoden wurden aus einem bestimmten Grund definiert. Wann sollte ich sie verwenden? In welchem ​​Zusammenhang? Zu welchen Zwecken?

Wenn Sie den Containern angepasste Größenhinweise geben müssen, wird der Layout-Manager so verwendet, dass die Komponente gut angeordnet ist

Was genau sind die negativen Folgen dieser Methoden? (Ich kann mir nur vorstellen, Portabilität zwischen Systemen mit unterschiedlicher Bildschirmauflösung hinzuzufügen).

  • Viele Layout-Manager beachten nicht die angeforderte maximale Größe einer Komponente. BoxLayout und SpringLayout tun dies jedoch. Außerdem bietet GroupLayout die Möglichkeit, die minimale, bevorzugte oder maximale Größe explizit einzustellen, ohne die Komponente zu berühren.

  • Stellen Sie sicher, dass Sie die genaue Größe der Komponente wirklich festlegen müssen. Jede Swing-Komponente hat eine andere bevorzugte Größe, abhängig von der verwendeten Schriftart und dem Erscheinungsbild. Eine festgelegte Größe kann daher zu unterschiedlichen Looks der Benutzeroberfläche auf verschiedenen Systemen führen

  • manchmal können Probleme mit GridBagLayout und Textfeldern auftreten. Wenn die Größe des Containers kleiner als die bevorzugte Größe ist, wird die Mindestgröße verwendet, wodurch Textfelder erheblich schrumpfen können.

  • JFrame erzwingt nicht das Überschreiben von getMinimumSize(), indem nur setMinimumSize(..) aufgerufen wird

Ich glaube nicht, dass ein LayoutManager alle gewünschten Layouts genau erfüllen kann braucht. Muss ich wirklich einen neuen LayoutManager für jeden .__ implementieren? kleine Variation meines Layouts?

Wenn Sie mit implementieren meinen, dann verwenden Sie ja. Nicht eine LayoutManger kann alles abwickeln, jede LayoutManager hat ihre Vor- und Nachteile, so dass jede zusammen verwendet werden kann, um das endgültige Layout zu erstellen.

Referenz:

46
David Kroukamp

Hier gibt es viele gute Antworten, aber ich möchte ein wenig mehr über die Gründe hinzufügen warum Sie sollten diese normalerweise vermeiden (die Frage ist gerade in einem doppelten Thema erneut aufgetaucht):

Mit wenigen Ausnahmen können Sie bei Verwendung dieser Methoden wahrscheinlich die Benutzeroberfläche so optimieren, dass sie in einem bestimmten Erscheinungsbild (und mit Ihren systemspezifischen Einstellungen, z. B. Ihrer bevorzugten Desktop-Schriftart usw.) gut aussieht. Die Methoden selbst sind nicht von Natur aus böse, aber die typischen Gründe für ihre Verwendung sind . Sobald Sie mit der Optimierung von Pixelpositionen und -größen in einem Layout beginnen, besteht die Gefahr, dass die grafische Benutzeroberfläche auf anderen Plattformen beschädigt wird (oder zumindest schlecht aussieht).

Versuchen Sie als Beispiel, das Standard-Look-and-Feel Ihrer Anwendung zu ändern. Selbst mit den auf Ihrer Plattform verfügbaren Optionen können Sie überrascht sein, wie schlecht die Ergebnisse gerendert werden können.

Um Ihre GUI auf allen Plattformen funktionsfähig und ansprechend zu halten (denken Sie daran, dass einer der Hauptvorteile von Java die plattformübergreifende Funktionalität ist), sollten Sie sich auf Layout-Manager usw. verlassen. um die Größe Ihrer Komponenten automatisch anzupassen, damit sie außerhalb Ihrer spezifischen Entwicklungsumgebung korrekt gerendert werden.

Trotzdem können Sie sich durchaus Situationen vorstellen, in denen diese Methoden gerechtfertigt sind. Auch hier sind sie nicht von Natur aus böse, aber ihre Verwendung ist normalerweise eine große rote Flagge, die auf potenzielle GUI-Probleme hinweist. Stellen Sie nur sicher, dass Sie sich des hohen Komplikationspotenzials bewusst sind, wenn Sie sie verwenden, und überlegen Sie immer, ob es eine andere, vom Erscheinungsbild unabhängige Lösung für Ihre Probleme gibt. In den meisten Fällen werden Sie diese finden Methoden sind nicht erforderlich.

Übrigens, wenn Sie mit Standard-Layout-Managern frustriert sind, gibt es viele gute kostenlose Open-Source-Versionen von Drittanbietern, zum Beispiel JGoodies 'FormLayout oder MigLayout . Einige GUI-Builder unterstützen sogar Layout-Manager von Drittanbietern - der WindowBuilder-GUI-Editor von Eclipse unterstützt beispielsweise FormLayout und MigLayout.

25
Jason C

Wenn Sie Probleme mit Layouts in Java Swing haben, kann ich die JGoodies FormLayout wärmstens empfehlen, die als Teil der Freeware-Bibliothek Forms von Karsten Lentzsch hier bereitgestellt wird.

Dieser sehr beliebte Layout-Manager ist äußerst flexibel und ermöglicht die Entwicklung sehr ausgefeilter Java-Benutzeroberflächen.

Sie finden die Dokumentation von Karsten in here und einige gute Dokumente von Eclipse hier .

19
Tom

Diese Methoden werden von den meisten Menschen kaum verstanden. Sie sollten diese Methoden auf keinen Fall ignorieren. Es ist Sache des Layout Managers, ob sie diese Methoden berücksichtigen. Diese Seite enthält eine Tabelle, die angibt, welche Layout-Manager welche dieser Methoden einhalten:

http://thebadprogrammer.com/swing-layout-manager-sizing/

Ich schreibe seit über 8 Jahren Swing-Code, und die im JDK enthaltenen Layout-Manager haben immer meine Bedürfnisse erfüllt. Ich habe noch nie einen Layout Manager von Drittanbietern benötigt, um meine Layouts zu erreichen.

Ich werde sagen, dass Sie nicht versuchen sollten, dem Layout-Manager mit diesen Methoden Hinweise zu geben, bis Sie sicher sind, dass Sie sie benötigen. Führen Sie Ihr Layout aus, ohne Hinweise zur Größenänderung zu geben (d.h. lassen Sie den Layout-Manager seine Arbeit erledigen), und Sie können bei Bedarf kleinere Korrekturen vornehmen.

16
Michael

Kann ich in einer Situation, in der ich die Proportionen zwischen den untergeordneten Elementen einer Komponente definieren muss (untergeordnetes Element 10%, untergeordnetes% 40%, untergeordnetes% 50%), das erreichen, ohne einen benutzerdefinierten Layout-Manager zu implementieren?

Vielleicht würde GridBagLayout Ihre Bedürfnisse befriedigen. Abgesehen davon gibt es im Internet eine Menge Layout-Manager, und ich wette, es gibt einen, der Ihren Anforderungen entspricht.

15
Thomas

Ich sehe es anders als die akzeptierte Antwort.

1) Sollte ich die Verwendung dieser Methoden vollständig vermeiden?

Niemals meiden! Sie geben dem Layout-Manager die Größenbeschränkungen Ihrer Komponenten an. Sie können die Verwendung vermeiden, wenn Sie keinen Layout-Manager verwenden und versuchen, das visuelle Layout selbst zu verwalten.

Leider hat Swing keine vernünftigen Standardmaße. Anstatt die Abmessungen einer Komponente festzulegen, ist es jedoch besser OOP, die eigene Komponente mit angemessenen Standardwerten abzurufen. (In diesem Fall rufen Sie setXXX in Ihrer abgeleiteten Klasse auf.) Alternativ können Sie die getXXX-Methoden für denselben Effekt überschreiben.

2) Die Methoden wurden aus einem bestimmten Grund definiert. Wann soll ich sie benutzen? In welchem ​​Zusammenhang? Zu welchen Zwecken?

Immer. Wenn Sie eine Komponente erstellen, legen Sie ihre realistische Mindest-/Vorzugs-/Maximalgröße entsprechend der Verwendung dieser Komponente fest. Wenn Sie beispielsweise ein JTextField-Feld für die Eingabe von Ländersymbolen wie UK haben, sollte die bevorzugte Größe so groß sein, dass sie zwei Zeichen (mit der aktuellen Schriftart usw.) einschließt. Wahrscheinlich ist es jedoch sinnlos, sie größer werden zu lassen. Ländersymbole sind immerhin zwei Zeichen. Wenn Sie ein JTextField für die Eingabe von z. Ein Kundenname kann eine bevorzugte Größe für die Pixelgröße für 20 Zeichen haben, kann jedoch bei einer Größenänderung des Layouts größer werden. Setzen Sie die maximale Größe also auf mehr. Gleichzeitig ist ein JTextField mit einer Breite von 0px sinnlos. Legen Sie daher eine realistische Mindestgröße fest (ich würde die Pixelgröße von 2 Zeichen angeben).

3) Was genau sind die negativen Folgen dieser Methoden?

(Ich kann mir nur vorstellen, Portabilität zwischen Systemen mit unterschiedlicher Bildschirmauflösung hinzuzufügen).

Keine negativen Folgen. Dies sind Hinweise für den Layout-Manager.

4) Ich glaube nicht, dass ein LayoutManager alle gewünschten Layout-Anforderungen exakt erfüllen kann.

Muss ich wirklich einen neuen LayoutManager für jede kleine Variation meines Layouts implementieren?

Nein, definitiv nicht. Der übliche Ansatz besteht darin, verschiedene grundlegende Layoutmanager wie horizontale und vertikale Layouts zu kaskadieren.

Zum Beispiel das Layout unten:

<pre>
+--------------+--------+
| ###JTABLE### | [Add]  | 
| ...data...   |[Remove]|
| ...data...   |        |
| ...data...   |        |
+--------------+--------+
</pre>

hat zwei Teile. Der linke und der rechte Teil sind horizontal angeordnet. Der rechte Teil ist ein JPanel, der zum horizontalen Layout hinzugefügt wird, und dieser JPanel hat ein vertikales Layout, das die Schaltflächen vertikal anordnet.

Natürlich kann dies mit einem realen Layout schwierig werden. Grid-basierte Layout-Manager wie MigLayout sind daher viel besser, wenn Sie ernsthafte Entwicklungen vornehmen möchten.

5) Wenn die Antwort auf 4 "ja" ist, führt dies nicht zu einer Zunahme der LayoutManager-Klassen, deren Pflege schwierig wird.

Nein, Sie sollten auf keinen Fall Layout-Manager entwickeln, es sei denn, Sie benötigen etwas ganz Besonderes.

6) In einer Situation, in der ich Proportionen definieren muss ...

zwischen untergeordneten Elementen einer Komponente (z. B. sollte child1 10% des Speicherplatzes verwenden, child2 40%, child3 50%), ist dies ohne Implementierung eines benutzerdefinierten LayoutManagers möglich?

Wenn die bevorzugten Größen richtig eingestellt sind, möchten Sie im Prinzip nichts in Prozent tun. Ganz einfach, weil Prozentsätze sinnlos sind (z. B. ist ein JTextField-Wert von 10% der Fenstergröße sinnlos - da man das Fenster verkleinern kann, so dass JTextField eine Breite von 0px hat, oder das Fenster so erweitern kann, dass das JTextField auf zwei Anzeigen angezeigt wird Multi-Display-Setup).

Aber vielleicht können Sie die Prozentsätze verwenden, um die Größe größerer Bausteine ​​Ihrer GUI (z. B. Panels) zu steuern.

Sie können JSplitPane verwenden, wo Sie das Verhältnis der beiden Seiten vorgeben können. Sie können auch MigLayout verwenden, mit dem Sie solche Einschränkungen in Prozent, Pixeln und anderen Einheiten festlegen können.

6
Gee Bee

Sollte ich die Verwendung dieser Methoden vollständig vermeiden? Ich würde sie nicht "meiden". Ich würde sagen, wenn du denkst, dass du sie brauchst, machst du wahrscheinlich etwas falsch. Komponentengrößen werden im Kontext bestimmt. Die Größe von Textkomponenten wird beispielsweise durch die Anzahl der von Ihnen angegebenen Zeilen und Spalten in Kombination mit der von Ihnen gewählten Schriftart bestimmt. Die Schaltflächen- und Beschriftungsgröße entspricht der Größe der Grafik, sofern Sie eine festgelegt haben, oder dem Platz, der zum Anzeigen des von Ihnen festgelegten Texts benötigt wird. Jede Komponente hat eine natürliche Größe, und die Layout-Manager verwenden diese Elemente, um alles festzulegen, ohne dass Sie Größen angeben müssen. Die Hauptausnahme ist das JScrollPane, dessen Größe unabhängig von dessen Inhalt ist. Für diese rufe ich manchmal setSize() auf, und ich lasse die anfängliche Fenstergröße durch den Aufruf von JFrame.pack() bestimmen. Normalerweise lasse ich die Fenstergröße die JScrollPane-Größe bestimmen. Der Benutzer bestimmt die Größe des Fensters. Viele Layout-Manager ignorieren die von Ihnen eingestellten Größen trotzdem, sodass sie oft nicht viel bewirken.

Die Methoden wurden aus einem bestimmten Grund definiert. Wann soll ich sie benutzen? In welchem ​​Zusammenhang? Zu welchen Zwecken? Ich glaube, sie wurden hinzugefügt, um den Layout-Managern Hinweise zu geben. Sie wurden möglicherweise aus historischen Gründen geschrieben, weil Layout-Manager neu waren und die Leute ihnen nicht vollständig vertrauten. Ich kenne einige Entwickler, die Layout-Manager vermieden und alles manuell platziert haben, nur weil sie sich nicht mit dem Erlernen eines neuen Paradigmas beschäftigen wollten. Das ist eine schreckliche Idee.

Was genau sind die negativen Folgen dieser Methoden? (Ich kann mir nur vorstellen, Portabilität zwischen Systemen mit unterschiedlicher Bildschirmauflösung hinzuzufügen). Sie sind ineffektiv und produzieren schlechte Layouts, wobei Objekte auf nicht natürliche Größen gedrückt oder gestreckt werden. Und die Layouts werden spröde. Bei Änderungen der Fenstergröße wird das Layout manchmal beschädigt und an den falschen Stellen angezeigt.

Ich glaube nicht, dass ein LayoutManager alle gewünschten Layout-Anforderungen exakt erfüllen kann. Muss ich wirklich einen neuen LayoutManager für jede kleine Variation meines Layouts implementieren? Sie sollten keinen neuen LayoutManager "implementieren". Sie sollten vorhandene instanziieren. Ich verwende oft mehrere Layout-Manager in einem einzigen Fenster. Jedes JPanel hat einen eigenen Layout-Manager. Manche Leute lehnen verschachtelte Layouts ab, weil sie schwer zu warten sind. Wenn ich sie benutze, gebe ich jedem eine eigene Erstellungsmethode, um besser sehen zu können, was jeder tut. Ich "implementiere" jedoch niemals einen Layout-Manager. Ich instanziiere sie einfach. 

Wenn die Antwort auf 4 "ja" ist, führt dies nicht zu einer zunehmenden Verbreitung von LayoutManager-Klassen, deren Pflege schwierig wird. Wenn Sie neue Layout-Manager-Klassen für geringfügige Layout-Abweichungen implementieren, verwenden Sie sie falsch. Wenn Sie nur neue Layout-Manager implementieren, machen Sie wahrscheinlich etwas falsch. Das einzige Mal, wenn ich eine LayoutManager-Klasse erweitert habe, war das Hinzufügen eines Zoom-Schiebereglers zu einem JScrollPane.

In einer Situation, in der ich die Proportionen zwischen untergeordneten Elementen einer Komponente definieren muss (z. B. sollte child1 10% des Speicherplatzes verwenden, child2 40%, child3 50%), kann dies ohne Implementierung eines benutzerdefinierten LayoutManagers erreicht werden? Das JSplitPane kann den Prozentsatz angeben, den jede Komponente erhalten soll. Der Teiler ist standardmäßig verschiebbar, Sie können ihn jedoch deaktivieren, wenn Sie möchten. Ich benutze diese Funktion nicht viel. Ich habe normalerweise einige Komponenten, die eine festgelegte Größe einnehmen, und der Rest des Platzes wird von einem Bildlauffenster belegt. Die Bildlauffenstergröße wird an die Fenstergröße angepasst. Wenn Sie zwei Bildlauffenster nebeneinander haben, können Sie sie in ein JSplitPane einfügen und den Prozentsatz an neuem Speicherplatz angeben, der jedem zugewiesen wird, wenn der Benutzer die Fenster erweitert und zusammenzieht.

0
MiguelMunoz