Die Logik von Game of Life wird also implementiert. Ich möchte den Prozess genießen, die Vielfalt der Formen des "Lebens" auf dem Bildschirm meines Monitors zu betrachten. Was wird dafür benötigt?

Das Fenster selbst mit Menüs und Schaltflächen sowie sein Verhalten werden mithilfe der Bibliothek erstellt Schwingen. Zeichnen Sie den Evolutionsprozess unseres "Lebens" - durch die Bibliothek AWT(genauer gesagt Java 2D). Dies sind die beiden Hauptpakete zum Erstellen von GUIs in Java.

Die Arbeit der AWT basiert zunächst auf den sogenannten Peer-Interfaces. Die Quintessenz ist, dass, wenn es notwendig ist, ein Java-Objekt auf dem Bildschirm anzuzeigen, das Betriebssystem ein gepaartes grafisches Objekt dafür erstellt, das tatsächlich angezeigt wird. Diese beiden Objekte interagieren miteinander, während das Programm läuft. Diese Implementierung führt dazu, dass jede Plattform ihr eigenes JDK veröffentlichen muss.

Später erstellte AWT Komponenten, die keine Peer-Schnittstellen verwenden - "leichte" (leichte) Komponenten. Die Bibliothek dieser Komponenten wurde Swing genannt. Das heißt, Swing ist tatsächlich eine Erweiterung von AWT.

AWT selbst wurde mit neuen Zeichen- und Bilddarstellungswerkzeugen namens ergänzt Java-2D.

Ich werde mit einer kurzen Beschreibung die Hauptelemente von Swing auflisten.

Der Grundbaustein der gesamten visuellen Komponentenbibliothek von Swing ist JKomponente. Dies ist die Oberklasse jeder Komponente. Es ist eine abstrakte Klasse, also können Sie nicht wirklich eine JComponent erstellen, aber sie enthält buchstäblich Hunderte von Funktionen, die jede Swing-Komponente als Ergebnis der Klassenhierarchie verwenden kann.

jFrame(Anwendungsfenster) - der Hauptcontainer, mit dem Sie sich selbst andere Komponenten hinzufügen können, um sie zu organisieren und dem Benutzer bereitzustellen. Der JFrame fungiert als Brücke zwischen den betriebssystemunabhängigen Swing-Teilen und dem tatsächlichen Betriebssystem, auf dem sie ausgeführt werden. Der JFrame wird als Fenster beim Betriebssystem registriert und erhält dadurch viele der bekannten Fenstereigenschaften Betriebssystem.

JMenu/JMenuItem/JMenuBar- entwickelt, um ein Menüsystem in einem JFrame zu entwickeln. Das Rückgrat eines jeden Menüsystems ist die JMenuBar, jedes JMenu und JMenuItem wird damit erstellt. JMenu ist eine Unterklasse von JMenuItem. Sie unterscheiden sich jedoch im Aussehen: JMenu wird verwendet, um andere JMenuItem und JMenu zu enthalten; JMenuItem aktiviert eine Aktion, wenn es ausgewählt wird.

JLabel(Label) - wird verwendet, um (Text oder Grafik) andere Elemente zu beschreiben.

jButton(Schaltfläche) - die wichtigste aktive Komponente, mit der Sie beim Drücken eine Aktion ausführen können. Zusätzlich zu den Standardmethoden, die die Anzeige der Komponente steuern, enthält sie eine Gruppe von Methoden zur Verwaltung ihres Zustands (aktiv / inaktiv, ausgewählt / nicht ausgewählt, Maus hoch / keine Maus, gedrückt / losgelassen).

JTextField(Textfeld) - ermöglicht dem Benutzer die Eingabe von Textdaten, die im Programm verarbeitet werden können.

JTextArea erweitert das JTextField, um die Eingabe mehrerer Zeilen zu ermöglichen.

JPasswordField(Passwortfeld) – ein Typ von JTextField, mit dem Sie die eingegebenen Zeichen verbergen können.

JComboBox(Kombinationsliste) – Ermöglicht dem Benutzer, ein Element aus einer vorhandenen Liste auszuwählen (oder der Liste ein neues Element hinzuzufügen).

JCheckBox(Kontrollkästchen) und JRadioButton(Optionsschaltfläche) – Bietet Optionen, aus denen der Benutzer auswählen kann. JRadioButtons werden normalerweise gruppiert, um dem Benutzer eine erzwungene Antwortfrage zu geben (die Antworten schließen sich gegenseitig aus - es kann nur eine Antwort pro Frage geben). Sobald Sie einen JRadioButton ausgewählt haben, können Sie ihn nicht deaktivieren, bis Sie eine andere Option aus der Gruppe auswählen. JCheckBox funktioniert anders. Sie können eine Option jederzeit aktivieren/deaktivieren und mehrere Antworten pro Frage auswählen. Die Klasse, die es ermöglicht, JCheckBox- oder JRadioButton-Komponenten zu gruppieren, ist die Klasse Schaltflächengruppe.

JSlider— ein Element zum Auswählen eines numerischen Werts aus einem grafisch dargestellten Bereich.

JSpinner- dient zur Auswahl aus einer Gruppe von Werten. Darin ähnelt es JComboBox, obwohl ihre Verwendung nicht austauschbar sein sollte. Sie sollten JSpinner nur für logisch aufeinander folgende Auswahlen verwenden – Zahlen und Datumsangaben sind dafür perfekt. JComboBox hingegen ist mehr gute Wahl um scheinbar zufällige Optionen darzustellen, die keine Beziehung zueinander haben.

JToolBar fungiert als Container für andere Komponenten (JButtons, JComboBoxes usw.), die zusammen die Symbolleisten bilden, die in den meisten Anwendungen zu finden sind. Symbolleisten ermöglichen es dem Programm, häufig verwendete Befehle an einer geeigneten Stelle zu platzieren und zu gruppieren. Symbolleistenschaltflächen entsprechen normalerweise Befehlen in einem Menü.

JToolTipp- Dies sind kleine "Blasen", die auftauchen, wenn Sie den Mauszeiger über etwas bewegen und halten. Sie können in Anwendungen sehr nützlich sein, indem sie QuickInfos für Elemente bereitstellen, detaillierte Informationen liefern oder sogar den vollständigen Text eines Elements in übersichtlichen Benutzeroberflächen anzeigen. Sie werden in Swing aktiviert, indem Sie den Mauszeiger für eine bestimmte Zeit über einer Komponente belassen; Sie werden normalerweise etwa eine Sekunde nach dem Anhalten der Maus angezeigt und bleiben sichtbar, solange der Mauszeiger über der Komponente bleibt.

JOptionPane- eine Klasse, um UI-Entwicklern die Möglichkeit zu geben, einfache Nachrichten (Fehler oder andere Informationen) auszugeben und schnell Daten (z. B. einen Namen oder eine Nummer) zu erhalten.

jscrollpane- Swing-Komponente, um alle Scroll-Aktionen zu verarbeiten.

jliste ist eine nützliche Komponente, um dem Benutzer viele Optionen zur Auswahl zu bieten. Sie können es sich als JComboBox-Erweiterung vorstellen. JList bietet mehr Auswahlmöglichkeiten und fügt die Möglichkeit hinzu, mehrere Auswahlmöglichkeiten auszuwählen. Die Wahl zwischen JList und JComboBox ist oft so: Wenn Sie mehrere Auswahlen benötigen oder mehr als 15 Auswahlmöglichkeiten haben (obwohl diese Anzahl keine allgemeine Regel ist), sollten Sie immer JList wählen. Sie sollten JList in Verbindung mit JScrollPane verwenden, da es mehr Optionen bieten kann, als in den sichtbaren Bereich passen. JList hat auch ein Auswahlmodell, das Sie einstellen können verschiedene Typen Auswahl an Optionen. Diese Typen sind: Einzelauswahl (Sie können nur eine Option auswählen), Einzelintervall (Sie können eine beliebige Anzahl benachbarter Optionen auswählen) und Mehrfachintervall (Sie können eine beliebige Anzahl von Optionen in beliebiger Kombination auswählen).

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 dem 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. Der Satz an Standardkomponenten übertrifft AWT in Vielfalt und Funktionalität bei weitem. 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

Zum Erstellen GUI Anwendungen müssen spezielle Komponenten der Swing-Bibliothek verwenden, die Top-Level-Container genannt werden. 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 jFrame.

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. Um ein einfaches Programm mit einem leeren Fenster zu erstellen, müssen Sie die folgenden Methoden verwenden:

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 jFrame 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 der Root-Bereich 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 A, das den gesamten verfügbaren Platz im Container einnimmt. 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 Ganzzahl 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 meisten wichtige Funktionen Anwendung mit mehreren Dokumenten - die Position des "aktiven" Fensters über anderen, das Minimieren von Fenstern, das Ziehen von Fenstern - werden durch die Mechanismen des mehrschichtigen Bedienfelds 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, wodurch sichergestellt wird, dass alle Mechanismen des mehrschichtigen Panels korrekt funktionieren. Standard-JLayeredPane-Layer sind in der folgenden Abbildung dargestellt.

Die Standardschicht wird verwendet, um alle normalen Komponenten zu hosten, 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. Entwickelt für Drag-and-Drop-Operationen, 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 jFrame 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.

In konventionellen Anwendungen kommt die Schichtplatte selten direkt zum Einsatz, in der sie unsichtbar ihre Funktionen erfüllt. Manchmal hilft es jedoch, erstaunliche Effekte und ungewöhnliche Schnittstellen zu erstellen, die es beispielsweise ermöglichen, Animationen oder Videos auf gewöhnlichen Komponenten zu platzieren, ohne dass unmenschliche Anstrengungen und Tricks des Entwicklers 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 verdeckt und der Rest der Benutzeroberfläche unsichtbar ist .

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 für eine ausgefallene Animation verwendet werden, die über allen Komponenten "schwebt", einschließlich der Menüleiste, oder zum Abfangen von Ereignissen, 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

Einer von wichtige Funktionen 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 um praktische JMenuBar-Menüs zu erstellen, 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.

Vorwarnung

Anders als in den vorangegangenen Sessions, wo wir meist nach dem Prinzip „do as I do“ agiert haben und Konzepte und technische Details sozusagen „an den Fingern“ besprochen haben, wird sich der Präsentationsstil ab dieser Lektion etwas ändern und technischer sein.

Dies lässt sich leider nicht vermeiden, denn. Früher oder später werden wir an einen Punkt kommen müssen, an dem der Ansatz „auf die Finger“ unhaltbar wird. Jetzt kommt dieser Moment. Also lasst uns unseren Mut zusammennehmen, die Ärmel hochkrempeln und loslegen.

In der vorigen Lektion () haben wir ein Grafikfenster erstellt und auf dem Monitorbildschirm angezeigt und nebenbei einige Probleme bezüglich seines Aussehens und seiner Position gelöst. Jetzt werden wir diskutieren, was hinter den Kulissen zurückbleibt.

Sie haben wahrscheinlich bemerkt, dass am Anfang des Quellcodes zwei folgende Zeilen stehen:

java.awt.* importieren;

javax.swing.* importieren;

Hier müssen wir ein wenig verweilen. Denken Sie daran, dass wir bereits erwähnt haben, dass die Umwelt Java-Programmierung enthält viele Bibliotheken zur Unterstützung von Netzwerken, Grafiken, Datenbankoperationen, Messaging usw. Bibliotheken geben Java all die Kraft und Vielseitigkeit.

In Java wird anstelle des Begriffs „Bibliothek“ der Begriff „Paket“ verwendet. Die obigen Zeilen verbinden nur die notwendigen Pakete, um eine grafische Oberfläche zu bilden. Später werden Sie sehen, dass wir andere Pakete verwenden werden, aber im Moment reichen uns diese beiden aus.

Pakete enthalten die notwendigen Klassen und Schnittstellen (wir werden zu gegebener Zeit über Schnittstellen sprechen), die die eine oder andere Funktionalität der zukünftigen Anwendung bereitstellen. Das Vorhandensein eines Sternchens ("*") zeigt an, dass der Programmierer den gesamten Inhalt des Pakets importiert, ohne genaue Angabe die darin enthaltenen Klassen oder Schnittstellen. Es mag den Anschein haben, dass bei großen Paketen der resultierende Objektcode zu groß ist, aber keine Sorge: Der Java-Compiler ist intelligent genug, um nur das zu verwenden, was Ihr Programm wirklich benötigt; alles, was das Programm nicht braucht, nimmt der Compiler einfach nicht in den Objektcode auf. Wenn Sie möchten, können Sie auch eine etwas andere Form des Einbindens von Paketen verwenden, z. B.

java.awt.window importieren;

javax.swing.JFrame importieren;

Dies setzt jedoch voraus, dass der Programmierer bereits gute Kenntnisse über die Struktur und die Fähigkeiten dieser Pakete hat. Wir werden die früher angegebene einfachere Form der Verbindungspakete verwenden.

Das Importieren (Verbinden) eines Pakets mit dem zu entwickelnden Programm erfolgt mit dem Schlüsselwort import, gefolgt vom Paketnamen. Jedes Paket muss separat importiert werden (d. h. Sie können nicht import java.awt.*, javax.swing.*; schreiben). Natürlich wird der Umfang des Quellcodes etwas erhöht, aber sehr geringfügig. Alle Klassen und Schnittstellen, aus denen Ihr Programm besteht, müssen strikt nach den Importkonstrukten platziert werden, da der Compiler sonst eine Fehlermeldung beim Kompilieren generiert.

Das erste Paket (beginnend mit java.awt) sorgt in erster Linie für die Interaktion von Java-Programmen mit dem Grafik-Subsystem des Betriebssystems. Denken Sie daran, dass Java eine plattformübergreifende Programmiersprache ist und unabhängig vom Betriebssystem, auf dem dieser Code ausgeführt wird, einen einzelnen Objektcode generiert. Daher wird Java „gezwungen“, auf Ressourcen zuzugreifen, die von dem Betriebssystem bereitgestellt werden, das auf dem Computer des Benutzers installiert ist. Eine solche Ressource sind Grafiken (neben Grafiken fordert Java Betriebssystem-"Dienste" auf, um darauf zuzugreifen Dateisystem und andere Ressourcen). Das java.awt.*-Paket ermöglicht also in Java geschriebenen grafischen Schnittstellen, die grafischen Fähigkeiten des Betriebssystems zu nutzen und auf in Java erstellten grafischen Objekten angezeigt zu werden. Java-Programme, auf dem Monitorbildschirm. Hier werden wir ein wenig verweilen.

Alle grafischen Komponenten in Java sind in zwei Kategorien unterteilt: Lightweight (lightweight) und Heavyweight (heavyweight). Die überwiegende Mehrheit der grafischen Komponenten (Schaltflächen, Listen, Bäume, Beschriftungen, Tabellen usw.) sind leichtgewichtig. Dies bedeutet, dass das Betriebssystem absolut nichts über sie weiß und ihre Existenz nicht einmal "ahnt". Lightweight-Komponenten gehören zu Fenstern (wie dem, das wir in der vorherigen Lektion gezeigt haben) und werden in diesen Fenstern angezeigt.

Wenn wir eine Schaltfläche in einem Fenster anzeigen möchten, müssen wir sie nur mit Code wie dem folgenden definieren

JButton buttonPressMe = new JButton ("Drück mich");

und platzieren Sie es an der angegebenen Stelle im Fenster (die relevanten Details werden später beschrieben). Eine Schaltfläche ist ein leichtes Objekt und das Betriebssystem hat keine Kenntnis von der Schaltfläche (Schaltfläche existiert nicht für das Betriebssystem). Nur das Fenster, in dem es sich befindet, „weiß“ von der Schaltfläche. Das Fenster zeichnet die Schaltfläche, fängt Ereignisse ab, die mit der Schaltfläche auftreten, zeichnet die Schaltfläche neu, wenn sie durch etwas verdeckt wurde usw. Aber das Fenster selbst als solches - das Betriebssystem ist sich dessen bewusst, und zwar gerade weil das Fenster eine schwere Komponente ist. Nur das Fenster hat Zugriff auf Betriebssystemressourcen (insbesondere Grafikressourcen).

Sehen Sie sich den Quellcode an. Als wir die Koordinaten der oberen linken Ecke des Fensters berechneten, bevor wir es auf dem Bildschirm anzeigten, mussten wir die Bildschirmauflösung kennen

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

Was kann solche Informationen liefern? Betriebssystem und nur es! Als nächstes haben wir den Code verwendet

try(UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

catch(Exceptionlfe)()

damit das Erscheinungsbild des Fensters dem in einem bestimmten Betriebssystem angenommenen Standard entspricht. Was kann solche Informationen liefern? Nochmal - das Betriebssystem! Um grafische Oberflächen zu erstellen, können wir also nicht auf das Paket java.awt.* verzichten.

Wenn ein Fenster auf dem Bildschirm angezeigt wird, weist das Betriebssystem dem Fenster die erforderlichen Ressourcen (hauptsächlich Speicher) zu und das Fenster wird sichtbar. Als nächstes kommen Leichtbaukomponenten ins Spiel und das Ganze weitere Arbeit fast ausschließlich mit ihnen durchgeführt.

Das zweite Import-Paket (beginnend mit javax.swing) ist für das Erstellen leichtgewichtiger GUIs verantwortlich (es gibt andere Pakete, aber dieses ist das wichtigste und wird fast immer verwendet). Wir werden dieses Paket nach und nach studieren und beherrschen, weil. es ist ziemlich groß und ziemlich komplex. Wir beginnen damit in der nächsten Lektion, aber schauen wir uns zunächst die folgende Zeile des Quellcodes an:

öffentliche Klasse MoneyForNothing erweitert JFrame(

Zwei Elemente sind hier neu: das Schlüsselwort „extends“ und das Wort „JFrame“.

Stichwort extend (übersetzt als „erweitern“, aber in der Bedeutung dem Wort „erbt“ oder dem Ausdruck „Eigenschaften und Verhalten ausleihen“ nahe steht) drückt das grundlegende Konzept der objektorientierten Programmierung (oder einfacher klassenbasierter Programmierung) aus ). Dieses Konzept wird "Vererbung" genannt. Damit muss gut umgegangen werden.

Denken Sie daran, dass wir in einer der ersten Lektionen () das Konzept von Klassen besprochen und einen Automotor als Beispiel verwendet haben. Bei aller Vielfalt der Motoren und ihrer Konstruktionen (wir sprechen natürlich von Verbrennungsmotoren) sind sich fast alle diese Motoren ähnlich: Jeder von ihnen hat Zylinder, Kolben, Kurbelwellen, Ventile usw.

Natürlich kann ein riesiger Dieselmotor für einen Tanker nicht mit einem winzigen Alkoholmotor für ein Flugzeugmodell verglichen werden, aber sie sind (wenn ich so sagen darf) - wenn auch entfernt, aber verwandt. Sie haben einen gemeinsamen Vorfahren - eine Art abstrakte Engine, und die Engines selbst sind ihre Nachkommen (auch wenn sie sehr, sehr weit entfernt sind).

In der Programmierung wird ein solcher Vorfahr normalerweise als "Eltern" oder "Superklasse" bezeichnet, d.h. Klasse, von der andere Klassen abstammen. Der Name der Oberklasse kommt direkt nach extend. Somit kann das obige Codefragment in die gewöhnliche Sprache übersetzt gelesen werden als: "Klasse ... erweitert die JFrame-Klasse", "Klasse ... erbt die JFrame-Klasse" oder "Klasse ... leiht Eigenschaften und Verhalten der JFrame-Klasse" . Die JFrame-Klasse definiert die grundlegenden Eigenschaften und das Verhalten von "Standard"-Grafikfenstern. Die JFrame-Klasse selbst befindet sich im javax.swing.*-Paket, und das haben wir am Anfang des Programms importiert.

JFrame ist das übergeordnete Element (in der Java-Terminologie eine Oberklasse) von Grafikfenstern (es gibt andere Fenster, wie z. B. Dialoge, aber wir werden zu gegebener Zeit darüber sprechen). Wenn Sie sich die Java-Dokumentation ansehen, werden Sie feststellen, dass die JFrame-Klasse mehrere Konstruktoren, Felder und ungefähr zwei Dutzend Methoden hat, die das Verhalten einiger »Standard«-Fenster definieren. Daher ist unsere Klasse namens MoneyForNothing ein Erbe der JFrame-Klasse (normalerweise sprechen sie nicht von Erben, sondern von Nachkommen oder untergeordneten Klassen).

Bitte beachten Sie, dass die JFrame-Klasse selbst ein Nachkomme mehrerer Klassen ist (von denen die meisten zum bereits bekannten Paket java.awt.* gehören):

Um nicht auf diese Frage zurückzukommen, machen wir Sie darauf aufmerksam, dass an der Spitze der Java-Vererbungshierarchie Klassen aus dem Paket java.lang.* stehen. Dies ist das einzige Paket aus dem JDK, das nicht explizit importiert werden muss – es wird immer automatisch importiert. Nach dieser „Leiter“ zu urteilen, ist die JFrame-Klasse das Ur-Ur-Ur-Enkelkind von java.lang.Object (das obige Bild wird wissenschaftlich als Klassenhierarchie bezeichnet).

Alle Komponenten der grafischen Benutzeroberfläche (abgekürzt als GUI, von Graphical User Interface), die, wie Sie sich erinnern, leichte Elemente sind, müssen innerhalb des Hauptfensters platziert werden - dem Nachfolger von JFrame. Im Moment haben wir keine Komponenten, aber sie werden bald erscheinen – versprochen.

Und jetzt gehen wir unsere letzte durch Quellcode, die so aussieht:

// Konstrukteur

öffentliches GeldFürNichts()(

setTitle("Willkommen bei Money for Nothing");

setSize (neue Dimension (600, 400));

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);

setDefaultCloseOperation (EXIT_ON_CLOSE);

setVisible(true);

Als erstes setzen wir den Titel des Fensters (Methode setTitle(...)). Dann werden die horizontalen und vertikalen Abmessungen des Fensters festgelegt (setSize(...)-Methode). Nach Ermittlung der Bildschirmauflösung des Monitors werden die Koordinaten der oberen linken Ecke unseres Fensters berechnet und das Fenster an der angegebenen Stelle auf dem Bildschirm angezeigt (Methode setLocation (...)).

Danach bestimmen wir, was beim Schließen des Fensters im Systemmenü zu tun ist; in diesem Fall ist es klar, dass die Anwendung ihre Arbeit beenden sollte (EXIT_ON_CLOSE). Hinter dieser kurzen und einfachen Zeile verbirgt sich tatsächlich die überraschend interessante und faszinierende Welt des Event-Handlings. Sagen wir gleich: Das Verständnis des Event-Handling-Mechanismus in Java ist ein Schlüsselmoment bei der Entwicklung grafischer Anwendungen, und ab der nächsten Lektion werden wir genau das tun.

Schließlich macht die letzte Zeile (Methode setVisible(true)) das Fenster sichtbar.

Natürlich haben wir einige Details nicht ausgelassen, aber unser Ziel ist es nicht, alles und jedes gründlich zu erzählen - dafür gibt es Dokumentationen, Nachschlagewerke und Tutorials. Unser Ziel ist es, eine allgemeine Richtung, einen Ausgangspunkt zu geben, von dem aus Sie (wenn Sie möchten und mit genügend Ausdauer) Ihre Programme in die richtigen Richtungen entwickeln und mit der erforderlichen Funktionalität füllen können.

Damit ist unsere Lektion beendet. Das Wichtigste, was Sie daraus mitnehmen sollten, ist das Konzept der Vererbung (Bleihe). Dies ist in der Tat ein grundlegendes Konzept. Ohne sie ist es in Java unmöglich, komplexe und zu erstellen nützliches Programm, nehmen Sie sich also Zeit, um fortzufahren, aber überprüfen Sie noch einmal sorgfältig alles, was wir bisher gelernt haben.

Viel Glück und bis bald!

In diesem kurzen Artikel möchte ich den Entstehungsprozess beschreiben kleines Programm Unterstützung der GUI in der Sprache 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)

Nach der Installation notwendige Software, offen 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.

Auf der diese Phase Wir haben bereits ein funktionierendes Programm, aber 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 enthält notwendige Elemente, aber selbst jetzt hat es nichts mit der GUI zu tun, also erweitern wir es mit jFrame und erben alle grundlegenden und notwendigen Funktionen der GUI .

IN dieser Moment Wir haben das Formular Hauptfenster und Klasse Hauptfenster verlängert mit jFrame. 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.

Senden Sie Ihre gute Arbeit in die Wissensdatenbank ist einfach. Verwenden Sie das untenstehende Formular

Studenten, Doktoranden, junge Wissenschaftler, die die Wissensbasis in ihrem Studium und ihrer Arbeit nutzen, werden Ihnen sehr dankbar sein.

Veröffentlicht am http://www.allbest.ru/

EINLEITUNG

In den letzten Jahren haben Entwickler viel Mühe darauf verwendet, Grafiken und Animationen in ihre Applets und Java-Anwendungen zu integrieren. Mit den APIs java.awt und javax.swing können Entwickler viel komplexere grafische Anwendungen implementieren, darunter Spiele, Bildschirmschoner, Bildschirmschoner und 3D-GUIs.

Zweck der Arbeit Die Berechnungs- und Grafikarbeit widmet sich dem Erstellen von Anwendungen unter Verwendung der grafischen Schnittstelle der Bibliotheken java.awt und javax.swing.

Relevanz: Bis heute ist Grafik für Programmiersprachen von nicht geringer Bedeutung. Es ermöglicht Ihnen, jedes Programm zu visualisieren, was Helligkeit und Komfort für die Verwendung bestimmter Programme bietet. Ermöglicht Ihnen, helle und interessante Webseiten zu erstellen, es ist praktisch beim Entwickeln von Datenbanken, Schreiben von Handy- und Computerspielen.

1. FORMULIERUNG DES PROBLEMS

Die grafische Benutzeroberfläche (GUI) ist die Hauptmethode, mit der Endbenutzer mit einer Java-Anwendung interagieren. Für die Entwicklung von angewandten Software In der Java-Sprache bzw. der grafischen Oberfläche von Anwendungen werden häufig die Pakete AWT und Swing verwendet.

AWT (das java.awt-Paket wird für den Zugriff geladen) enthält eine Reihe von Klassen, mit denen Sie grafische Operationen ausführen und Fenstersteuerelemente erstellen können, ähnlich wie dies in VBA und Delphi geschieht.

Swing (das Paket javax.swing wird für den Zugriff geladen) enthält neue Klassen, die größtenteils AWT ähneln. Klassennamen (JButton, JLabel usw.) wird J hinzugefügt.

Im Moment sind die Hauptklassen zum Erstellen visueller Schnittstellen im Swing-Paket enthalten. Aus dem AWT-Paket werden Klassen verwendet, um Nachrichten zu verarbeiten. Protozoen Grafikanwendung unter.

javax importieren. schwingen.*;

öffentliche finale Klasse HelloWorld implementiert Runnable(

public static void main(String args) (

//Swing hat seinen eigenen Dispatching-Thread,

// die parallel zur Haupt läuft (in der main() ausgeführt wird)

//Strom. Wenn der Hauptthread die Ausführung beendet (die Hauptmethode endet),

//Der Thread, der für den Betrieb der Swing-Schnittstelle verantwortlich ist, kann seine Arbeit fortsetzen.

//Und selbst wenn der Benutzer alle Fenster geschlossen hat, wird das Programm seine Arbeit fortsetzen

//(solange dieser Thread lebt). Seit Java 6 wenn überhaupt

//Komponenten werden zerstört, Kontrollfluss stoppt automatisch.

//Führen Sie den gesamten Code aus, der auf dem Steuerthread ausgeführt wird, sogar die Initialisierung:

SwingUtilities.invokeLater (neues HelloWorld());

public void run() (

// Erstellen Sie ein Fenster mit dem Titel "Hello, World!"

Frame f = new JFrame("Hello, World!");

// Bisherige Praxis bestand darin, einen Listener zu erstellen und sich zu registrieren

// auf der Hauptfensterinstanz, die auf windowClosing() geantwortet hat

// erzwungener Stopp virtuelle Maschine durch Aufruf von System.exit()

// Jetzt gibt es eine "richtigere" Möglichkeit, die Reaktion auf das Schließen des Fensters einzustellen.

// Diese Methode zerstört das aktuelle Fenster, hält die Anwendung jedoch nicht an. Tem

// Die Anwendung selbst wird ausgeführt, bis alle Fenster geschlossen sind.

f.setDefaultCloseOperation (JFrame.DISPOSE_ON_CLOSE);

// Du kannst es aber auch so einstellen:

// f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Fügen Sie dem Fensterbereich eine nicht bearbeitbare Komponente mit Text hinzu.

// f.getContentPane().add (neues JLabel("Hello, World!")); - alter Stil

f.add(new JLabel("Hallo Welt"));

// pack() "packt" das Fenster auf die optimale Größe

// alle darin befindlichen Komponenten.

// Schaufenster

f.setVisible(true);

Swing bietet Mechanismen zur Steuerung der folgenden Aspekte einer Präsentation:

Tastatur (Swing bietet eine Möglichkeit, Benutzereingaben abzufangen)

Farben (Swing bietet eine Möglichkeit, die auf dem Bildschirm angezeigten Farben zu ändern)

Textfeld für die Eingabe (Swing bietet Textbausteine für alle alltäglichen Aufgaben).

JKomponente

Die Basisklasse der gesamten visuellen Swing-Komponentenbibliothek ist JComponent. Es ist eine Oberklasse anderer visueller Komponenten. Es ist eine abstrakte Klasse, also können Sie nicht wirklich eine JComponent erstellen, aber sie enthält Hunderte von Funktionen, die jede Swing-Komponente als Ergebnis der Klassenhierarchie verwenden kann. Die JComponent-Klasse stellt die Farbinfrastruktur für alle Komponenten bereit, sie weiß, wie sie mit allen Tastendrücken auf der Tastatur umgeht, ihre Unterklassen müssen daher nur auf bestimmte Tasten lauschen. Die JComponent-Klasse enthält auch eine add()-Methode, mit der Sie andere Objekte der JComponent-Klasse hinzufügen können, sodass Sie jede Swing-Komponente zu jeder anderen hinzufügen können, um verschachtelte Komponenten zu erstellen (z. B. ein JPanel, das einen JButton enthält, oder noch ausgefallenere Kombinationen, wie z. B. ein JMenu, das einen JButton enthält).

JLabel

Die einfachste und gleichzeitig wichtigste visuelle Komponente in der Swing-Bibliothek ist das JLabel oder "Label". Die Methoden dieser Klasse umfassen das Festlegen von Text, Bild, Ausrichtung und anderen Komponenten, die das Label beschreibt:

get/setText() - holt/setzt den Text im Etikett;

get/setIcon() - holt/setzt das Icon im Label;

get/setHorizontalAlignment - holt/setzt die horizontale Position des Textes;

get/setDisplayedMnemonic() - holt/setzt die Mnemonik (unterstrichenes Zeichen) für das Label;

get/setLabelFor() - Abrufen/Setzen der Komponente, an die dieses Label angehängt ist; Wenn der Benutzer die Tastenkombination Alt + Mnemonik drückt, bewegt sich der Fokus auf die angegebene Komponente.

jButton

Die wichtigste aktive Komponente in Swing ist der Jbutton.

Die Methoden zum Ändern der Eigenschaften eines JButton ähneln denen eines JLabel (Sie werden feststellen, dass sie für die meisten Swing-Komponenten gleich sind). Sie steuern Text, Bilder und Ausrichtung:

get/setText() - holt/setzt den Text in der Schaltfläche;

get/setIcon() - holt/setzt das Bild in der Schaltfläche;

get/setHorizontalAlignment() - holt/setzt die horizontale Position des Textes;

get/setVerticalAlignment() - holt/setzt die vertikale Position des Textes;

get/setDisplayedMnenomic() - ruft/setzt die mnemonische Zeichenkette (unterstrichenes Zeichen), die in Kombination mit der Alt-Taste bewirkt, dass auf die Schaltfläche geklickt wird.

jFrame

Die JFrame-Klasse ist ein Container, der es Ihnen ermöglicht, andere Komponenten zu sich selbst hinzuzufügen, um sie zu organisieren und dem Benutzer zu präsentieren.

JFrame fungiert als Brücke zwischen betriebssystemunabhängigen Swing-Teilen und dem eigentlichen Betriebssystem, auf dem sie ausgeführt werden. Ein JFrame wird als Fenster registriert und erhält daher viele Eigenschaften des Betriebssystemfensters: Minimierung/Maximierung, Größenänderung und Bewegung. Obwohl die Umsetzung Labor arbeit es genügt, sich den JFrame als die Palette vorzustellen, auf der Sie die Komponenten platzieren. Hier sind einige der Methoden, die Sie für einen JFrame aufrufen können, um seine Eigenschaften zu ändern:

get/setTitle() - Holt/Setzt den Titel des Frames;

get/setState() - Rahmenzustand abrufen/einstellen (minimieren, maximieren usw.);

is/setVisible() - Abrufen/Setzen der Sichtbarkeit des Rahmens, mit anderen Worten, der Anzeige auf dem Bildschirm;

get/setLocation() - holt/setzt die Position im Fenster, wo der Frame erscheinen soll;

get/setSize() - Rahmengröße abrufen/einstellen;

add() - fügt dem Frame Komponenten hinzu.

Schemata, Modelle und Ereignisse

Wenn Sie visuelle Anwendungen in Java erstellen, können Sie sie nicht einfach zufällig auf dem Bildschirm platzieren und erwarten, dass sie sofort funktionieren. Komponenten müssen an bestimmten Orten platziert werden, auf Interaktionen mit ihnen reagieren, sie basierend auf dieser Interaktion aktualisieren und sie mit Daten füllen. Um effektiv mit visuellen Komponenten arbeiten zu können, müssen die folgenden drei Swing-Architekturkomponenten installiert sein.

Schemata (Layout). Swing enthält viele Schemas, das sind Klassen, die steuern, wo Komponenten in einer Anwendung platziert werden und was mit ihnen geschehen soll, wenn die Größe des Fensters der Anwendung geändert wird oder wenn Komponenten entfernt oder hinzugefügt werden.

Veranstaltungen Das Programm muss auf Tastenanschläge, Mausklicks und alles andere reagieren, was der Benutzer tun kann.

Modelle (Modell). Für fortgeschrittenere Komponenten (Listen, Tabellen, Bäume) und sogar einige einfachere wie JComboBox sind Modelle die effizienteste Art, mit Daten zu arbeiten. Sie entfernen einen Großteil der Datenverarbeitungsarbeit von der Komponente selbst (denken Sie an MVC) und bieten einen Wrapper um allgemeine Datenobjektklassen (wie Vector und ArrayList).

Aufgrund der Notwendigkeit, dynamische Szenen auf visuellen Komponenten anzuzeigen, sollte der Graphics 2D-Klasse besondere Aufmerksamkeit geschenkt werden.

Individuelle Berechnungs- und Grafikaufgabe: Zeichnen Sie im Anwendungsfenster ein Segment, das sich in der Rahmenebene um einen Punkt dreht, der sich entlang des Segments bewegt.

GUI-Java-Komponente

2. IMPLEMENTIERUNG EINES PROBLEMS IN EINER HOCHSPRACHEJAVA

java.awt.* importieren;

import java.awt.geom.*;

import java.awt.image.BufferedImage;

* Eine Aufgabe 4. porträtieren in Fenster Anwendungen (Applet) Sektion, rotierend in

* Flugzeug Rahmen um herum Punkte ziehen um an Segment.

öffentliche Klasse LB4 erweitert java.applet.Applet implementiert Runnable(

privates statisches Finale lang serialVersionUID= 1 Liter;

privat int w, h;

privates BufferedImage bi;

privat Graphics2D groß;

privater boolescher Stopp = falsch;

privater Thread-Timer = null;

private Farbe fonColor = Farbe. WEISS;

privates FarbsegmentFarbe = Farbe. HELLGRAU;

private FarbpunktFarbe = Farbe. GRÜN;

privates Segment;

// Initial Lage Zeichnung

privates doppeltes Längensegment;

// Richtung Voreingenommenheit Achsen Drehung

privater doppelter movePoint = -1;

private Doppelschicht = 0;

privater doppelter speedPoint = 1;

// Geschwindigkeit Änderungen Bestimmungen in Platz

private int speedRepaint = 30;

// Injektion auf der welche die los Änderungen Bestimmungen Segment

privat int grad = 15;

/** Dies Methode Wille namens nach dem Downloads Applet */

öffentlich void init()(

// Wir erstellen Objekte Und Installieren Initial Werte.

Dimension dim = getSize();

// Wir erstellen Segment, fragen Länge

lengthSegment = (doppelt) Math. Mindest(b, h) / 3;

segment = new Segment(lengthSegment, lengthSegment / 2, grad,

segmentColor, pointColor, fonColor);

bi = (BufferedImage) createImage(w, h);

big = bi.createGraphics();

big.setRenderingHint(RenderingHints. KEY_ANTIALIASING,

RenderingHints. VALUE_ANTIALIAS_ON);

// Wir erstellen fließen, welche die Wille regelmäßig Anruf Methode aktualisieren.

timer = neuer Thread(dies);

) catch (Ausnahme e) (

System. aus.println(e);

) // Ende drin

// Dies Methode führt Neuzeichnen Fenster Applet

öffentliches Void-Update (Grafik g) (

// Wir bekommen Zeiger auf der ein Objekt Graphics2D

Graphics2D g2 = (Graphics2D) g;

// Wir zeichnen beendet Bild auf der Bildschirm

g2.drawImage(bi, 0, 0, this);

) catch (Ausnahmefehler) (

System. aus.println (error.getMessage());

private void grawSegment() (

* //Reinigung Bild big.setBackground (Color.BLUE); big.clearRect(0, 0,

// Wir zeichnen Sektion

Verschiebung + = Bewegungspunkt * Geschwindigkeitspunkt;

wenn (Verschiebung< -lengthSegment / 2) {

movePoint *= -1;

shift = -lengthSegment / 2;

) else if (shift > lengthSegment / 2) (

movePoint *= -1;

shift = lengthSegment / 2;

segment.setPos (Verschiebung, Geschwindigkeitspunkt);

segment.drehen ();

big.drawImage(segment.getSegment(), null, 0, 0);

// Dies Methode durchgeführt in trennen fließen(Timer).

// Er verursacht Neuzeichnen Fenster Applet jeden gib mir eine Sekunde.

public void run() (

Gewinde. aktueller Thread();

Gewinde. Schlaf(speedRepaint);

) catch (Ausnahmefehler) (

// Dies Methode durchgeführt wenn Benutzer links Seite

// von Applet. Er stoppt fließen(Timer) und, bzw,

// Neuzeichnen Fenster Applet.

öffentlicher void stop()(

// Diese Methode wird ausgeführt, wenn der Benutzer auf der Seite landet

// mit Applet. Es startet einen parallelen Thread (Timer).

öffentlich void start() (

if (timer == null) (

timer = neuer Thread(dies);

// Diese Methode wird ausgeführt, wenn die Seite, die das Applet enthält, geschlossen wird.

öffentliche Leere zerstören () (

super.destroy();

Gewinde. aktueller Thread();

// Warten Sie, bis der parallele Thread (Timer) beendet ist.

Gewinde. Ertrag();

) // Ende zerstören

) // Ende der öffentlichen Klasse RotatingSegment

// ein Segment erstellen

privates statisches Doppelzimmer x = 0;

letztes Doppel RAD = 10;

private doppelte Länge;

privates BufferedImage-Segment;

private FarbsegmentFarbe;

privater FarbpunktFarbe;

private Farbe backGroundColor;

privates Rectangle2D.Double r;

private Ellipse2D.Double p;

private doppelte Rotationsachse;

privates Point2D.Double Center;

private Doppelschicht;

// Winkel, um den sich die Position des Segments ändert

privates Intgrad;

Segment(double length, double posPointRotating, int grad,

FarbsegmentFarbe, FarbpunktFarbe, Farbe HintergrundGroundColor)

throwsException (

// Parameter prüfen

Wenn (Länge<= 0 || posPointRotating < 0 || length < posPointRotating)

neue Ausnahme werfen (

"Fehler: Ungültiger Parameter in Klasse Segment");

this.grad = grad;

this.segmentColor = segmentColor;

this.pointColor = punktFarbe;

this.backGroundColor = backGroundColor;

this.length = Länge;

// Zeichnung erstellen

segment = new BufferedImage((int) length * 3, (int) length * 3,

BufferedImage. TYPE_INT_ARGB);

center = new Point2D.Double(length, 3 * length / 2);

// ein Segment erstellen

rotationAxis = center.x + posPointRotating - RAD / 2;

p = new Ellipse2D.Double(rotationAxis, center.y, RAD, RAD);

// setze die Farbe des Segments

g2.setColor (Segmentfarbe);

// Segment zeichnen

// Set-Point-Farbe

g2.setColor (Punktfarbe);

// zeichne einen Punkt

// verschiebt den Drehpunkt

public void setPos(double shiftX, double shiftY) (

// ein Segment erstellen

this.shift = shiftX;

center.y = center.y + shiftY * Math. Sünde(Mathematik. bis Radiant(grad * x));

r = new Rectangle2D.Double(center.x, center.y, length, RAD);

p = new Ellipse2D.Double(rotationAxis + shift, center.y, RAD, RAD);

// Segment dreht

public void rotieren () (

Affine Transformation bei = Affine Transformation. getRotateInstance(

Mathematik. bis Radiant(grad * (++ x)), Drehachse + RAD / 2 + Verschiebung,

// Grafikkontext abrufen

Graphics2D g2 = segment.createGraphics();

// malen Sie alles mit der angegebenen Farbe

g2.setBackground (Hintergrundfarbe);

g2.clearRect(0, 0, (int) (3 * Länge), (int) (3 * Länge));

g2.setTransform(at);

g2.setColor (Segmentfarbe);

// Segment zeichnen

// Set-Point-Farbe

g2.setColor (Punktfarbe);

// zeichne einen Punkt

// Gibt ein Bild zurück

public BufferedImage getSegment() (

3. BEISPIEL FÜR DEN PROGRAMMBETRIEB

Das Ergebnis der Programmausführung:

Abbildung 1. Das Ergebnis der Programmausführung

Abbildung 2. Das Ergebnis der Programmausführung

Abbildung 3. Das Ergebnis der Programmausführung

FAZIT

Damit ist unsere Diskussion über Grafiken in Java abgeschlossen. In diesem Dokument haben wir einen kurzen Überblick über Programmierwerkzeuge für 2D-Grafiken in Java gegeben. Wir haben eine Anwendung vorgestellt, die die Verwendung von geometrischen Formen und Texturen demonstriert.

Wir haben einige der grafischen Funktionen von Java besprochen. Wir begannen mit einer kurzen Einführung in die Grundlagen der Grafik, wie Koordinatensysteme und Grafikkontexte. Wir haben dann die Java 2D-Möglichkeiten besprochen. Wir haben auch kurz die Verwendung von Grafikeffekten behandelt.

Die zweite Hälfte unserer Einführung in die grafische Programmierung in Java. Unter Verwendung der grafischen Oberfläche der Bibliotheken java.awt und javax.swing haben wir einen einfachen grafischen Editor erstellt, der ein zweidimensionales Objekt um seine Achse dreht.

REFERENZLISTE

1. H.M. Deitel, P.J. Deitel, S.I. Suntry - Java Programming Technologies, Buch 1 (Grafik, JAVABEANS, Benutzeroberfläche)

2. Judy Bishop - Effizientes Arbeiten mit Java

3. James Gosling, Bill Joy, Guy Steele, Gilad Bracha – The Java Language Specification, Zweite Auflage.

4. Tim Lindholm, Frank Yellin – The Java Virtual Machine Specification, Zweite Ausgabe.

5. Gosling J., Arnold K. – Programmiersprache Java

6. Informationen von www.ibm.com

7. Informationen von der Website www.mexmat.sgu.ru

8. Informationen von der Website www.uic.rsu.ru

Gehostet auf Allbest.ru

...

Grafikbibliotheken java. Ein kurzer Überblick über Java-GUI-Frameworks und meine erste einfache Swing-GUI-Anwendung

Java-AWT

Grundlegende SWING-Konzepte

Container auf oberster Ebene schwenken

Layered Panel JLayeredPane

ContentPane

Transparentes JOptionPane

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

JMenuBar Menüleiste

Swing-Beispiele

Senden Sie Ihre gute Arbeit in die Wissensdatenbank ist einfach. Verwenden Sie das untenstehende Formular

Ähnliche Dokumente