communityWir suchen ständig neue Tutorials und Artikel! Habt ihr selbst schonmal einen Artikel verfasst und seid bereit dieses Wissen mit der Community zu teilen? Oder würdet ihr gerne einmal über ein Thema schreiben das euch besonders auf dem Herzen liegt? Dann habt ihr nun die Gelegenheit eure Arbeit zu veröffentlichen und den Ruhm dafür zu ernten. Schreibt uns einfach eine Nachricht mit dem Betreff „Community Articles“ und helft mit das Angebot an guten Artikeln zu vergrößern. Als Autor werdet ihr für den internen Bereich freigeschaltet und könnt dort eurer literarischen Ader freien Lauf lassen.

Taschenrechner - Buttons und Ereignisse PDF Drucken E-Mail
Benutzerbewertung: / 546
SchwachPerfekt 
Geschrieben von: Kristian   
Sonntag, den 18. September 2005 um 20:01 Uhr
Beitragsseiten
Taschenrechner
Buttons und Ereignisse
Rechenoperationen
Alle Seiten

Buttons generieren

Die wesentlichen Interface-Komponenten unseres Taschenrechners sind die Schaltflächen, auch Buttons genannt. Wir möchten den Taschenrechner über diese Buttons bedienen und somit Eingaben tätigen. Zusätzlich möchten wir ein Display erzeugen welches und das Ergebnis unserer Rechnungen anzeigt. Die Implementierung von Buttons in Swing geschieht über die Klasse JButton. Wir schreiben uns nun eine Methode private void addButton(String label) welche es erlaubt Buttons in das Panel einzufügen. Wir werden aber vorerst nur die numerischen Tasten implementieren. Warum, erfahren wir im nächsten Abschnitt.

import java.awt.*;
import javax.swing.*;
 
public class Calculator
{
   public static void main(String[] args)
   {
      CalculatorFrame frame = new CalculatorFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
   }
}
 
class CalculatorFrame extends JFrame
{
   public CalculatorFrame()
   {
      setTitle("Calculator");
      CalculatorPanel panel = new CalculatorPanel();
      add(panel);
      // Größe des Fensters an seine Komponenten anpassen
      pack();
   }
}
 
class CalculatorPanel extends JPanel
{
   public CalculatorPanel()
   {
      setLayout(new BorderLayout());
      // Display hinzufügen
      display = new JButton("0");
      display.setEnabled(false);
      // Display oben positionieren
      add(display, BorderLayout.NORTH);
 
      panel = new JPanel();
      panel.setLayout(new GridLayout(4, 4)); 
      // Generierung der numerischen Taschenrechner-Tasten
      addButton("7");
      addButton("8");
      addButton("9");
 
      addButton("4");
      addButton("5");
      addButton("6");
 
      addButton("1");
      addButton("2");
      addButton("3");
 
      addButton("0");
      addButton(".");
 
      add(panel, BorderLayout.CENTER);      
   }
 
   /**
    * Taste in die mittlere Grundfläche einfügen.
    * @param label Beschriftung der Taste
    */
   private void addButton(String label)
   {
      JButton button = new JButton(label);
      panel.add(button);
   }
 
   private JButton display;
   private JPanel panel;
}

Zusätzlich passen wir die Größe des Taschenrechnerfensters so an, das es sich an die vorhandenen Subkomponenten, also an die Buttons und an das Display anpasst. Dies erreichen wir mit der Funktion void pack().

Ereignisbehandlung

Wir haben nun den Taschenrechner mit Tasten und einem Display ausgestattet. Jedoch sind diese Komponenten derzeit noch funktionslos und bei Betätigung geschieht relativ unspektakuläres, nämlich nichts. Deshalb brauchen wir eine Ereignisbehandlung. Das Betriebssystem überwacht ständig die Umgebung auf Ereignisse, die z.B. durch Mausklicks oder Tastenbetätigungen hervorgerufen werden. Anschließend werden diese Ereignisse dem Programm "mitgeteilt" und von diesem entsprechend verarbeitet. Java kapselt Ereignisse in so genannte Ereignisobjekte. Sobald ein Ereignis, wie z.B. ein Mausklick auftritt, sendet die Ereignisquelle Ereignisobjekte an alle registrierten Empfänger. Anschließend verwenden die Empfängerobjekte die Informationen in diesem Ereignisobjekt um entsprechende Reaktionen auszulösen.

Bei unseren Tasten ist ein Ereignis ein Klick auf die Schaltfläche. Das heißt sobald der Benutzer auf eine Taste klickt wird ein Ereignis, ein so genanntes ActionEvent ausgelöst. Daraufhin erfolgt eine Benachrichtigung an das listener-Objekt. Dazu ist es erforderlich in die Klasse, zu der das Empfängerobjekt (listener) gehört, eine passende Schnittstelle zu implementieren. Um die Schnittstelle zu implementieren, muss der Empfänger über eine Methode namens actionPerformed verfügen, die unser ActionEvent-Objekt als Parameter übernimmt. Sobald der Benutzer auf eine Schaltfläche klickt, erzeugt das JButton-Objekt ein ActionEvent-Objekt, ruft listener.actionPerformed(event) auf und übergibt ein entsprechendes ActionEvent-Objekt.

Für die numerischen Tasten des Taschenrechners möchten wir ein Aktionsbefehl im Falle eines Klicks auslösen. In diesem Fall soll ein entsprechender String übergeben werden. Dazu implementiert die Klasse DefaultButtonModel in Swing eine Schnittstelle mit Methoden. Einen Überblick über diese Klasse und alle ihre Methoden erhält man auf der offiziellen Java Sun Seite unter DefaultButtonModel. Für uns ist nur eine Methode der Schnittstelle ButtonModel interessant und diese sehen wir uns etwas näher an.

WertMethode
StringgetActionCommand - Die Methode gibt einen Aktionsbefehl (action command) für das entsprechende Button zurück sobald ein Ereignis ausgelöst wurde.

Wir werden nun die ActionListener Schnittstelle implementieren und Methoden includieren. Dazu verwenden wir eine neue Klasse mit dem Namen InsertAction und lassen diese das Interface ActionListener implementieren. Anschließend erweitern wir den Code der Klasse um die Methode ActionPerformed welche mittels getActionCommand() das Ereignis des Schaltflächenklicks abfängt.

Da sich der Aktionsbefehl der numerischen Tasten von den Operationstasten, wie +, -, * usw. unterscheidet, erzeugen wir zunächst nur für die numerischen Tasten eine neue Klasse. Deshalb haben wir im vorigen Abschnitt vorerst die Operationstasten ausgelassen.

import java.awt.*;
import javax.swing.*;
// Stellt die Schnittstelle und Klassen für die
// Ereignisbehandlung welche durch AWT Komponenten 
// erzeugt wurden bereit
import java.awt.event.*;
 
public class Calculator
{
   public static void main(String[] args)
   {
      CalculatorFrame frame = new CalculatorFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
   }
}
 
class CalculatorFrame extends JFrame
{
   public CalculatorFrame()
   {
      setTitle("Calculator");
      CalculatorPanel panel = new CalculatorPanel();
      add(panel);
      pack();
   }
}
 
class CalculatorPanel extends JPanel
{
   public CalculatorPanel()
   {
      setLayout(new BorderLayout());
      // Startflag setzen
      start = true;
      display = new JButton("0");
      display.setEnabled(false);
      add(display, BorderLayout.NORTH);
 
      // ActionListener insert erzeugen
      ActionListener insert = new InsertAction();
 
      panel = new JPanel();
      panel.setLayout(new GridLayout(4, 4)); 
      // Die Aktion insert als zweiten Parameter hinzufügen
      addButton("7", insert);
      addButton("8", insert);
      addButton("9", insert);
 
      addButton("4", insert);
      addButton("5", insert);
      addButton("6", insert);
 
      addButton("1", insert);
      addButton("2", insert);
      addButton("3", insert);
 
      addButton("0", insert);
      addButton(".", insert);
 
      add(panel, BorderLayout.CENTER);      
   }
 
   /**
    * @param label Beschriftung der Taste
    * @param listener der Ereignisempfänger für die Taste
    */
   private void addButton(String label, ActionListener listener)
   {
      JButton button = new JButton(label);
      // Ereignisempfänger für die Schaltfläche
      button.addActionListener(listener);
      panel.add(button);
   }
 
   /**
    * Diese Aktion fügt den String der Tastenaktion an das Ende
    * des Anzeigetextes an.
    */
   private class InsertAction implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         String input = event.getActionCommand();
         // Beim Start keinen Text anzeigen
         // Das Start Flag anschließend auf false setzen
         if (start)
         {
            display.setText("");
            start = false;
         }
         // Text anzeigen
         display.setText(display.getText() + input);
      }
   }
 
   private JButton display;
   private JPanel panel;
   private boolean start;
}


Zuletzt aktualisiert am Montag, den 14. Mai 2018 um 22:18 Uhr
 
AUSWAHLMENÜ