JButton & JTextField in Java
In der
Programmiersprache Java gibt es, wie wir es in den letzten zwei Posts
mitgeteilt haben, Fenster, die auch JFrame oder auch Frame benannt werden. Mithilfe
von Fenster können wir die Programme, welches wir als Konsoleapplikation
entwickelt haben, Benutzerfreundlicher aufbauen und dem Kunden repräsentieren.
Das können wir mithilfe des Jframe erreichen. Die Frames, welches wir
programmiert haben, können bis jetzt keinerlei Funktionen anbieten. In diesem
Teil oder Kapitel werden wir deshalb die Funktionen wie Textfelder und
Schaltflächen behandeln. Zur Verständnis werden wir ebenfalls Beispiele angeben
welches wir auch auf GitHub euch zur Verfügung stellen werden.
JButton:
Ein JButton auch Button
oder Schaltfläche genannt ist eine Virtuelle Taste auf dem JFrame erscheint.
Diese Taste kann auf unterschiedliche Anwendungen unterschiedlich verwendet
werden. Meistens wird sie nach dem EVA-Prinzip ausgeführt. (EVA = Eingabe
Verarbeitung Ausgabe).
Mithilfe der Klasse
javax.swing.Button oder auch kurz javax.swing.* können wir ein einfaches Button
implementieren. Die Konstruktoren von dieser Klasse lautet wie folgt:
JButton()
// Standard Konstruktor
JButton(String text)
// Überschrift des
Buttons
JButton(Icon
icon)
//
Icon des Buttons
JButton(String
text, Icon icon)
// Text mit einem Bild
des Buttons
Icon eines JButtons:
Das Interface Icon
javax.swing.Icon ist ein Werkzeug, welches mit dem Befehl javax.swing.ImageIcon
implementiert wird. Ein ImageIcon-Objekt kann mit folgenden Konstruktoren
aufgerufen werden.
ImageIcon(String datei)
ImageIcon(URL url)
Java kann alle
Bilddateien erkennen, jedoch müssen diese die Größenordnung, welches wir in
Kapitel zwei unserer GUI Programmierreihe behandelt haben, einhalten.
AbstractButton:
Mit AbstractButton
werden die allgemeine Eigenschaften von Schaltflächen für den Entwickler
bereitgestellt. Die Superklasse javax.swing.AbstractButton bietet die folgenden Methoden:
void
setText(String text)
// legt die Beschriftung
fest
String getText()
// liefert die
Beschriftung
void
setIcon(Icon icon)
// legt das Icon fest
Icon getIcon()
// liefert das Icon
void setHorizontalTextPosition(int
pos)
void
setVerticalTextPosition(int pos)
//Legt die Horizontale
beziehungsweise die Vertikale Position des Textes relativ zum Icon fest. Dabei
werden für die Horizontale Ausrichtung die Konstanten LEFT, CENTER oder RIGHT
und für die Vertikale Ausrichtung TOP, CENTER oder BOTTOM übergeben.
void
setActionCommand(String cmd)
// Setzt den
Kommandonamen für das dem Button zugeordnete ActionEvent als Voreinstellung ist
das die Beschriftung des Buttons.
String
getActionCommand()
// Liefert den
Kommandonamen.
Ereignisbehandlung:
ActionEvent in JButtons:
Ein Button hat Anfangs keine
Funktion so kann diese auch nichts unternehmen. Um ein Button eine Funktion zu
programmieren, machen wir uns ein ActionEvent. Wird also ein Button gedrückt,
so wird ein ActionEvent an seine Ereignisempfänger gesendet.
Die dazugehörige
Registrierungsmethode sieht wie folgt aus:
void addActionListener(ActionListener
e)
Die dazugehörige
ActionListenerMethode der Klasse java.awt.ActionListener lautet:
void actionPerformed(ActionEvent
e)
Diese Methode String getActionCommand() der Klasse javax.awt.event.ActionEvent
liefert den Kommandonamen.
Bei mehreren Buttons
kann man hiermit feststellen, welcher Button gedrückt wurde.
Beispiel:
package java2enterprise;
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Random;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
public class ButtonTestEins extends JFrame implements ActionListener {
private Container c;
private JButton button;
public ButtonTestEins() {
super("Button"); //
Titel des Fensters
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
c = getContentPane();
c.setLayout(new FlowLayout());
Icon icon = new ImageIcon(getClass().getResource("Jupiter.gif"));
button = new JButton("Hier klicken", icon);
button.setToolTipText("Test");
button.addActionListener(this);
c.add(button);
setSize(300, 200);
setVisible(true);
setResizable(false);
}
public void actionPerformed(ActionEvent e) {
Random random = new Random();
c.setBackground(new Color(random.nextInt(256), random.nextInt(256),
random.nextInt(256)));
}
public static void main(String[] args) {
ButtonTestEins
laufen = new ButtonTestEins();
}
}
Dazu müssen sie ein Bild
welches möglichst Klein ist, in das Projektordner einfügen. Wir haben in diesem
Fall hier das Icon Jupiter.gif hinzugefügt.
JTextField:
Ein Objekt der Klasse javax.swing.JTextField erlaubt die Eingabe einer Textzeile, welches beliebige Spalten
besitzt. Die für diese Klasse zugehörigen Konstruktoren lauten wie folgt:
JTextField()
//Standartkonstruktor
JTextField(int columns)
//Gibt die Anzahl der
Spalten
JTextField(String text)
//Text vor der Eingabe
in das TextFeld
JTextField(String
text, int columns)
//Text und Spaltenanzahl
eines TextFelds
void
setColumns(int
columns)
int
getColumns()
void
setHorizontalAligment(int aligment)
// Legt die Horizontale
ausrichtung des Textfeldes fest. Dabei werden die Konstanten LEFT, CENTER oder
RIGHT übergeben.
Neben JTextField gibt es in Java auch
das sogenannte JPasswordField welches für die Eingabe von Passwörter geeignet
ist. Der Einzige unterschied besteht darin, dass die Eingabe des Benutzers intern
sichtbar ist und nicht auf dem Display erscheint. Anstelle des Passwortes wird
hier das sogenannte ECHO-Zeichen “*“
angezeigt.
Die für JTExtField()
geeignete Methoden lauten wie folgt:
void
setEchoChar(char
c)
// Setzt das
Echo-Zeichen auf c, c kann also beliebig sein “*“, “i“, “x“, etc.
char
getEchoChar()
// Liefert das
eingestellte Echo-Zeichen.
char[] getPassword()
// Liefert den Inhalt
des Passwortfeldes als Char-Array.
Ereignisbehandlung:
ActionEvent in JTextFields:
Wird die return-Taste innerhalb des TextFeldes gedrückt, so
erzeugt das Textfeld ein ActionEvent. Ein TextField erlaubt die Registrierung
eines ActionListener Objekts welches genau wie bei JButton funktioniert. Die Methode String getActionCommand() der Klasse ActionEvent liefert hier den Inhalt des TextFeldes.
Im folgenden
Beispielprogramm wird beim Verlassen eines Feldes sein Inhalt überprüft. Das
Feld 'Artikel' darf nicht leer sein, das Feld 'Preis' muss einen double-Wert
enthalten.
Der Eingabe-Fokus
wechselt erst dann, wenn der Inhalt korrekt ist.
Zu diesem zweck wird für
TextFelder die JComponent() Methode
void setInputVerifier(InputVerifier
verifier) aufrufen.
Die Abstrakte Klasse javax.swing.InputVerifer enthält die Methode:
abstract
boolean
verify(JComponent input)
Diese Methode muss
Anwendungsbezogen überschrieben werden. Verify liefert ein boolean-Wert zurück. Falls die Eingabe korrekt ist,
wird true und falls nicht, wird false zurückgeliefert.
package java2enterprise;
import java.awt.Color;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.InputVerifier;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class TextTestEins extends JFrame implements ActionListener {
private JTextField artikel, preis;
private JLabel msg1, msg2;
private JButton ok;
public TextTestEins() {
super("TextFelder");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container c = new Container();
c.setLayout(new GridLayout(7, 1, 0, 0));
c.add(new JLabel("Artikel"));
artikel = new JTextField(30);
artikel.setInputVerifier(new InputVerifier() {
public boolean verify(JComponent input) {
return isNotEmpty((JTextField) input);
}
});
c.add(artikel);
msg1 = new JLabel();
msg1.setForeground(Color.red);
c.add(msg1);
c.add(new JLabel("Preis"));
preis = new JTextField(30);
preis.setHorizontalAlignment(JTextField.RIGHT);
preis.setInputVerifier(new InputVerifier() {
public boolean verify(JComponent input) {
return isDouble((JTextField) input);
}
});
c.add(preis);
msg2 = new JLabel();
msg2.setForeground(Color.red);
c.add(msg2);
ok = new JButton("OK");
ok.addActionListener(this);
c.add(ok);
pack();
setVisible(true);
}
private boolean isNotEmpty(JTextField f) {
String s = f.getText().trim();
if
(s.length() == 0) {
msg1.setText("Bitte die
Artikelbezeichnung angeben:");
return false;
}
else {
msg1.setText("");
return true;
}
}
private boolean isDouble(JTextField f) {
String s = f.getText().trim();
try {
Double.parseDouble(s.trim());
msg2.setText("");
return true;
}
catch (NumberFormatException
ex) {
msg2.setText("Bitte eine Zahl eingeben");
return false;
}
}
public void actionPerformed(ActionEvent e) {
if(isNotEmpty(artikel) &&
isDouble(preis)) {
System.out.println("Artikel: "+artikel.getText()+" ,
Preis: "+preis.getText());
artikel.setText("");
preis.setText("");
}
}
public static void main(String[] args) {
new
TextTestEins();
}
}
Die beiden Beipsiele
haben wir >>HIER<< für euch auf GitHub hochgeladen.
In Teil 4 unser
GUI-Programmierungreihe werden wir die sogenannten JCheckBox und JRadiobutton
sowie JTextArea behandeln. Viel Spaß beim Preogrammieren.
Kommentare
Kommentar veröffentlichen