Swing-Komponenten ähneln AWT-Komponenten, fügen jedoch jeder Komponente neue Methoden hinzu und bieten erweiterte Komponenten.
Grundkomponenten von Swing:
1. Schaltfläche (JButton):
Schaltflächen in Swing können Bilder anzeigen, und die Schaltfläche kann als Standardsymbol für ein Fenster festgelegt werden, und einer Schaltfläche können mehrere Bilder zugewiesen werden.
(1) Häufig verwendete Konstruktionsmethoden von JButton.
JButton(String text): Auf der Schaltfläche angezeigte Zeichen.
JButton (Symbolsymbol): Zeigt das Symbol auf der Schaltfläche an.
JButton(String-Text, Symbolsymbol): Auf der Schaltfläche werden sowohl Symbole als auch Zeichen angezeigt.
(2). Häufig verwendete Methoden:
b1.setEnabled(false); //Schaltfläche derzeit nicht verfügbar machen
b1.setToolTipText("..."): //Schaltflächentipptext festlegen
b1.setMnemonic(KeyEvent.VK_D); // b1 an die Alt+D-Taste binden
(3).Fallcode:
Kopieren Sie den Codecode wie folgt:
Die öffentliche Klasse JButtonExample3 erweitert JPanel und implementiert ActionListener {
geschützter JButton b1, b2, b3;
public JButtonExample3() {
ImageIcon leftButtonIcon = createImageIcon("right.gif");
ImageIcon middleButtonIcon = createImageIcon("middle.gif");
ImageIcon rightButtonIcon = createImageIcon("left.gif");
b1 = new JButton("Ungültige mittlere Schaltfläche (D)", leftButtonIcon);
b1.setVerticalTextPosition(AbstractButton.CENTER);//Horizontale Mittelausrichtung
b1.setHorizontalTextPosition(AbstractButton.LEADING);//Entspricht LEFT
b1.setMnemonic(KeyEvent.VK_D); // b1 an die Alt+D-Taste binden
b1.setActionCommand("disable");
b2 = new JButton("M middle button", middleButtonIcon);
b2.setVerticalTextPosition(AbstractButton.BOTTOM);
b2.setHorizontalTextPosition(AbstractButton.CENTER);
b2.setMnemonic(KeyEvent.VK_M); // b2 an die Alt+M-Taste binden
b3 = new JButton("E aktiviert den mittleren Knopf", rightButtonIcon);
b3.setMnemonic(KeyEvent.VK_E); // b3 an die Alt+E-Taste binden
b3.setActionCommand("enable");
b3.setEnabled(false);
//Ereignis-Listener zu 1 und 3 hinzufügen
b1.addActionListener(this);
b3.addActionListener(this);
//Schaltflächenaufforderungstext festlegen
b1.setToolTipText("Durch Klicken auf diese Schaltfläche wird die mittlere Schaltfläche ungültig!");
b2.setToolTipText("Klicken Sie auf diese Schaltfläche, es tritt kein Ereignis ein!");
b3.setToolTipText("Durch Klicken auf diese Schaltfläche wird die mittlere Schaltfläche wirksam");
//Schaltfläche zu JPanel hinzufügen
add(b1);
add(b2);
add(b3);
}
public void actionPerformed(ActionEvent e) {
if ("disable".equals(e.getActionCommand())) {
b2.setEnabled(false);
b1.setEnabled(false);
b3.setEnabled(true);
} anders {
b2.setEnabled(true);
b1.setEnabled(true);
b3.setEnabled(false);
}
}
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = JButtonExample3.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} anders {
System.err.println("Datei konnte nicht gefunden werden: " + Pfad);
null zurückgeben;
}
}
public static void main(String[] args) {
//Einrichten, um die neue Swing-Schnittstelle zu verwenden
//Gibt einen Hinweis, ob der neu erstellte JFrame über die Fensterdekorationen verfügen soll, die durch das aktuelle Erscheinungsbild bereitgestellt werden (z. B. Rahmen, Widgets zum Schließen des Fensters, Titel usw.).
JFrame.setDefaultLookAndFeelDecorated(true);
//Erstelle ein Formular
JFrame Frame = new JFrame("Little Dragon Button");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Erstelle ein Panel
JButtonExample3 newContentPane = new JButtonExample3();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
// Formular anzeigen
frame.pack();
frame.setLocation(300, 200);
frame.setVisible(true);
}
}
Lauf-Screenshot:
2. Kombinationsfeld (JComboBox):
Ausführliche Erklärung zur Verwendung des Kombinationsfelds (Dropdown-Liste JComboBox) und Beispiele:
Bauweise:
* JComboBox() erstellt eine JComboBox-Komponente.
* JComboBox(ComboBoxModel-Modell) Erstellen Sie eine JComboBox-Komponente basierend auf dem Modell.
* JComboBox(Objext[] items) verwendet Array-Objekte, um eine JComboBox-Komponente zu erstellen.
* JComboBox (Vektorelemente) verwendet Vektorobjekte, um eine JComboBox-Komponente zu erstellen.
Häufig verwendete Methoden:
....
Umfangreiches Beispiel:
Kopieren Sie den Codecode wie folgt:
import java.awt.*; /* Enthält alle Klassen zum Erstellen von Benutzeroberflächen und zum Zeichnen von Grafiken. */
import javax.swing.*; /* Stellen Sie eine Reihe „leichter“ Komponenten bereit und versuchen Sie, dass diese Komponenten auf allen Plattformen gleich funktionieren */
Die öffentliche Klasse JComboBoxDemo erweitert JFrame {
öffentliche JComboBoxDemo() {
/*
* Container ist die übergeordnete Klasse aller Container und eine Unterklasse der Java-Sprachkomponentenklasse Component. Ein Container ist eine Komponente, die die Funktion hat, andere Komponenten und Container aufzunehmen.
* Das grundlegendste Element einer grafischen Java-Benutzeroberfläche ist eine Komponente. Eine Komponente ist ein Objekt, das grafisch auf dem Bildschirm angezeigt werden kann und mit dem Benutzer interagiert, z. B. eine Schaltfläche, ein Textfeld usw.
* In Java werden Komponenten normalerweise in einem bestimmten Container platziert und die Methode this.getContentPane() wird verwendet, um das contentPane-Objekt dieser Form zurückzugeben.
*/
Container contentPane = this.getContentPane();
/* Erstellen Sie ein Panel-Objekt und geben Sie den Layout-Manager als GridLayout, 1 Zeile und 2 Spalten an. Die Standard-Layout-Verwaltung von Jpanel ist FlowLayout */.
JPanel jPanel1 = neues JPanel(neues GridLayout(1, 2));
// JComboBox mit String-Array erstellen
String[] Fruit = { "Apple", "Banane", "Orange", "Birne", "Mango" };
JComboBox jComboBox1 = new JComboBox(fruit);
jComboBox1.addItem("Other"); //Eine weitere Option „Other“ am Ende der Listenfeldoptionen hinzufügen
//Legen Sie den Titelrand des jList1-Objekts fest
jComboBox1.setBorder(BorderFactory.createTitledBorder("Deine Lieblingsfrucht:"));
//Listenfeld jComboBox1 zum Panel hinzufügen
jPanel1.add(jComboBox1);
//ComboBoxModel verwenden, um JComboBox zu erstellen
ComboBoxModel myModel = new MyModel();
JComboBox jComboBox2 = new JComboBox(myModel);
//Legen Sie den Titelrand des jList1-Objekts fest
jComboBox2.setBorder(BorderFactory.createTitledBorder("Deine Lieblingsfrucht:"));
//Listenfeld jComboBox2 zum Panel hinzufügen
jPanel1.add(jComboBox2);
//Panel zum übergeordneten Container hinzufügen
contentPane.add(jPanel1);
//Legen Sie den Titel dieses Formulars fest
this.setTitle("JComboBoxDemo");
//Legen Sie die Anfangsgröße fest, die von diesem Formular angezeigt wird
this.setSize(350, 90);
this.setLocation(300, 200);
//Setzen Sie dieses Formular so ein, dass es zunächst sichtbar ist
this.setVisible(true);
}
Klasse MyModel erweitert DefaultComboBoxModel {
String[] Fruit = { "Apple", "Banane", "Orange", "Birne", "Mango" };
MyModel() {
for (int i = 0; i <fruit.length; i++) {
/* Die Methode addElement() wird verwendet, um Optionselemente zum Listenfeld hinzuzufügen */
this.addElement(fruit[i]);
}
}
}
public static void main(String args[]) {
JComboBoxDemo test = new JComboBoxDemo();
}
}
Screenshot:
3. Listenfeld (JList):
Die Funktion des Listenfelds ähnelt der des Dropdown-Listenfelds. Es ermöglicht Benutzern auch die Auswahl zwischen mehreren Elementen, es gibt jedoch einige Unterschiede. Es bietet Benutzern vielfältigere Auswahlmodi, einschließlich Einzelauswahl und kontinuierliche Auswahl und Mehrfachauswahl, entsprechend den 3 Konstanten in ListSelectionModel:
(1) static int SINGLE_SELECTION Es kann nur einer ausgewählt werden.
(2) static int SINGLE_INTERVAL_SELECTION Halten Sie die [Umschalt]-Taste gedrückt, um das Kontaktintervall auszuwählen.
(3) static int MULTIPLE_INTERVAL_SELECTION Halten Sie die [Strg]-Taste gedrückt, um mehrere Elemente auszuwählen.
Der Konstruktor lautet wie folgt:
(1) JList() erstellt eine JList-Komponente.
(2) JList (ListModel-Modell) Erstellen Sie eine JList-Komponente basierend auf dem Modell.
(3) JList(Object[] items) verwendet Array-Objekte, um eine JList-Komponente zu erstellen.
(4) JList (Vektorelemente) Verwenden Sie Vektorobjekte, um eine JList-Komponente zu erstellen.
Durch Hinzufügen des Listenfelds JList zum JScrollPane kann ein Scrollen des Listenfelds erreicht werden.
Beispiel 1 für die Verwendung der List-Komponente (JList) lautet wie folgt:
Kopieren Sie den Codecode wie folgt:
Die öffentliche Klasse JListDemo1 erweitert JFrame{
Container contentPane;
JPanel jp;
JList jList1,jList2,jList3;
öffentliche JListDemo1(){
contentPane = this.getContentPane();
jp = neues JPanel(neues GridLayout(1,3));
//String-Array verwenden, um ein JList-Objekt zu erstellen
String[] Fruit={"Apfel", "Banane", "Orange", "Birne", "Mango"};
jList1=neue JList(Frucht);
//Legen Sie den Titelrand des jList1-Objekts fest
jList1.setBorder(BorderFactory.createTitledBorder("Deine Lieblingsfrucht: "));
//Setzen Sie den Auswahlmodus des jList1-Objekts auf Einzelauswahl
jList1.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jp.add(jList1);
// Verwenden Sie ListModel, um ein JList-Objekt zu erstellen und die Dynamik des Listeninhalts zu realisieren
ListModel myModel=new MyModel(); //Ein Listenmodellobjekt erstellen
jList2=new JList(myModel); //Eine Liste basierend auf dem Listenmodellobjekt erstellen
jList2.setBorder(BorderFactory.createTitledBorder("Deine Lieblingsfrucht: "));
//Stellen Sie den Auswahlmodus des jList2-Objekts so ein, dass bei Mehrfachauswahl die [Strg]-Taste gedrückt gehalten wird
jList2.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jp.add(jList2);
jList3=neue JList(Frucht);
jList3.setBorder(BorderFactory.createTitledBorder("Deine Lieblingsfrucht: "));
jList3.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jList3.setVisibleRowCount(3);
jList3.setFixedCellWidth(120);
jList3.setFixedCellHeight(30);
JScrollPane jScrollPane = new JScrollPane(jList3);
jp.add(jScrollPane);
contentPane.add(jp);
this.setTitle("JListDemo");
this.setSize(340,200);
//Pack();
this.setLocation(400, 300);
this.setVisible(true);
}
// Durch die Vererbung der DefaultListModel-Klasse kann eine Listenauswahl dynamischer Inhalte erreicht werden
Klasse MyModel erweitert DefaultListModel{
String[] Fruit={"Apfel", "Banane", "Orange", "Birne", "Mango"};
MyModel(){
for(int i=0;i<fruit.length;i++){
/* void addElement(Object obj)
* Fügt die angegebene Komponente am Ende einer solchen Tabelle hinzu. */
this.addElement(fruit[i]);
}
}
}
public static void main(String[] args){
JListDemo1 test=new JListDemo1();
}
}
Die laufenden Ergebnisse sind in der folgenden Abbildung dargestellt:
Beispielcode 2 für das Listenfeld:
Kopieren Sie den Codecode wie folgt:
Die öffentliche Klasse JListDemo2 erweitert JFrame {
Container contentPane;
JPanel jp;
JList jListFont, jListSize;
//Konstrukteur
public JListDemo2() {
contentPane = this.getContentPane();
jp = new JPanel(new GridLayout());
setJListFont();
setJListFontSize();
contentPane.add(jp);
this.setTitle("JListDemo");
this.setSize(240, 200);
this.setLocation(400, 300);
this.setVisible(true);
} // Ende von JListDemo2
public void setJListFont() {
GraphicsEnvironment ge = GraphicsEnvironment
.getLocalGraphicsEnvironment();
final String fontName[] = ge.getAvailableFontFamilyNames(); // Lokale Schriftart des Systems abrufen
jListFont = new JList(fontName);
//Legen Sie den Titelrand des jList1-Objekts fest
jListFont.setBorder(BorderFactory.createTitledBorder("Systemschriftart: "));
//Setzen Sie den Auswahlmodus des jList1-Objekts auf Einzelauswahl
jListFont.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
jListFont.setVisibleRowCount(3);
jListFont.setFixedCellWidth(120);
jListFont.setFixedCellHeight(20);
JScrollPane jScrollPane1 = new JScrollPane(jListFont);
jp.add(jScrollPane1);
}
public void setJListFontSize() {
final String fontSize[] = { "8", "9", "10", "12", "14", "15", "16",
„18“, „20“, „21“, „22“, „24“, „26“, „28“, „30“, „36“, „48“,
"54", "72", "89" };
//Erstellen Sie ein Listenfeld mit Schriftgrößen listSize
jListSize = new JList(fontSize);
jListSize.setBorder(BorderFactory.createTitledBorder("Schriftgröße: "));
//Stellen Sie den Auswahlmodus des jList2-Objekts so ein, dass bei Mehrfachauswahl die [Strg]-Taste gedrückt gehalten wird
jListSize
.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
jListSize.setVisibleRowCount(3);
jListSize.setFixedCellWidth(120);
jListSize.setFixedCellHeight(20);
JScrollPane jScrollPane2 = new JScrollPane(jListSize);
jp.add(jScrollPane2);
}
public static void main(String[] args) {
JListDemo2 test = new JListDemo2();
}
}
Schematische Darstellung der Programmbedienung:
4.javax.swing
Klasse JColorChooser:
JColorChooser (Farbauswahldialog) bietet einen Controller-Bereich, der es dem Benutzer ermöglicht, Farben zu manipulieren und auszuwählen.
JColorChooser-Konstruktor:
JColorChooser(): Erstellen Sie ein JColorChooser-Objekt. Die Standardfarbe ist Weiß.
JColorChooser(Color initialColor): Erstellen Sie ein JColorChooser-Objekt und legen Sie die Anfangsfarbe fest.
JColorChooser(ColorSelectionModel modal): Konstruiert ein JColorChooser-Objekt mit ColorSelectionModel.
Die häufigste Art, JColorChooser zu verwenden, ist die Verwendung der statischen Methode showDialog() von JColorChooser. Das heißt, in den meisten Fällen erstellen wir kein neues JColorChooser-Objekt, sondern verwenden direkt die statische Methode (showDialog()) von JColorChooser Um das Dialogfeld „Farbauswahl“ auszugeben, können wir auch die vom Benutzer ausgewählte Farbe abrufen. Wenn der Benutzer dies nicht auswählt, wird ein Nullwert zurückgegeben.
Einfacher Code für Fall 1 für den Farbauswahldialog:
Kopieren Sie den Codecode wie folgt:
öffentliche Klasse JColorChooserDemo {
public static void main(String[] args) {
JFrame Frame = new JFrame("JColorChooserDemo");
MyPanel-Panel = new MyPanel();
frame.getContentPane().add(panel);
frame.pack();
frame.setLocation(300, 200);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Klasse MyPanel erweitert JPanel implementiert ActionListener {
private static final long serialVersionUID = 1L;
privater JButton-Button, RGB, Rot, Grün, Blau;
private Farbe color = new Color(255, 51, 150);
öffentliches MyPanel() {
button = new JButton("Get Color");
rgb = new JButton("RGB: ");
red = new JButton("Red: ");
grün = neuer JButton("Grün: ");
blue = new JButton("Blue: ");
button.addActionListener(this);
setPreferredSize(new Dimension(550, 250));
setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));
setBackground(color);
hinzufügen(Schaltfläche);
add(rgb);
add(rot);
add(grün);
add(blau);
}
public void actionPerformed(ActionEvent e) {
color = JColorChooser.showDialog(this, „Farbe auswählen“, color);
if (color != null) {
setBackground(color);
button.setText("Erneut abrufen");
rgb.setText("RGB: " + color.getRGB());
red.setText("Red: " + color.getRed());
green.setText("Green: " + color.getGreen());
blue.setText("Blue: " + color.getBlue());
}
}
}
Das laufende Ergebnisdiagramm sieht wie folgt aus:
Eine andere übliche Möglichkeit, JColorChooser zu verwenden, ist die Verwendung der statischen Methode createDialog(). Nach Verwendung dieser statischen Methode erhalten Sie ein JDialog-Objekt, um weitere Einstellungen für das Farbauswahldialogfeld vorzunehmen. Um diese Methode zu verwenden, müssen Sie mit dem JColorChooser-Objekt zusammenarbeiten, das heißt, Sie müssen ein neues JColorChooser-Objekt erstellen. Nach der Auswahl der Farbe können Sie die Hintergrundfarbe auf dem JLabel ändern.
Einfacher Fall-2-Code für den Farbauswahldialog:
Kopieren Sie den Codecode wie folgt:
java.awt.* importieren;
import java.awt.event.*;
javax.swing.* importieren;
öffentliche Klasse ColorChooserDemo1 erweitert MouseAdapter {
JFrame f = null;
JLabel label = null;
JLabel label1 = null;
JLabel label2 = null;
Rechteck rec1 = null;
Rechteck rec2 = null;
public ColorChooserDemo1() {
f = new JFrame("ColorChooser-Beispiel");
Container contentPane = f.getContentPane();
contentPane.addMouseListener(this);
label = new JLabel(" ", JLabel.CENTER);
label.setPreferredSize(new Dimension(300, 20));
JPanel-Panel = neues JPanel();
panel.setLayout(new GridLayout(1, 2));
label1 = new JLabel("Left Label", JLabel.CENTER);
label1.setBackground(Color.red);
label1.setForeground(Color.black);
label1.setOpaque(true);
label1.setBounds(0, 0, 150, 150);
panel.add(label1);
label2 = new JLabel("Right Label", JLabel.CENTER);
label2.setBackground(Color.green);
label2.setForeground(Color.black);
label2.setOpaque(true);
label2.setBounds(150, 0, 150, 150);
panel.add(label2);
rec1 = label1.getBounds();
rec2 = label2.getBounds();
contentPane.add(panel, BorderLayout.CENTER);
contentPane.add(label, BorderLayout.SOUTH);
f.setSize(new Dimension(300, 150));
f.setVisible(true);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
// Implementieren Sie die Methoden „mousePressed()“ und „mouseClicked()“ in MouseAdapter. Wenn die Maus gedrückt wird, können Sie die aktuelle Position des Mauszeigers ermitteln
// Wenn sich der Cursor zweimal im Etikett befindet, wird ein Dialogfeld zur Farbauswahl angezeigt, und der Benutzer kann eine beliebige Farbe auswählen, um die Farbe des Etiketts zu ändern.
public void mousePressed(MouseEvent e) {
label.setText("Die aktuellen Mauskoordinaten (X,Y) sind: (" + e.getX() + "," + e.getY() + ")");
}
public void mouseClicked(MouseEvent e) {
Punkt point = e.getPoint();
if (e.getClickCount() == 2) {
if (rec1.contains(point)) {
/*
* Verwenden Sie die statische Methode showDialog() von JColorChooser, um das Farbauswahldialogfeld auszugeben
*, die drei Parameter in showDialog() sind: übergeordnete Komponente des Dialogfelds, Farbauswahl-Dialogfeldtitel
*, mit der Standardfarbe des Dialogfelds Nachdem der Benutzer die Farbe ausgewählt hat, klickt er auf die Schaltfläche „OK“, um zurückzukehren
* Farbobjekt, wenn die Schaltfläche „Abbrechen“ gedrückt wird, wird ein Nullwert zurückgegeben.
*/
Farbe color = JColorChooser.showDialog(f,
„Change label1 Color“, Color.white);
if (color != null) // Wenn der Wert null ist, bedeutet dies, dass der Benutzer die Schaltfläche „Abbrechen“ gedrückt hat
label1.setBackground(color);
}
if (rec2.contains(point)) {
Farbe color = JColorChooser.showDialog(f,
„Change label2 Color“, Color.gelb);
if (color != null) // Wenn der Wert null ist, bedeutet dies, dass der Benutzer die Schaltfläche „Abbrechen“ gedrückt hat
label2.setBackground(color);
}
}
}
public static void main(String[] arg) {
new ColorChooserDemo1();
}
}