~Java4Beginners~
~Java4Beginners~

JMenuItem

Mit Hilfe der Klassen JMenuBar und JMenu haben wir eine Grundstuktur unserer Menüleiste festgelegt. Mit der Klasse JMenuItem können wir nun die einzelnen Unterpunkte in unserem Menü festlegen.
Um die Untermenüpunkte zu erstellen, erzeugen wir ein Objekt der Klasse JMenuItem, welchem wir im Konstruktor den Namen des Menüpunktes übergeben. Das Objekt der Klasse JMenuItem wird dem dazugehörigen JMenu-Objekt übergeben. Hierfür verfügt die Klasse JMenu über die Methode Bezeichner.add(JMenuItem-Objekt).

Notwendige Imports


import javax.swing.JMenuItem;

Deklaration


 private JMenuItem jmi_new, jmi_reset, jmi_save, jmi_open, jmi_gamePanel, 
        jmi_bombCount, jmi_timeHigh, jmi_movesHigh, jmi_help, jmi_about,
        jmi_rules, jmi_exit;
In meinen Programmen verwende ich für JMenuItem die Präix jmi. Was Sie schon erkennen können ist die Tatsache, dass die Anzahl der notwendigen Deklaration stetig steigt. Da wir jedes JMenuItem noch initialisieren und mit einem Event-Handling versehen müssen, ist es auch eine kleine Menge an Codezeilen. Aus diesem Grunde habe ich die Menüerstellung ausgelagert in eine eigene Methode.

Beispiel für das Erstellen von JMenuItem

Unser JMenuItem kann ebenfalls ein Mnemoinc besitzen. Um dafür nicht 2 Anweisungen zu schreiben, nämlich

    jmi_new = new JMenuItem("Neues Spiel");
    jmi_new.setMnemonic('N');
verwenden wir einen anderen Konstruktor, welcher neben dem Menünamentext auch gleich den Mnemonic-Buchstaben setzt. Dadurch erhalten wir folgende verkürzte Initialisierung:

    jmi_new = new JMenuItem("Neues Spiel",'N');
Die Untermenüpunkte werden in der Reihenfolge angezeigt, in welcher Sie dem JMenu hinzugefügt wurden. Um nicht mit Indexen im lauenden Programm arbeiten zu müssen, empfiehlt es sich, so lange es die Programmstruktur zulässt, die Positionierung direkt bei der Initialisierung mit vorzunehmen.

        jm_spiel = new JMenu("Spiel");
        jm_spiel.setToolTipText("Spiel starten und speichern");
        jm_spiel.setMnemonic('S');
        jmi_new = new JMenuItem("Neues Spiel",'N');
        jmi_reset = new JMenuItem("Spiel zurücksetzen");
        jmi_save = new JMenuItem("Spiel speichern");
        jmi_open = new JMenuItem("Spiel laden");
        jm_spiel.add(jmi_new);
        jm_spiel.add(jmi_reset);
        jm_spiel.add(jmi_save);
        jm_spiel.add(jmi_open);

Tastenkombinationen setzen

Das setzen der Tastenkombinationen geschieht auf 2 Ebenen. Die Erste Ebene ist das setzen des Accelerators, d. h. die Beschriftung in unserem Menü rechts neben dem Menüpunkt. Die 2te Ebene ist es, dass wir einen speziellen Event-Listener einbinden müssen, um auf Tastatureingaben zu reagieren. Für das Setzen des Accelerators benötigen wir verschiedene Klassen.
  • KeyStroke (um festzulegen, bzw. zu ermitteln, welche Taste gedrückt wurde)
  • KeyEvent (festlegen der Taste)

Accelerator setzen


// Dem Menüpunkt Neues Spiel wird die Tastaturkombination Strg + N zugwiesen
jmi_new.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, KeyEvent.CTRL_MASK));
// Dem Menüunterpunkt Hilfe wird der Zusatztext F1 zugewiesen
jmi_help.setAccelerator(KeyStroke.getKeyStroke("F1"));
// Dem Menüunterpunkt Beenden wird der Zusatztext ALT + F4 zugewiesen
jmi_exit.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, KeyEvent.ALT_DOWN_MASK));
Der ein oder andere möchte versucht sein, bei der Tastenkombination eine Kurzform zu versuchen. KeyStroke.getKeyStroke("ALT + F4") ist allerding keine gute Idee. Der Compiler zeigt zwar keinen Fehler an, allerdings wird trotzdem der String nicht angezeigt, weil es einfach keine Taste Alt + F4 gibt.

KeyListener implementieren

Um auf Tastatureingaben reagieren zu können, benötigen wir das Interface KeyListener. Dieses Interface können wir direkt in unsere Klasse implementieren.

public class mbsweeper extends JFrame implements KeyListener
{
Da wir unsere Tastaturkombinationen während der kompletten Laufzeit der Anwendung verwenden werden, können wir den KeyListener direkt unserem JFrame hinzufügen.

    void mbsweeper()
    {
        this.addKeyListener(this);
        this.setTitle("MBSweeper v1.0");
Abschließend müssen wir noch alle Methoden des Interfaces in unserer Klasse einbinden.

    @Override
    public void keyTyped(KeyEvent e) 
    {
        // Was passiert, wenn geschrieben wird
    }

    @Override
    public void keyPressed(KeyEvent e) 
    {
        //Was passiert, wenn eine Taste gedrückt wird.
        if (e.getKeyCode() == KeyEvent.VK_F1)
        {
            // Aufruf des Hilfefensters
        }      
        if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_N)
        {
            // Strg-N Neues Spiel
        }    
    }

    @Override
    public void keyReleased(KeyEvent e) 
    {
        //Was passiert, wenn eine Taste losgelassen wird
    }
Dem KeyEvent wird die Variable e übergeben. Über e.getKeyCode() wird die gedrückte Taste abgefragt. e.isControlDown prüft z. B., ob die Strg-Taste gedrückt ist.
In den if-Abfragen wird ermittelt, welche Kombination zutrifft, und was passieren soll.
Für alle anderen JMenuItem benötigen wir das Interface ActionListener. Die einzelnen JMenuItems müssen nun dem ActionListener auch hinzugefügt werden, und die abstrakte Klasse muss implementiert und überschrieben werden.

public class mbsweeper extends JFrame implements ActionListener, KeyListener
{
Nachdem wir den ActionListener hinzugefügt haben, fügen wir die einzelenen JMenuItems dem ActionListener hinzu.

        jmi_new = new JMenuItem("Neues Spiel",'N');  
        jmi_new.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, KeyEvent.CTRL_MASK));
        jmi_new.addActionListener(this);
In der abgeleiteten Methode actionPerformed ermitteln wir wie beim KeyListener das auslösende Objekt und hinterlegen im Quelltext, welche Aktionen wir durchühren möchten.

    @Override
    public void actionPerformed(ActionEvent e) 
    {
        if (e.getSource() == jmi_new)
        {
            // Neues Spiel starten
        }
    }

JSeparator

Mit dieser Klasse haben wir noch die Möglichkeit, Trennlinien in unser Menü einzubauen.

        jm_spiel.add(jmi_new);    
        jm_spiel.add(jmi_reset);
        jm_spiel.add(new JSeparator());
        jm_spiel.add(jmi_save);       
        jm_spiel.add(jmi_open);
Durch das hinzufügen eines JSeparator() an unser JMenu wird an dieser Stelle eine horizontale Trennlinie gezogen. Die Linie ist rein zu optischen Zwecken, um Bereiche optisch abzutrennen. Sie hat keine Programmrelevanten Funktionen.

nach oben Java4Beginners -- Seitenversion 1.02 -- Stand: 2017-05-01