~Java4Beginners~
~Java4Beginners~

JFrame

JFrame stellt uns das Standardfenster für die grafische Oberflächenprogrammierung unter Java zur Verfügung. JFrame nimmt die Container mit Ihren Bedienelementen auf.

Notwendiger Import


import javax.swing.JFrame;

Beispiel


import java.awt.Color; //benötigt für Hintergrundfarbe
import javax.swing.JFrame; // benötigt für Objekterzeugung von JFrame

/**
 * Beispielprogramm für das Erzeugen eines Objekts der Klasse JFrame
 * @author Markus Badzura
 */
public class Fenster 
{
    public static void main(String[] args) 
    {
        JFrame j = new JFrame();
        j.setTitle("JFrame"); // Fensterüberschrift
        j.setSize(500,200); // Fenstergröße
        j.setLocationRelativeTo(null); // Fensterplatzierung mittig
        j.setLayout(null); // Festlegung Layoutmanager
        j.getContentPane().setBackground(Color.blue); // Hintergrundfarbe
        j.setVisible(true);// sichtbar machen
        j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Thread beenden

    }
}
Als Ergebnis dieses kleinen Quellcodes erhalten wir folgendes Fenster.


Methoden

Hier ein Auszug einiger Methoden der Klasse JFrame.
Methode Erklärung
setTitle("Name in der Titelzeile") Mit dieser Methode legen wir den Text in der Titelzeile unseres Fensters fest.
setSize(Breite in px, Länge in px) Diese Methode, welche unsere Fenstergröße beim Start festlegt. Als Parameter wird die Breite in Pixel und die Höhe in Pixel übergeben.
setMinimumSize(Dimension d) Diese Methode gibt an, wie groß der JFrame mindestens sein muss, wenn das Fenster verkleinert wird.
setResizable(boolean b) Mit false kann die Größe des JFrames nicht geändert werden.
setLocationRelativeTo(null) Mit dieser Methode sorgen wir dafür, dass unser erzeugtes Fenster mittig angezeigt wird. Wenn wir eine bestimmte Position auf unserem Monitor möchten, können wir die Methode setLocation() verwenden. Dieser Methode werden 2 int-Wert übergeben. Wert1 gibt den Pixelabstand von links, Wert2 den Pixelabstand von oben an.
setLayout(null) Mit setLayout legen wir den zu verwendenden Layout-Manager fest. Durch die Angabe null geben wir an, dass wir ohne Layout-Manager arbeiten.
getContentPane().setBackground(COLOR.blue) Mit getContentPane() fragen wir die aktuelle Ebene ab und weisen dieser Ebene (hier unser FJrame) mit .setBackground(Farbe) eine Hintergrundfarbe zu. Wenn wir die Farbe mit COLOR.farbe zuweisen, wird in NetBeans schon automatisch der import der Klasse Color automatisch eingetragen.
setVisible(Bool-Wert) Mit dem Bool-Wert true wird das Fenster sichtbar, mit false machen wir das Fenster unsichtbar.
setDefaultCloseOperation(JFrame.XXXXX) Mit dieser Methode legen wir fest, was passiert, wenn jemand ALT + F4, oder das Kreuz zum schließen des Fensters verwendet. XXXX steht hierbei für die Auswahlmöglichkeiten.
setState(JFrame.NORMAL)
setState(JFrame.ICONIFIED)
Maxmiert oder Minimiert den JFrame

setExtendedState()

Diese Methode wurde JFrame aus der Klasse Frame vererbt. Mit dieser Methode haben wir z. B. die Möglichkeit, dass unser TopLevelContainer maximiert dargestellt wird. Die Methode verwendet verschiedene Konstanten.

    setExtendedState(JFrame.MAXIMIZED_BOTH);
Diese Anweisung sorgt dafür, dass das Fenster beim öffnen maximiert, d. h. über die komplette Bildschirmbreite und Bildschirmhöhe dargestellt wird.

Bildschirmgröße ermitteln

Bei der Entwicklung von grafischen Oberflächen ist es sinnvoll, wenn man weiß, wie groß die Bildschirmauflösung ist. Dieses lässt sich relativ einfach herausfinden.

    private final Dimension SCREENSIZE = java.awt.Toolkit.getDefaultToolkit().getScreenSize ();
Somit lässt sich auch einfach die Höhe und Breite rausfiltern. Dies kann nötig sein, wenn man z. B. eine Fenster exakt in der Bildschirmmitte platzieren möchte.

    private final int SCREEN_WIDTH = SCREENSIZE.width;
    private final int SCREEN_HEIGHT = SCREENSIZE.height;

setMinimumSize

Mit folgendem Beispiel startet dar JFrame mit maximalser Fenstergröße und kann nur auf die Größe 800 * 600 Pixel verkleinert werden.

Dimension SCREENSIZE = java.awt.Toolkit
          .getDefaultToolkit().getScreenSize ();
this.setSize(SCREENSIZE);
this.setMinimumSize(new Dimension(800,600));

setDefaultCloseOperation

Wie bereits erwähnt, legen wir mit dieser Methode das Verhalten beim Schließen des Fensters fest. Wenn wir wollen, dass das Fenster und alle dazugehörigen Ressourcen geschlossen werden, sieht die Methode wie folgt aus.

    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
Sollte setDefaultCloseOperation nicht festgelegt werden, dann wird zwar das Fenster geschlossen, während das Programm, bzw. die Aplikation weiter aktiv ist.
  • DO_NOTHING_ON_CLOSE bewirkt, dass unser Fenster nicht schließbar ist.
  • HIDE_ON_CLOSE sorgt dafür, dass die Verbindung auf die Information im Arbeitsspeicher verbleibt und somit ein neues Öffnen des Fensters schneller erfolgt.
  • DISPOSE_ON_CLOSE trennt diese Verbindung zum Speicher. Das Fenster muss komplett neu aufgebaut werden.

setState()

Mit dieser Methode können wir unseren JFrame minimieren (JFrame.ICONIFIED) oder wieder maximieren (JFrame.NORMAL). Mit Minimieren werden wir weniger zu tun haben, da dies über die Titelleiste passieren kann, aber das Maximieren benötigen wir dafür öfters.

Ein Beispiel:

Wir haben eine Anwendung (JFrame) , aus der wir ein Hilfefenster aufrufen (ebenfalls ein JFrame). Wenn das Hilfefenster minimiert ist, arbeitet der Benutzer munter weiter, bis er wieder Hilfe benötigt. Er ruft also, nachdem das Hilfefenster nicht sichtbar ist, erneut die Hilfe auf. Da das Hilfefenster allerdings nur minimiert ist, soll natürlich kein neues Hilfefenster geöffnet werden, sondern das bestehende wieder maximiert werden.

Durch einen boolschen Wert können wir prüfen, ob ein Hilfefenster aktiv ist. Wenn nein, dann öffnen wir ein Hilfefenster, wenn ja, dann maximieren wir es.

Hier der Aufruf für das Hilfefenster

rezeptinator_hilfe rzh = new rezeptinator_hilfe();
.. .. .. .. .. .. .. .. .. .. .. .. .. 
    /**
     * Hilfefenster öffnen
     * @author Markus Badzura
     * @since 1.0.003
     */
    private void oeffneHilfe()
    {
        if (!rzh.isAktiv())
            rzh.rezeptinator_hilfe(VERSION);
    }
Hier die Methode isAktiv() aus meiner Hilfeklasse.

public class rezeptinator_hilfe extends JFrame implements ComponentListener, ListSelectionListener
        ,ChangeListener, ActionListener
{
    ///////////////////////////////////////////////////////////////////////////
    //                                                                       //
    // Initialisierung aktiv mit false                                       //
    //                                                                       //
    ///////////////////////////////////////////////////////////////////////////
    boolean aktiv = false;    

    .. .. .. .. .. .. .. .. .. .. .. .. .. 

    public void rezeptinator_hilfe(String version)
    {
        try 
        {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } 
        catch (ClassNotFoundException | IllegalAccessException | InstantiationException | UnsupportedLookAndFeelException e) 
        {
            System.err.println("Setting Look and Feel Failed");
        }
        // aktiv im Konstruktor auf true gesetzt.
        aktiv = true;

    .. .. .. .. .. .. .. .. .. .. .. .. .. 


    /**
     * Prüfung, ob Hilfefenster bereits aktiv ist. Wenn aktiv, dann wird
     * das Hilfefenster in den Vordergrund geholt
     * @return aktiv Bool-Wert
     * @author Markus Badzura
     * @since 1.0.005
     */
    public boolean isAktiv()
    {
        if (aktiv)
        {
            this.setState(JFrame.NORMAL);   
        }
        return aktiv;
    }

Rückfrage ob wirklich geschlossen werden soll.

Auch wenn ich hier auf andere Themen schon vorgreife, ist es sinnvoll, sein Top-Level-Container gegen unbeabsichtigtes Schließen zu sichern.
Hierfür sind verschiedene Schritte notwendig.
  1. Dafür Sorgen, dass sich das Fenster nicht mit dem X in der Titelleiste, oder der Tastenkombination ALT + F4 schließen lässt.
  2. Ein Event implementieren, welches die unter 1 genannten Punkte als WindowEvent abfängt.
  3. Eine Methode implementieren, in welcher die Abfrage durchgeführt wird, ob wirklich beendet werden soll.
  4. Das Ergebnis dieser Abfrage auswerten.
Nachfolgend sehen Sie den Quelltext für die Punkte 1 bis 4, welche dafür sorgen, dass beim Schließen des Fensters die Abfrage erfolgt, ob wirklich geschlossen werden soll.

        // DO_NOTHING_ON_CLOSE, damit das Fenster nicht schließbar ist.
        this.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
        // WindowAdapter hinzufügen, welcher auf das WindowEvent windowClosint reagiert
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e)
            {
                // Aufruf der Methode exit, welche die Abfrage beinhaltet.
                exit();
            }
        });
Nun muss nur noch die Methode exit() implementiert werden.

    /**
     * Abfragedialog beim Beenden des Programmes, inclusive des Schließens
     * über ALT + F4 und dem Schließbutton über die Titelleiste.
     * @author Markus Badzura
     * @version 1.0
     */
    private void exit()
    {
        // JOptionPane mit den Schlatflächen YES und NO. Wert der gedrückten Schaltfläche wird in result abgelegt.
        int result = JOptionPane.showConfirmDialog(null, "Möchten Sie wirklich beenden?",
                "Programm beenden", JOptionPane.YES_NO_OPTION);
        // Abfrage des Wertes result
        switch (result)
        {
            // False YES gedürckt wurde, Programm verlassen.
            case JOptionPane.YES_OPTION:
                System.exit(0);
        }
    }

Icon in der Titelleiste ändern

Wir haben die Möglichkeit die berühmte Java-Kaffeetasse auch gegen andere Images auszutauschen.
Hierfür gehen wir in 3 Schritten vor.
  1. Angeben des Pfades zu unserem Images innerhalb des Projektes
  2. Erstellen eines ImageIcon - Objektes
  3. Das ImageIcon in unserem JFram setzen.

    // Pfadangabe zum Image
    private static final URL URLICON = mbsweeper.class.getResource("Icon.gif");
    // Erstellen ImageIcon-Objekt
    private static final ImageIcon ICON = new ImageIcon(URLICON);
    . . . . . . . . 
    void mbsweeper()
    {
        this.setTitle("MBSweeper v1.0");
        // ImageIcon dem JFrame hinzusetzen.
        this.setIconImage(ICON.getImage());
    . . . . . . . . . .    
Im Internet kursieren viele weitere, kürzere Versionen, die allerdings nur funktionieren, wenn das Programm über die IDE gestartet wird.
Sollte das ganze als JAR gestartet werden, findet eine Vielzahl der Internetlösungen die Grafik nicht mehr und zeigt weiterhin die Kaffeetasse an.

Hintergrundbild setzen

Wenn wir dem JFrame ein Hintergrundbild setzen möchten, werden wir feststellen, dass JFrame nicht über eine Methode zum setzen des Hintergrundes verfügen.

Um trotzdem ein Hintergrundbild einzufügen, schreiben wir unsere eigenen "Background"-Methode, in welcher wir das Hintergrundbild zeichnen.

import java.awt.Graphics;
import java.awt.Image;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

/**
 * Hintergrund für Startfenster
 * @author Markus Badzura
 * @version 1.0.002
 */
public class rezeptinator_hintergrund extends JPanel
{
    private Image img;
    /**
     * Konsturktur zum setzen des Image-Objektes
     * @author Markus Badzura
     * @since 1.0.002
     */
    public rezeptinator_hintergrund() 
    {
        ImageIcon imageIcon = new ImageIcon(getClass().getResource("holz.jpg"));
        img = imageIcon.getImage();
    }
    /**
     * Zeichnen der Bildkomponente
     * @param g Graphics-Objekt
     * @author Markus Badzura
     * @since 1.0.002
     */
    @Override
    protected void paintComponent(Graphics g) 
    {
        super.paintComponent(g);
        g.drawImage(img, 0, 0, this);

    }
    /**
     * Image-Objekt weiterreichen
     * @return img Image
     * @author Markus Badzura
     * @since 1.0.002
     */
    public Image getBackgroundImage() {
        return img;
    }
}   
Nun können wir von unserer Hintergrundklasse in unserer Anwendung ein Objekt erstellen und das Hintergrundbild erstellen.

        rezeptinator_hintergrund bgp = new rezeptinator_hintergrund();
        bgp.setBounds(0,0,SCREENSIZE.width,SCREENSIZE.height);
        this.add(bgp);
nach oben Java4Beginners -- Seitenversion 1.05 -- Stand: 2017-06-23