In diesem kurzen Artikel möchte ich den Prozess der Erstellung eines kleinen Programms beschreiben, das GUI in der Sprache unterstützt Java. Es wird davon ausgegangen, dass der Leser mit den Grundlagen der Sprache vertraut ist. Java.

Also, welche Werkzeuge brauchen wir:

• Java Virtual Machine (OpenJDK oder Oracle JDK)
• Intellij IDEA (oder eine andere IDE für Java)

Öffnen Sie nach der Installation der erforderlichen Software IntelliJ-IDEE und erstellen Sie ein neues Projekt: Datei -> Neues Projekt…

Ich habe das Projekt benannt guiBase. Wie Sie auf dem Screenshot sehen können, ist der Ordner Quelle enthält nichts, also erstellen wir darin unsere Hauptklasse, die die Funktion enthält hauptsächlich.

Öffentliche Klasse Main ( public static void main(String args) ( System.out.println("Hello, Govzalla!"); ) )

Siehe den Inhalt der Hauptklasse oben. Wir können jetzt ein Projekt erstellen ( Projekt bauen ) und führe es aus ( Laufen ). Unten im Terminal Ihres IDE Sie werden eine Nachricht sehen Hallo Govzalla!. Aber wie Sie selbst verstanden haben, wird die GUI nicht unterstützt.

Zu diesem Zeitpunkt haben wir bereits ein funktionierendes Programm, jedoch ohne GUI-Unterstützung. Und jetzt im selben Ordner Quelle schaffen GUI-Formular: Neu -> GUI-Formular

Öffnen Sie das erstellte GUI-Formular, klicken Sie auf jPanel und stellen Sie seine Kennung in das Feld ein Feldname, Ich fragte Tafel.

Ziehen Sie dann per Drag & Drop auf das Formular auf der rechten Seite JTextField, JPasswordField und jButton:

Es bleibt, den Code hinzuzufügen und unser Formular damit zu verknüpfen. Als wir das Formular hinzugefügt haben Hauptfenster, wurde die Klasse automatisch erstellt Hauptfenster, diese Klasse ist die Klasse des generierten Formulars, d.h. diese Klasse dient allen Ereignissen der gegebenen Form.

Obwohl unsere Fensterklasse die notwendigen Elemente enthält, hat sie auch jetzt noch nichts mit der GUI zu tun, also erweitern wir sie mit jRahmen und erben alle grundlegenden und notwendigen Funktionen der GUI .

BEI dieser Moment Wir haben das Formular Hauptfenster und Klasse Hauptfenster verlängert mit jRahmen. Jetzt müssen wir alle hinzugefügten GUI-Elemente als Klasseninhalt definieren Hauptfenster this.getContentPane().add(panel); Danach wird der Inhalt der Datei MainWindow.java wie folgt geändert:

javax.swing.* importieren; öffentliche Klasse MainWindow erweitert JFrame ( privates JTextField textField1; privates JPasswordField passwordField1; privates JButton button1; privates JPanel-Panel; öffentliches MainWindow() ( this.getContentPane().add(panel); ) )

Wenn Sie versuchen, den Code auszuführen, sehen Sie erneut die gleiche „Hello, Govzalla!“-Nachricht. Es handelt sich darum, dass wir die Klasse und die Form dazu geschaffen haben, aber die Instanz dieser Klasse nicht geschaffen haben.

Es ist an der Zeit, die Datei Main.java zu ändern und den Code zum Erstellen unserer GUI dort hinzuzufügen:

java.awt.* importieren; public class Main ( public static void main(String args) ( // Erstellen Sie eine Instanz der MainWindow-Klasse MainWindow mainWindow = new MainWindow(); // Packen Sie alle Elemente aus unserem Formular mainWindow.pack(); // Passen Sie die Größe des Fensters an mainWindow.setSize( new Dimension(200, 200)); // Das erstellte Fenster anzeigen mainWindow.setVisible(true); ) )

Ausführen des Codes

Wenn Sie auf den Button klicken, werden Sie feststellen, dass das Programm in keiner Weise reagiert. Die Sache ist, wir haben den Listener noch nicht hinzugefügt ( Hörer) für Veranstaltungen ( Veranstaltungen) der Schaltfläche.

Ereignis-Listener ( Ereignis-Listener) jButton muss eine Adapterimplementierung sein ActionListener, fügen Sie also den folgenden Code zum Hauptteil der Klasse hinzu Hauptfenster:

Private Klasse MyButtonListener implementiert ActionListener ( @Override public void actionPerformed(ActionEvent actionEvent) ( ) )

Methode Handlung ausgeführt() verarbeitet alle Button-Ereignisse von button1, aber zuerst müssen Sie button1 noch mitteilen, welche Klasse es verarbeiten soll, also fügen Sie den folgenden Code zum MainWIndow-Klassenkonstruktor hinzu: this.button1.addActionListener(new MyButtonListener()); Damit unser Handler nicht bedeutungslos wird, fügen Sie der Methode den folgenden Code hinzu Handlung ausgeführt():

@Override public void actionPerformed(ActionEvent actionEvent) ( if (textField1.getText().equals(passwordField1.getText())) ( JOptionPane.showMessageDialog(null, "Success"); ) else ( JOptionPane.showMessageDialog(null, "Failure "); ) )

Jetzt reagiert das Programm korrekt auf Ereignisse, natürlich nicht auf alle Ereignisse. Wenn Sie beispielsweise versuchen, das Programm durch Klicken auf das Kreuz zu deaktivieren, verschwindet das Fenster, aber das Programm funktioniert weiterhin, weil. Hauptfenster-Event-Handler nicht hinzugefügt.

Davydov Anton Walerjewitsch
Student der TSU, Russland, Togliatti
Wissenschaftlicher Leiter: Erofeeva E.A.

Die Benutzerschnittstelle in Java hat einen sehr dornigen Entstehungs- und Entwicklungsweg durchlaufen. Seine lange Zeit beschuldigt, gierig nach Systemressourcen zu sein, langsame Arbeit und eingeschränkte Funktionalität. Das Aufkommen von .NET mit schnelleren grafischen Komponenten hat die Position von Java weiter erschüttert. Aber ein solcher Wettbewerb spornte Java-Entwickler nur an, Grafikbibliotheken zu entwickeln und zu verbessern. Und in diesem Artikel werden wir sehen, was dabei herausgekommen ist.

Abstraktes Fenster-Toolkit

Das Abstract Window Toolkit (kurz AWT) wurde erstmals 1995 von Sun Microsystems veröffentlicht. Es war der erste Versuch, eine GUI für Java zu erstellen. AWT fungierte als Schicht, die Methoden aus in C geschriebenen Bibliotheken aufrief. Und diese Methoden verwendeten wiederum grafische Komponenten Betriebssystem. Einerseits sah ein so gebautes Programm optisch allen anderen Programmen auf dem verwendeten Betriebssystem ähnlich, andererseits kann dasselbe Programm auf verschiedenen Betriebssystemen völlig unterschiedlich aussehen, was die Entwicklung erschwert. Außerdem war es aus Gründen der Multiplattform notwendig, die Aufrufschnittstellen von Komponenten zu vereinheitlichen, was zu einer etwas eingeschränkten Funktionalität führte. Auch die Ausstattung ist recht bescheiden. Beispielsweise gibt es keine Tabellen, und Symbole können nicht in Schaltflächen platziert werden. AWT versucht, verbrauchte Ressourcen automatisch freizugeben. Dies wirkt sich auf die Leistung aus und verkompliziert die Architektur. AWT ist leicht zu erlernen, aber etwas Komplexes zu schreiben ist schwierig. Jetzt wird AWT hauptsächlich für Applets verwendet. Oracle ermutigt derzeit Entwickler, auf Swing umzusteigen, da es sicherer ist.

Abb.1 - Ein Beispielprogramm, das mit AWT in einer Windows-Umgebung geschrieben wurde

Nach AWT veröffentlichte Sun 1998 Swing. Es ist vollständig in Java geschrieben und verwendet 2D zum Rendern. Swing hat eine viel größere Auswahl an Komponenten als AWT. Die Komponenten selbst sind viel einfacher zu erstellen, indem sie von bestehenden . Die Möglichkeit, verschiedene Stile und Skins zu verwenden, wurde ebenfalls eingeführt. Allerdings ist die Geschwindigkeit der Arbeit frühe Versionen Der Swing war ziemlich niedrig, und Fehler beim Schreiben eines Programms konnten sogar zum Einfrieren des Betriebssystems führen.

Allerdings aufgrund der Leichtigkeit des Lernens und der Verfügbarkeit eine große Anzahl Dokumentation ist Swing zur beliebtesten GUI in Java geworden. Darauf basierend sind viele Erweiterungen wie SwingX und JGoodies erschienen, die es noch einfacher machen, visuell komplexe Anwendungen zu erstellen. Alle modernen Java-Programmierumgebungen enthalten grafischer Editor Schwingen. Auch wenn es mittlerweile modernere Frameworks gibt, bleibt Swing das beliebteste.

Abb. 2 - Mit Swing geschriebenes Beispielprogramm

Standard-Widget-Toolkit

SWT wurde von IBM zu einer Zeit veröffentlicht, als Swing noch langsam war, und hauptsächlich, um die Eclipse-Programmierumgebung zu fördern. Wie AWT verwendet SWT OS-Komponenten, aber für verschiedene Plattformen werden unterschiedliche Interoperabilitätsschnittstellen verwendet. Daher muss für jedes Betriebssystem eine eigene JAR-Bibliothek ausgeliefert werden. Dadurch können Sie die den verschiedenen Betriebssystemen entsprechenden Funktionen umfassender nutzen. Und die fehlenden Komponenten wurden in 2D umgesetzt. SWT erwies sich jedoch als schwieriger zu meistern als Swing. Außerdem muss der Programmierer die Freigabe von Ressourcen durch die Anwendung selbst umsetzen.

Abb.3 - Mit Swing geschriebenes Beispielprogramm

JavaFX wurde 2008 von Oracle veröffentlicht. Es ist als Plattform für die Erstellung einer reichhaltigen Internetanwendung positioniert. Für das Rendern wird eine Grafikpipeline verwendet, die die Anwendung erheblich beschleunigt. Es gibt eine große Auswahl an integrierten Komponenten. Es gibt auch separate Komponenten zum Zeichnen von Diagrammen. Implementierte Unterstützung für Multimedia-Inhalte, Animationen und sogar Multi-Touch. Das Erscheinungsbild von Komponenten wird mithilfe von CSS-Stilen konfiguriert. Darüber hinaus umfasst der Satz von JavaFX-Dienstprogrammen die Möglichkeit, ein natives Installationsprogramm für die gängigsten Plattformen zu erstellen: exe oder msi für Windows, deb oder rpm für Linux, dmg für Mac. Auf der Oracle-Website finden Sie eine ausführliche Dokumentation und eine große Anzahl vorgefertigter Beispiele.

Nachdem wir also die Hauptmerkmale und Nachteile der oben genannten grafischen Benutzeroberflächen beschrieben haben, können wir entscheiden, für welche Aufgaben sie am besten geeignet sind. Das Abstract Window Toolkit eignet sich besser zum Erstellen von Applets. Ein Anfänger kann Swing angesichts der Tatsache empfehlen, dass Sie im Internet eine riesige Menge an Dokumentation dafür finden, auch in russischer Sprache. JavaFX eignet sich hervorragend zum Erstellen von Rich-Internet-Anwendungen.

Liste der verwendeten Quellen

Ryzhenko A. V. Objektorientierte Programmierung: Bildungs- und Methodenkomplex für die Disziplin für das Fachgebiet 010501 - "Angewandte Mathematik und Informatik". – 2007.

Khabibullin I. Sh. Java 7 (4. Aufl.). - BHV-Petersburg, 2012.

Clarke J., Connors J., Bruno E. J. JavaFX: Entwicklung von Rich-Internet-Anwendungen. – Pearson-Bildung, 2009.

Northover S., Wilson M. Swt: Das Standard-Widget-Toolkit, Band 1. - Addison Wesley Professional, 2004.

Die grafische Schnittstelle in Java hat einen sehr dornigen Weg der Entwicklung und Gestaltung durchlaufen. Lange Zeit wurde ihm langsame Arbeit, Gier nach Systemressourcen und eingeschränkte Funktionalität vorgeworfen.

Java-AWT

Suns erster Versuch einer GUI für Java war die Bibliothek AWT(Abstract Window Toolkit) - ein Toolkit zum Arbeiten mit verschiedenen Fensterumgebungen. Sun hat eine Java-Schicht erstellt, die Methoden aus in C geschriebenen Bibliotheken aufruft. Die Methoden der AWT-Bibliothek erstellen und verwenden die grafischen Komponenten der Betriebsumgebung. Das ist einerseits gut, da ein Java-Programm anderen Programmen innerhalb desselben Betriebssystems ähnlich ist. Wenn Sie es jedoch auf einer anderen Plattform ausführen, kann es zu Unterschieden in der Größe von Komponenten und Schriftarten kommen, die beschädigt werden Aussehen Programme.

Um Multi-Plattform zu gewährleisten AWT Komponentenaufrufschnittstellen wurden vereinheitlicht, was zu einer leicht reduzierten Funktionalität führt. Und der Satz von Komponenten erwies sich als ziemlich klein. Beispielsweise gibt es in AWT keine Tabellen, und Symbole werden in Schaltflächen nicht unterstützt. Allerdings das Paket java.awt von der allerersten Version an in Java enthalten und kann zum Erstellen von GUIs verwendet werden.

Also die Komponenten AWT keine „Arbeit“ machen. Es ist nur ein "Java-Wrapper" für die Steuerelemente des Betriebssystems, auf dem sie ausgeführt werden. Alle Anfragen an diese Komponenten werden an das Betriebssystem umgeleitet, das die ganze Arbeit erledigt.

Gebrauchte Ressourcen AWT versucht, automatisch freizugeben. Dies verkompliziert die Architektur etwas und beeinträchtigt die Leistung. Etwas Ernsthaftes mit AWT zu schreiben, wird etwas schwierig sein. Jetzt wird es nur für Applets verwendet.

Grundlegende SWING-Konzepte

Nach AWT Sun hat eine Grafikkomponentenbibliothek entwickelt Schwingen, komplett in Java geschrieben. Für das Rendern wird 2D verwendet, was gleich mehrere Vorteile mit sich bringt. Bausatz Standardkomponentenübertrifft AWT in Vielfalt und Funktionalität deutlich. Swing macht es einfach, neue Komponenten zu erstellen, indem es von bestehenden erbt, und unterstützt eine Vielzahl von Stilen und Skins.

Schöpfer der neuen UI-Bibliothek Schwingen haben das Rad nicht neu erfunden und AWT als Basis für ihre Bibliothek gewählt. Natürlich sprachen wir nicht über die Verwendung spezieller schwergewichtiger AWT-Komponenten (repräsentiert durch die Klassen Button, Label und ähnliche). Nur Leichtbauteile sorgten für das erforderliche Maß an Flexibilität und Steuerbarkeit. Das Vererbungsdiagramm zeigt die Beziehung zwischen AWT und Swing.

Der wichtigste Unterschied Schwingen von AWT ist, dass Swing-Komponenten überhaupt nicht mit dem Betriebssystem verbunden sind und daher viel stabiler und schneller sind. Solche Komponenten werden in Java als leichtgewichtig bezeichnet, und das Verständnis der Grundprinzipien ihrer Funktionsweise trägt wesentlich dazu bei, die Funktionsweise von Swing zu erklären.

Container auf oberster Ebene schwenken

Um eine grafische Oberfläche für eine Anwendung zu erstellen, müssen Sie spezielle Komponenten der Swing-Bibliothek verwenden, die als Container bezeichnet werden. Höchststufe(Container der obersten Ebene). Sie sind Betriebssystemfenster, die Komponenten der Benutzeroberfläche hosten. Zu den Top-Level-Containern gehören die JFrame- und JWindow-Fenster, das JDialog-Dialogfeld und das JApplet-Applet (das kein Fenster ist, aber auch dazu gedacht ist, eine Schnittstelle in dem Browser anzuzeigen, der dieses Applet ausführt). Swing-Container der obersten Ebene sind schwergewichtige Komponenten und bilden eine Ausnahme von der allgemeinen Regel. Alle anderen Swing-Komponenten sind leicht.

Einfach Schwingen Beispiel einer Fensteroberfläche jRahmen.

java.awt.Dimension importieren; javax.swing.JFrame importieren; javax.swing.JLabel importieren; public class JFrameTest ( public static void createGUI() ( JFrame frame = new JFrame("Test frame"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JLabel label = new JLabel("Test label"); frame.getContentPane(). add(label); frame.setPreferredSize(new Dimension(200, 100)); frame.pack(); frame.setVisible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); javax. swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( createGUI(); ) )); ) )

Konstrukteur JFrame() ohne Parameter erzeugt ein leeres Fenster. Konstrukteur JFrame(String-Titel) erzeugt ein leeres Fenster mit Titel title. Erschaffen das einfachste Programm bei einem leeren Fenster müssen die folgenden Methoden verwendet werden:

• setSize(int width, int height) - definiert die Größe des Fensters;
• setDefaultCloseOperation(int operation) - Definition der Aktion bei Programmbeendigung;
• setVisible(boolean visible) - macht das Fenster sichtbar.

Wenn Sie die Größe des Fensters nicht definieren, hat es eine Nullhöhe, unabhängig davon, was sich darin befindet. Die Abmessungen des Fensters umfassen nicht nur die "Arbeitsfläche", sondern auch die Ränder und die Titelleiste.

Die Methode setDefaultCloseOperation definiert die auszuführende Aktion beim "Beenden des Programms". Übergeben Sie dazu die in der Klasse JFrame beschriebene Konstante EXIT_ON_CLOSE als Operationsparameter.

Standardmäßig wird das Fenster unsichtbar erstellt. Um das Fenster auf dem Bildschirm anzuzeigen, wird die Methode setVisible mit dem Parameter true aufgerufen. Wenn Sie es mit dem falschen Parameter aufrufen, wird das Fenster unsichtbar.

GUI Java-Swing Beispiel für die Fenstererstellung jRahmen in der folgenden Abbildung dargestellt.

Um die Bibliothek zu verbinden Schwingen Die Anwendung muss die Bibliothek importieren javax.swing.

Jedes Mal, wenn ein Top-Level-Container erstellt wird, sei es ein normales Fenster, ein Dialogfeld oder ein Applet, erstellt der Konstruktor des Containers JRootPane-Root-Panel. Swing-Container der obersten Ebene stellen sicher, dass andere Komponenten nicht außerhalb des JRootPane „kriechen“ können.

Wurzel blass JRootPane fügt Behältern eine "Tiefe"-Eigenschaft hinzu, die die Möglichkeit bietet, Komponenten nicht nur übereinander zu platzieren, sondern sie bei Bedarf auch auszutauschen, die Tiefe der Komponenten zu erhöhen oder zu verringern. Diese Funktion ist erforderlich, wenn Sie eine Anwendung mit mehreren Dokumenten erstellen. Schwingen, deren Fenster übereinander gestapelte Lightweight-Komponenten darstellen, sowie Dropdown-Menüs (Kontextmenüs) und QuickInfos.

Die folgende Abbildung zeigt deutlich den Aufbau des Root-Panels JRootPane.

Root-Panel JRootPane ist ein Container, der von der Swing JComponent-Basisklasse erbt. In diesem Container ist ein spezieller Layout-Manager, implementiert in der internen Klasse RootPaneLayout, für das Layout der Komponenten zuständig. Dieser Layout-Manager ist dafür verantwortlich, sicherzustellen, dass alle Bestandteile des Root-Panels so platziert werden, wie sie sein sollten: das geschichtete Panel nimmt den gesamten Raum des Fensters ein; sein FRAME_CONTENT_LAYER enthält die Menüleiste und das Inhaltsfeld und darüber ein transparentes Feld.

Alle Komponenten des Root-Panels JRootPane erhalten oder geändert werden können. Dafür gibt es eine Reihe von Get/Set-Methoden. Programmatisch JRootPane kann mit der Methode getRootPane() abgerufen werden.

Zusätzlich zu Top-Level-Containern wird das Stammfenster in internen JInternalFrame-Fenstern verwendet, die in Anwendungen mit mehreren Dokumenten erstellt wurden und sich auf dem „Desktop“-JDesktopPane befinden. Dadurch können Sie vergessen, dass es sich bei diesen Fenstern um gewöhnliche leichte Komponenten handelt, und mit ihnen arbeiten, als wären sie echte Container der obersten Ebene.

Layered Panel JLayeredPane

An der Basis der Wurzelplatte (Container) liegt die sogenannte Schichtplatte JLayeredPane nimmt alles ein verfügbarer Platz Container. In diesem Panel befinden sich alle anderen Teile des Root-Panels, einschließlich aller Komponenten der Benutzeroberfläche.

JLayeredPane Wird verwendet, um dem Container eine Tiefeneigenschaft hinzuzufügen. Das heißt, mit dem Multilayer-Panel können Sie eine dritte Dimension im Container organisieren, entlang der sich die Layer (Layer) der Komponente befinden. In einem normalen Container wird die Position einer Komponente durch ein Rechteck bestimmt, das anzeigt, wie viel des Containers die Komponente einnimmt. Beim Hinzufügen einer Komponente zu einem Multilayer-Panel müssen Sie nicht nur das von der Komponente belegte Rechteck angeben, sondern auch die Ebene, in der sie sich befinden wird. Eine Ebene in einem mehrschichtigen Panel wird durch eine ganze Zahl definiert. Je größer die Zahl, die die Schicht definiert, desto höher ist die Schicht.

Die erste dem Behälter hinzugefügte Komponente ist höher als die später hinzugefügten Komponenten. Meistens befasst sich der Entwickler nicht mit den Positionen der Komponenten. Wenn Sie Komponenten hinzufügen, ändert sich deren Position automatisch. Das mehrschichtige Bedienfeld ermöglicht es Ihnen jedoch, die Position der Komponenten dynamisch zu ändern, nachdem sie dem Container hinzugefügt wurden.

Layered-Panel-Fähigkeiten werden von einigen Komponenten häufig verwendet Schwingen. Sie sind besonders wichtig für Anwendungen mit mehreren Dokumenten, QuickInfos und Menüs. Multidokument Schwingen Anwendungen verwenden einen speziellen Container JDesktopPane("Desktop") geerbt von JLayeredPane A, das innere Schwingfenster hält. Die wichtigsten Funktionen einer Multi-Document-Anwendung - Positionierung des "aktiven" Fensters über anderen, Minimierung von Fenstern, Ziehen - werden durch die Mechanismen des geschichteten Panels bereitgestellt. Der Hauptvorteil der Verwendung eines mehrschichtigen Panels für Tooltips und Menüs ist ihre Geschwindigkeit. Anstatt für jede QuickInfo oder jedes Menü ein neues schweres Fenster zu erstellen, das sich über der Komponente befindet, in der die QuickInfo oder das Menü angefordert wurde, Schwingen schafft ein schnelles Leichtbauteil. Diese Komponente wird in einer ausreichend hohen Ebene des geschichteten Panels darüber im Stapel aller anderen Komponenten platziert und wird verwendet, um einen Tooltip oder ein Menü anzuzeigen.

Mit dem Multi-Layer-Panel können Sie eine unbegrenzte Anzahl von Ebenen organisieren. Struktur JLayeredPane enthält mehrere Standardebenen, die von allen Swing-Komponenten verwendet werden und die Sie bereitstellen können richtige Arbeit alle Mechanismen der Mehrschichtplatte. Standard-JLayeredPane-Layer sind in der folgenden Abbildung dargestellt.

Die Standardebene wird verwendet, um alles unterzubringen herkömmliche Komponenten, die dem Container hinzugefügt werden. Diese Ebene enthält die internen Fenster von Anwendungen mit mehreren Dokumenten.

Die Palettenebene dient dazu, Fenster mit einer Reihe von Werkzeugen zu hosten, die normalerweise den Rest der Benutzeroberfläche überlappen. Mit dem JDesktopPane-Panel können Sie solche Fenster erstellen, die sie auf dieser Ebene platzieren.

Die modale Schicht sollte einfache modale Dialogfelder hosten. Solche Dialogfelder sind jedoch noch nicht implementiert, sodass diese Ebene derzeit nicht in Swing verwendet wird.

Die am häufigsten verwendete Ebene für Popup-Menüs und QuickInfos.

Die oberste Schicht. Vorgesehen für Drag-and-Drop-Operationen ( ziehen und ablegen drop), die in der Programmoberfläche deutlich sichtbar sein sollten.

Ein kleines Beispiel für ein JLayeredPane mit einem geschichteten Panel zeigt, wie Komponenten zu verschiedenen Ebenen hinzugefügt werden und wie die Ebenen übereinander gestapelt werden:

javax.swing.* importieren; java.awt.* importieren; // Klasse zum Zeichnen von zwei Typen von Figuren mit Textklasse Figure erweitert JComponent ( private static final long serialVersionUID = 1L; private Farbe Farbe; privater int-Typ; privater String-Text; // Parameter: Farbe und Abbildungstyp Figure(Color color, int type, String text) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g ) ( // Zeichnen der Form g.setColor(color); switch (type) ( case 0: g.fillOval(0, 0, 90, 90); break; case 1: g.fillRect(0, 0, 130, 80 ); break; ) g.setColor(Color.yellow); g.drawString(text, 10, 35); ) ) public class JLayeredPaneTest erweitert JFrame ( private static final long serialVersionUID = 1L; public JLayeredPaneTest() ( // create ein Fenster super("Example LayeredTest"); // beenden, wenn das Fenster geschlossen wird setDefaultCloseOperation(EXIT_ON_CLOSE); // Definition eines geschichteten Panels JLayeredPane lp = getLayeredPane(); // drei Formen erstellen Figure figure1 = new Figure(Color.red , 0, "Figure popup"); Figure figure2 = new Figure(Color.blue, 0, "Figure 1"); Figure figure3 = new Figure(Color.cyan, 1, "Figure 2"); // Finde die Formen im Fenster figure1.setBounds (10, 40, 12 0,120); figure2.setBounds(60, 120, 160, 180); figure3.setBounds(90, 55, 250, 180); // Hinzufügen von Formen zu verschiedenen Ebenen lp.add (figure1, JLayeredPane.POPUP_LAYER); lp.add (Abbildung 2, JLayeredPane.PALETTE_LAYER); lp.add (Abbildung 3, JLayeredPane.PALETTE_LAYER); // Position einer der Figuren ändern lp.setPosition(figure3, 0); // Größe ermitteln und Fenster öffnen setSize(280, 250); setVisible(true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new JLayeredPaneTest(); ) )

Das Beispiel erstellt ein kleines Fenster jRahmen und mehrere Abbildungskomponenten werden dem geschichteten Panel hinzugefügt. Um ein mehrschichtiges Panel in einem beliebigen Swing-Container der obersten Ebene zu erhalten, rufen Sie einfach die Methode auf getLayeredPane().

Die Helper-Klasse Figure erbt die Eigenschaften der JComponent-Basisklasse und ermöglicht es Ihnen, zwei Arten von Formen (Kreise und Rechtecke) mit unterschiedlichen Farben zu zeichnen. Parameter zum Zeichnen von Formen werden im Klassenkonstruktor festgelegt.

Beim Definieren einer Schnittstelle werden drei verschiedenfarbige Formen (zwei Kreise und ein Rechteck) erstellt. Der Kreis wird in der Ebene POPUP_LAYER platziert, und die Rechtecke werden in der Ebene PALETTE_LAYER platziert. Beim Platzieren von Komponenten werden deren absolute Bildschirmkoordinaten angegeben, da die üblichen Positionsmanager nicht in einem geschichteten Panel arbeiten.

Am Ende wird die Position eines der Rechtecke so geändert, dass es das erste in der Ebene ist, obwohl es ursprünglich das zweite hinzugefügt wurde. Wenn Sie die Anwendung ausführen, werden Sie sehen, dass das geschichtete Panel funktioniert und die Komponenten ordentlich nach ihren Ebenen und Positionen anordnet.

BEI allgemeine Anwendungen Die Mehrschichtplatte wird selten direkt verwendet, in ihnen erfüllt sie ihre Funktionen unmerklich. Trotzdem hilft es manchmal, erstaunliche Effekte und ungewöhnliche Schnittstellen zu erstellen, die es Ihnen beispielsweise ermöglichen, Animationen oder Videos auf gewöhnliche Komponenten zu legen, ohne dass unmenschliche Anstrengungen und Tricks vom Entwickler erforderlich sind.

ContentPane

Das ContentPane ist der nächste Teil des Stammbereichs und dient zum Hosten der Benutzeroberflächenkomponenten des Programms. ContentPane nimmt den größten Teil des geschichteten Bedienfelds ein (mit Ausnahme des Platzes, der von der Menüleiste eingenommen wird). Um zu verhindern, dass das Inhaltsfeld Komponenten verdeckt, die anschließend dem Fenster hinzugefügt werden, platziert das geschichtete Feld es auf einer speziellen sehr niedrigen Ebene namens FRAME_CONTENT_LAYER mit der Nummer -30000.

Sie können auf das Inhaltsfenster zugreifen, indem Sie verwenden getContentPane() JFrame-Klasse. Mit der add(Component-Komponente)-Methode können Sie ihr jedes beliebige Steuerelement hinzufügen. Ersetzen ContentPane Für jedes andere Panel vom Typ JPanel können Sie die Methode verwenden setContentPane()

Ein Beispiel für das Hinzufügen einer Schaltfläche zum Inhaltsbereich:

JButton newButton = new JButton(); getContentPane().add(newButton);

Als Ergebnis erhalten wir ein Fenster mit einer Schaltfläche. Die Schaltfläche nimmt den gesamten verfügbaren Bereich des Fensters ein. Dieser Effekt ist nicht in allen Programmen nützlich, daher müssen Sie verschiedene Möglichkeiten verwenden, um Elemente auf dem Bedienfeld anzuordnen.

Das Inhaltsfeld kann komplett ausgetauscht werden. Folgendes berücksichtigen Schwingen Beispiel für das Inhaltsfeld ContentPane.

javax.swing.* importieren; öffentliche Klasse ContentPaneReplace erweitert JFrame ( private static final long serialVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Panel mit zwei Schaltflächen erstellen JPanel content = new JPanel(); content. add (new JButton("Family")); content.add(new JButton("School")); // Inhaltsfenster ersetzen setContentPane(contents); // Größe des Fensters bestimmen setSize(200, 100); // Öffnen des Fensters setVisible (true); ) public static void main(String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )

Das Beispiel erzeugt ein kleines Fenster und ein Panel mit zwei Buttons, das ist dann setContentPane() ersetzt den Inhaltsbereich des Fensters. Daher wurde anstelle einer einfacheren Addition ein Ersatz verwendet - der Aufruf der Methode add(). Die Fensteroberfläche ist im folgenden Screenshot dargestellt.

Inhaltsbereich ContentPane an sich ist nichts besonderes. Sie müssen sich nur daran erinnern, dass die Komponenten hinzugefügt werden.

Transparentes JOptionPane

Transparente Platte JOptionPane als Root-Panel über allen Elementen des geschichteten Panels platziert. Die JOptionPane-Platzierung wird vom Stammbereich gehandhabt, der den transparenten Bereich über dem geschichteten Bereich platziert, sodass er den gesamten Fensterbereich vollständig abdeckt, einschließlich des Bereichs, der von der Menüleiste eingenommen wird.

JOptionPane wird in Anwendungen selten verwendet, daher macht das Root-Panel es standardmäßig unsichtbar, was die Belastung des Zeichensystems verringert. Denken Sie daran, dass Sie, wenn Sie ein transparentes Panel sichtbar machen, sicherstellen müssen, dass es transparent ist (seine opaque-Eigenschaft ist falsch), da es sonst alle anderen Elemente des Root-Panels bedeckt, und der Rest der Benutzeroberfläche wird es sein unsichtbar.

In welchen Fällen kann eine transparente Platte verwendet werden? JOptionPane? Es kann verwendet werden, um Anwendungsfunktionen zu definieren, deren Implementierung von Grund auf erheblichen Aufwand erfordern würde. Das transparente Panel kann für automatisierte Tests der Benutzeroberfläche angepasst werden. Die darin synthetisierten Ereignisse ermöglichen es Ihnen, zwischenzeitliche Debugging-Ergebnisse zu verfolgen. Manchmal ist dieser Ansatz viel effektiver als manuelles Testen.

Transparente Platte JOptionPane kann verwendet werden, um ausgefallene Animationen zu erstellen, die über allen Komponenten "schweben", einschließlich der Menüleiste, oder um Ereignisse abzufangen, wenn einige von ihnen behandelt werden müssen, bevor sie an die Hauptbenutzeroberfläche gesendet werden.

Ein Beispiel für die Verwendung eines transparenten Swing-JOptionPane:

// Ein transparentes JOptionPane verwenden import java.awt.Dimension; java.awt.Font importieren; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; javax.swing.JDialog importieren; javax.swing.JFrame importieren; javax.swing.JLabel importieren; javax.swing.JOptionPane importieren; javax.swing.UIManager importieren; öffentliche Klasse JOptionPaneTest erweitert JFrame (private static final long serialVersionUID = 1L; public static final Font FONT = new Font("Verdana", Font.PLAIN, 11); public static void createGUI() ( JFrame frame = new JFrame("Test JOptionPane "); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowListener() ( public void windowActivated(WindowEvent event) () public void windowClosed(WindowEvent event) () public void windowDeactivated(WindowEvent event) () public void windowDeiconified(WindowEvent event) () public void windowIconified(WindowEvent event) () public void windowOpened(WindowEvent event) () public void windowClosing(WindowEvent event) ( Object options = ( "Yes", "No!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "Fenster schließen?", "Bestätigen", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, Optionen, Optionen); (false);System.exit(0); ) ) )); JLabel label = new JLabel("Beim Schließen des Fensters transparentes Bedienfeld verwenden"); frame.getContentPane().add(label); frame.setPreferredSize (neue Dimension (350, 80)); frame.pack(); frame.setLocationRelativeTo(null); frame.setVisible (wahr); ) public static void main(String args) ( javax.swing.SwingUtilities.invokeLater(new Runnable() ( public void run() ( UIManager.put("Button.font", FONT); UIManager.put("Label.font ", SCHRIFTART); JFrame.setDefaultLookAndFeelDecorated(true); JDialog.setDefaultLookAndFeelDecorated(true); createGUI(); ) )); ) )

Wenn der Methode setDefaultCloseOperation eine Konstante übergeben wird JFrame.EXIT_ON_CLOSE, dann funktioniert die Anwendung nicht mehr, wenn das Fenster geschlossen wird. Im Beispiel wird dieser Methode eine Konstante übergeben JFrame.DO_NOTHING_ON_CLOSE damit bei geschlossenem Fenster nichts passiert. Das Beenden der Anwendung im Beispiel erfolgt über den JFrame-Listener WindowListener in der Methode FensterSchließen. Wenn das Fenster geschlossen wird, wird die windowClosing-Methode mit einem WindowEvent-Ereignisparameter aufgerufen, der in einem transparenten Swing-JOptionPane einen Bestätigungsdialog öffnet.

Der folgende Screenshot zeigt zwei Anwendungsfenster. Oberes Hauptfenster. Wenn Sie dieses Fenster schließen, wird das untere Dialogfeld zur Absichtsbestätigung geöffnet.

JMenuBar Menüleiste

Eines der wichtigsten Merkmale bei der Verwendung des JRootPane-Root-Pane in Swing ist die Notwendigkeit, eine Menüleiste im Fenster zu platzieren. JMenuBar. Eine seriöse Anwendung kann nicht ohne eine Art Menü für den Zugriff auf die Programmfunktionen erstellt werden. Die Swing-Bibliothek bietet hervorragende Möglichkeiten zum Erstellen praktischer JMenuBars, die auch leichtgewichtige Komponenten sind.

Menüleiste JMenuBar in einem geschichteten Panel in einer speziellen Ebene FRAME_CONTENT_LAYER platziert und nimmt einen kleinen Platz am oberen Rand des Fensters ein. Die Länge der Menüleiste entspricht der Größe des Fensters. Die Breite der Menüleiste hängt von den enthaltenen Komponenten ab.

Das Root-Panel stellt sicher, dass das Inhaltspanel und die Menüleiste JMenuBarüberschnitten sich nicht. Wenn die Menüleiste nicht benötigt wird, verwendet das Root-Panel den gesamten Platz, um das Inhaltspanel aufzunehmen.

Swing-Beispiele

Die Quellcodes der im Text der Seite besprochenen Beispiele können heruntergeladen werden.

Wir vermuten, dass wir Sie müde gemacht haben, indem wir die ganze Zeit über Inferenzprogramme geredet haben. Textnachrichten zur Konsole. In dieser Lektion wird diese "trostlose" Reihe von Beispielen endlich unterbrochen: Wir zeigen, wie Fenster in Java erstellt werden, und Sie werden sehen, dass dies eine einfache Aufgabe ist. Hier ist unser Code (wir werden ihn in der nächsten Lektion besprechen, da er viele, viele Funktionen hat, die Sie wirklich kennen müssen):

java.awt.* importieren;

javax.swing.* importieren;

öffentliche Klasse MoneyForNothing erweitert JFrame(

// Konstrukteur

öffentliches GeldFürNichts()(

setTitle("Willkommen bei Money for Nothing");

setSize (neue Dimension (600, 400));

setDefaultCloseOperation (EXIT_ON_CLOSE);

setVisible(true);

public static void main(String args)(

MoneyForNothing mfn = new MoneyForNothing();

Und hier ist derselbe Code im FAR-Bearbeitungsfenster:

Übrigens empfehlen wir Ihnen, die Quellcodes von Programmen in der CP1251-Codierung (oder im allgemeinen Sprachgebrauch in der Windows-Codierung) sofort einzugeben: Das Umschalten der Codierung erfolgt durch Drücken von F8, und die aktuelle Codierung wird in der Statusleiste oben angezeigt den Bearbeitungsbereich.

Der Einstiegspunkt ist unverändert geblieben, aber der Rest des Codes hat sich der Reihe nach geändert (aber wir kommen nicht weiter). Nach dem Kompilieren und Ausführen sollten Sie Folgendes sehen:

Herzlichen Glückwunsch - in nur wenigen Zeilen haben Sie ein echtes Grafikfenster erstellt! Es kann gezogen, in der Größe geändert, reduziert, erweitert und geschlossen werden. Es stimmt, dass unser Fenster irgendwie verblasst war, um es klar auszudrücken - „hässlich“. Außerdem wird das Fenster in der oberen linken Ecke des Bildschirms angezeigt, aber ich hätte es gerne in der Mitte - es ist bequemer, es dort zu verwenden, und eine solche Ausgabe sieht schöner aus. Lassen Sie uns also ein wenig "polieren".

Lassen Sie uns zuerst das zweite Problem lösen - die Zentrierung des Fensters. Hier empfehlen wir innezuhalten und nachzudenken – wie würden Sie das anstellen?

Nehmen wir an, in der Java-Grafikbibliothek gibt es eine setLocation-Methode, der die Koordinaten der oberen linken Ecke des Fensters als Parameter übergeben werden (von dieser Ecke aus werden andere Grafikelemente im Fenster platziert). Aber wenn Sie diese Parameter "auf die Stirn" setzen, wird mit ziemlicher Sicherheit nichts Gutes dabei herauskommen. Auf einem anderen Monitor mit einer anderen Auflösung befindet sich das Fenster nicht dort, wo Sie es erwartet haben. Daher müssen die Koordinaten intelligenter eingestellt werden.

Um das Fenster zu zentrieren, müssen lediglich die Abmessungen des Fensters selbst (die übrigens im Konstruktor festgelegt werden und ein Rechteck von 600 x 400 Pixel ergeben) und die Bildschirmauflösung bekannt sein, und dann mit einfacher Arithmetik , berechnen Sie die notwendigen Koordinaten der oberen linken Ecke. Dies wird durch Platzieren des folgenden Codes erreicht

Dimension sSize = Toolkit.getDefaultToolkit().getScreenSize(),

fSize = getSize();

if (fSize.height > sSize.height) (fSize.height = sSize.height;)

if (fSize.width > sSize.width) (fSize.width = sSize.width;)

setLocation((sSize.width - fSize.width)/2,

(sSize.height - fSize.height)/2);

unmittelbar nach der Zeile setSize (neue Dimension (600, 400)); im Konstruktor. Nehmen Sie die erforderlichen Änderungen am Quellcode vor, kompilieren Sie das Programm und führen Sie es zur Ausführung aus. Das Fenster sollte in der Mitte des Monitorbildschirms erscheinen.

Nun noch ein paar Worte zum Aussehen des Fensters. Sein seltsames Erscheinungsbild erklärt sich aus der Tatsache, dass Java-Entwickler versuchten, sicherzustellen, dass alle grafischen Elemente (Fenster, Schaltflächen, Listen usw.) unabhängig von der Hardwareplattform und dem "Stuffing" der Software ein einheitliches Rendering und ein einheitliches Farbschema hatten. Dazu entwickelten sie einen speziellen Stil, den sie „METAL“ nannten. Wenn der Entwickler nicht nimmt besondere Bemühungen, dann sehen die Elemente der grafischen Benutzeroberfläche in ihren Programmen genau in diesem Stil aus, ohne die Funktionen bestimmter Computer und deren zu berücksichtigen Software. In einigen Fällen ist das sinnvoll, aber Sie müssen trotzdem zugeben, dass es viel besser ist, wenn ein Programm, das unter Windows läuft, wie ein Windows-Programm aussieht und ein Programm, das unter LINUX läuft, wie ein Linux-Programm aussieht. Dies ist einfach zu erreichen. Es muss lediglich der folgende Code in den Einstiegspunkt eingefügt werden, bevor eine Instanz der Klasse erstellt wird:

try(UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

catch(Exceptionlfe)()

So werden wir es machen. Nachdem Sie nun die aktualisierte Version unseres Programms kompiliert und zur Ausführung ausgeführt haben, sieht das Grafikfenster sehr "anständig" aus:

Je nach Einstellung der Anzeigeeigenschaften Ihres Monitors unterscheidet sich die Anzeige des Fensters; Wir verwenden den Klassiker Windows-Design XP. So könnte Ihr Fenster aussehen:

Stellen Sie sicher, dass alles wie erwartet funktioniert: Das Fenster wird in der Mitte des Bildschirms angezeigt und sieht wie erwartet aus.

Damit ist unsere erste Lektion über GUIs abgeschlossen. Darin haben wir zwar die „Fassade“ gezeigt, aber viele Punkte komplett „über Bord“ gelassen, die extrem wichtig sind und ohne die das Programmieren in Java im Allgemeinen und grafischen Oberflächen im Besonderen nicht möglich ist. Wir werden uns in der nächsten Lektion mit diesen Problemen befassen, aber spielen Sie zunächst mit dem Quellcode herum, den Sie haben.

Berechnen Sie als Übung beispielsweise die Koordinaten der Ausgabe unseres Fensters in der unteren rechten Ecke des Bildschirms und überprüfen Sie das Ergebnis.

Eine andere Übung ist einfacher, aber Sie müssen die Dokumentation verwenden (Sie müssen wirklich irgendwo anfangen): Machen Sie es so, dass Sie die Größe des Fensters nicht ändern können, d.h. zu Bereich Systemtasten sah aus wie auf dem Bild

(Tipp: Suchen Sie nach Informationen auf Schlüsselwörter Javax und JFrame). Also Ärmel hochkrempeln und viel Glück!

Kommentar

Es kann vorkommen, dass das generierte Fenster ganz oder teilweise unsichtbar ist (weil Sie die Koordinaten seiner Anzeige auf dem Bildschirm falsch berechnet haben). Die Schaltflächen zur Fenstersteuerung sind möglicherweise ebenfalls nicht verfügbar. Wie unterbreche ich die Anwendung, ohne die Aufgabe im "Task-Manager" zu entfernen oder den Computer neu zu starten?

Da wir Programme zur Ausführung von FAR starten, wird die Ausführung eines Java-Programms durch Drücken der Tastenkombination Strg-C unterbrochen (hier ist „C“ ein lateinischer Buchstabe, verwechseln Sie ihn nicht mit einem ähnlichen kyrillischen Buchstaben).