(Studienreferenzbuch: Java2-Tutorial, fünfte Ausgabe)
Erstens die GUI-Programmierung
Containerklasse (Container) und Komponentenklasse (Komponente). Die JComponent-Klasse im Paket javax.swing ist eine direkte Unterklasse der Container-Klasse im Paket java.awt und eine indirekte Unterklasse der Component-Klasse im Paket java.awt. Grundkenntnisse der GUI-Programmierung:
- Java ruft ein Objekt, das von einer Unterklasse oder einer indirekten Unterklasse der Component-Klasse erstellt wurde, als Komponente auf
- Java nennt das von einer Unterklasse oder indirekten Unterklasse von Container erstellte Objekt einen Container
- Sie können dem Container Komponenten hinzufügen. Die Container-Klasse stellt eine öffentliche Methode add () bereit. Ein Container kann diese Methode aufrufen, um dem Container Komponenten hinzuzufügen.
- Der Container ruft die Methode removeAll () auf, um alle Komponenten im Container zu entfernen, und ruft die Methode remove (Component c) auf, um die durch den Parameter c angegebene Komponente zu entfernen.
- Der Container selbst ist auch eine Komponente, sodass Sie einen Container zu einem anderen Container hinzufügen können, um eine Verschachtelung der Container zu erreichen.
- Immer wenn eine neue Komponente zum Container hinzugefügt oder daraus entfernt wird, sollte der Container die validate () -Methode aufrufen, um sicherzustellen, dass die Komponenten im Container korrekt angezeigt werden können.
Zweitens das Fenster
GUI-basierte Anwendungen können einen Container bereitstellen, der direkt mit dem Betriebssystem interagieren kann. Der Container kann direkt auf der vom Betriebssystem gesteuerten Plattform (Anzeige) angezeigt und gezeichnet werden. Ein solcher Container wird im GUI-Design als unterer Container bezeichnet. Das Objekt, das von der von Java bereitgestellten JFrame-Klasse erstellt wird, ist ein Container auf niedriger Ebene, der allgemein als Fenster bezeichnet wird. (Das von der JDialog-Klasse erstellte Objekt ist auch ein Container auf niedriger Ebene, der allgemein als Dialogfeld bezeichnet wird.) Wenn Sie ein Fenster benötigen, können Sie JFrame oder seine Unterklassen zum Erstellen eines Objekts verwenden.
(1) Häufig verwendete Methoden von JFrame:
JFrame()创建一个无标题的窗口
JFrame(String s)创建标题为s的窗口
public void setBounds(int a,int b,int width,int height)设置窗口的初始位置为（a,b），即距屏幕左边a个像素，距屏幕上方b个像素，窗口的宽是width，高是height
public void setSize(int width,int height)设置窗口的大小宽是width，高是height
public void setLocation(int x,int y)设置窗口的位置，默认位置是（0，0）
public void setVisible(boolean b)设置窗口是否可见，窗口默认不可见
public void setResizable(boolean b)设置窗口是否可调整大小，默认可调整大小
public void dispose()撤销当前窗口，并释放当前窗口所使用的资源
public void setExtendedState(int state)设置窗口的扩展状态，其中参数state取JFrame类中的· 下列类常量：
MAXIMIZED_HORIZ 水平方向最大化
MAXIMIZED_VERT 垂直方法最大化
MAXIMIZED_BOTH 水平垂直方向都最大化
public void setDefaultCloseOperation(int operation)设置单击窗体右上角关闭图标后，程序会做出怎样的处理。其中参数operation取JFrame类中int static常量：
DO_NOTHING_ON_CLOSE 什么也不做
HIDE_ON_CLOSE 隐藏当前窗口
DISPOSE_ON_CLOSE 隐藏当前窗口，并释放窗体占有的其他资源
EXIT_ON_CLOSE 结束窗口所在的应用程序
(2) Menüleiste, Menü und Menüpunkt
Diese drei Komponenten werden üblicherweise in Fenstern verwendet. Das Menü befindet sich in der Menüleiste und der Menüpunkt im Menü .
- Menüleiste: JMenubar, eine Unterklasse der JComponent-Klasse, ist für die Erstellung einer Menüleiste verantwortlich, dh ein von JMenubar erstelltes Objekt ist eine Menüleiste. JFrame verfügt über eine Methode zum Platzieren der Menüleiste im Menü:
setJMenuBar (JMenuBar-Leiste) Diese Methode fügt die Menüleiste oben im Fenster hinzu. Dem Fenster kann nur eine Menüleiste hinzugefügt werden - Menü: JMenu, eine Unterklasse von JComponent, ist für die Erstellung von Menüs verantwortlich, dh ein von JMenu erstelltes Objekt ist ein Menü
- Menüelement: JMenuItem, eine Unterklasse der JComponent-Klasse, ist für das Erstellen von Menüelementen verantwortlich, dh ein von JMenuItem erstelltes Objekt ist ein Menüelement
- Eingebettetes Untermenü: JMenu ist eine Unterklasse von JMeunItem, daher ist das Menü selbst auch ein Menüelement. Wenn einem Menü ein Menü als Menüelement hinzugefügt wird, wird das hinzugefügte Menü als Untermenü bezeichnet
- Symbol im Menü: Um dem Menüelement ein Symbol zuzuweisen, können Sie mit der Symbolklasse Symbol ein Symbol deklarieren und anschließend mit der Unterklasse ImageIcon ein Symbol erstellen. Anschließend ruft der Menüpunkt die
Methode setIcon (Symbolsymbol ) auf, um das Symbol als Parametersymbol festzulegen
Drei gemeinsame Komponenten und Layout
(1) Gemeinsame Komponenten: Alle Unterklassen von JComponent
JTextField 文本框，允许用户在文本框输入单行文本
JTextArea 文本区，允许用户在文本区输入多行文本
JButton 按钮，允许用户单击按钮
JLabel 标签，标签为用户提供提示信息
JCheckBox 复选框，为用户提供多项选择，并提供两种状态，一种是选中，一种是未选中，用户通过单击该组件切换状态
JRadioButton 单选按钮，为用户提供单项选择
JComboBox 下拉列表，为用户提供可单项选择的列表
JPasswordField 密码框，允许用户在框内输入单行密码，密码的默认回显字符是*。可以使用setEchoChar(char c)重新设置回显字符，调用char[] getPassword()方法返回用户在密码框中输入的密码。
(2) Allgemeine Container: JComponent bietet speziell einige Container an, die häufig zum Hinzufügen von Komponenten verwendet werden. Im Vergleich zum unteren JFrame-Container werden diese Container häufig als Zwischencontainer bezeichnet. Der Zwischenbehälter muss zum unteren Behälter hinzugefügt werden, um zu funktionieren.
JPanel 面板，创建有个面板后，再向其中添加组件，然后把这个面板添加到其他容器中。JPanel面板的默认布局是FlowLayout布局
JTabbedPane 选项卡窗口，当用户向其中添加一个组件时，选项卡窗口自动为该组件指定一个对应的选项卡，即让一个选项卡对应一个组件。各个选项卡对应 的组件层叠式放入该容器中，当用户单击选项卡时，容器会显示选项卡对应的组件。选项卡默认在该容器的顶部，从左向右依次排列。使用add(String text,Component c);方法将组件c添加到选项卡容器中去，并且对应文本提示是text。
JScrollPane 滚动窗格，只可以添加一个组件，可以把组件放到一个滚动窗格中，然后通过滚动条来观看该组件比如JTextArea不自带滚动条，因此把文本区放到滚动窗口中：JScrollPane scroll = new JScrollPane(JTextArea);
JSplitPane 拆分窗格，是被分成两部分的容器。具有水平拆分和垂直拆分。水平拆分窗口就是左右各一组件，中间用可以水平移动的拆分线隔。垂直拆分同理。
两个常用构造方法：
JSplitPane(int a,Component b,Component c);参数a取该类的静态常量HORIZONTAL_SPLIT或VERTICAL_SPLIT,决定是水平还是垂直
JSplitPane(int a,boolean b,Component c,Component d);参数a同上决定方向，参数b决定当拆分线移动时，组件是否连续变化（true是连续）
JLayeredPane 分层窗格，如果添加到容器的组件经常需要处理重叠问题，就可以考虑将组件添加到分层窗格中。分层窗格分为5层，使用add(Jcomponentcom,int layer)添加组件com，并指定com所在的层。layer的取值是该类中的类常量:DEFAULT_LAYER（最底层）,PALETTE_LAYER, MODAL_LAYER,POPUP_LAYER,DRAG_LAYER（最上层）。
如果分层窗口添加了多个组件，当用户用鼠标移动一组件时，可以把该组件放到最上层。添加到同一层的组件，如果发生重叠，后添加的会遮挡先添加的组件。分层窗格调用public void setLayer(Component c,int layer)可以重新设置组件c所在的层，调用public int getLayer(Component c)可以获取c所在的层数。
(3) Allgemeines Layout: Das Layout kann die Position der Komponente im Container steuern. So legen Sie das Layout fest:setLayout(布局对象);
FlowLayout 常用构造方法FlowLayout();可以创建一个居中对齐的布局对象使用add方法将组件顺序添加到容器中，组件按照先后顺序从左到右排列，一行排满后就转到下一行继续从左到右排列。组件的大小默认为最佳大小，如需调整需调用public void setPreferredSize(new Dimension(int x,int y))。调用setAlignment(int align)方法可以重新设置布局的对齐方式，其中参数align取值FlowLayout.LEFT、FlowLayout.CENTER、FlowLayout.RUGHT。
BorderLayout 使用这种布局的容器将空间简单分为东西南北中5个区域，每一个添加的组件应该指明添加到哪个区域中。区域由静态常量表示：CENTER、NORTH、SOUTH、WEST、EAST例：将组件b添加到使用该布局的容器con中：con.add(b,BorderLayout.CENTER);
CardLayout 使用该布局的容器可以容纳多个组件，这些组件被层叠放入容器中，最先加入的容器是第一张（最上面），依次向下排列。该布局的特点是：同一时刻容器只能从这些组件中选一个出来显示。假设有一个容器con，使用步骤如下：
(1)创建CardLayout对象作为布局：CardLayout card = new CardLayout();
(2)为容器设置布局：con.setLayout(card)
(3)容器调用add(String s,Component b)将组件b加入容器，给出代号s（不是组件的名字）
(4)用代号显示组件：card.show(con,s);也可按顺序显示
GridLayout 使用较多的布局编辑器，把容器划分为若干行乘若干行的网格区域。组件位于每一个小格中，调用方法add(Component c)将组件c加入容器
null 空布局可以准确定位组件在容器内的大小和位置。setBounds(int a,int b,int width,int height)方法是所有组件都拥有的一个方法。使用方法：
(1)设置容器p为空布局：p.setLayout(null)
(2)添加组件：p.add(Component c)
(3)设置大小和位置：c.setBounds(int a,int b,int width,int height)
BoxLayout 盒式容器，可以利用容器的嵌套，将某个容器嵌入几个盒式容器，达到布局目的。使用静态方法createHorizontaBox()获得一个行型盒式容器，createVerticalBox获得一个列型盒式容器。使用水平支撑和垂直支撑控制布局容器和组件之间的距离。createHorizontalStrut(int width)得到一个不可见的水平支撑，宽度为width;createVerticalStrut(int height)得到一个不可见的垂直支撑，高度为height。
Viertens, Ereignisse behandeln
Das Programm reagiert auf die Operationen des Benutzers auf der Schnittstelle, um eine bestimmte Aufgabe zu erfüllen, die als Behandeln von Ereignissen bezeichnet wird.
(1) Ereignisverarbeitungsmodus
Ereignisquelle : Objekte, die Ereignisse generieren können, können als Ereignisquellen bezeichnet werden, z. B. Textfelder, Schaltflächen und Dropdown-Listen. Die Ereignisquelle muss ein Objekt sein, und dieses Objekt muss ein Objekt sein, von dem Java glaubt, dass es passieren kann.
Überwachen : Ein Objekt wird benötigt, um die Quelle des Ereignisses zu überwachen, um das auftretende Ereignis zu behandeln. Die Ereignisquelle registriert ein Objekt als eigenen Monitor, indem sie die entsprechende Methode aufruft. Die entsprechende Operation des Benutzers führt dazu, dass das entsprechende Ereignis auftritt, und benachrichtigt den Monitor, um die entsprechende Behandlung durchzuführen.
Schnittstelle zur Behandlung von Ereignissen : Ein Monitor ist ein Objekt. Um Ereignisse aus der Ereignisquelle zu verarbeiten, ruft der Monitor automatisch eine Methode auf. Java legt Folgendes fest: Damit der Monitor Ereignisse aus der Ereignisquelle verarbeiten kann, muss die Klasse, die den Monitor erstellt hat, die entsprechende Schnittstelle implementieren, und der Monitor ruft die Schnittstellenmethode auf, die von der Klasse beim Auftreten des Ereignisses überschrieben wird.
(2) ActionEvent-Ereignis
ActionEvent-Ereignisquelle : Textfelder, Schaltflächen, Menüelemente , Kennwortfelder und Optionsfelder können ActionEvent-Ereignisse auslösen, dh sie können alle zur Ereignisquelle von ActionEvent-Ereignissen werden.
Registrieren eines Monitors : Java legt fest, dass Komponenten, die ActionEvent-Ereignisse auslösen können, die Methode addAction Listener (ActionListener listen) (der Parametertyp ist eine Schnittstelle) verwenden, um eine Instanz einer Klasse zu registrieren, die die ActionListener-Schnittstelle als Monitor der Ereignisquelle implementiert.
ActionListener-Schnittstelle : Nachdem die Ereignisquelle das ActionEvent-Ereignis ausgelöst hat, ruft der Monitor die Aktion Performed (ActionEvent e) auf, um das Ereignis zu verarbeiten.
Methoden in der ActionEvent-Klasse: Es gibt zwei gängige Methoden:
（1） public Object getSource() 该方法被ActionEvent事件对象调用后可以获取ActionEvent事件的事件源对象的引用，即getSource()方法可以将事件源上转型为Object对象，并返回这个上转型对象的引用。
（2） public String getActionCommand() ActionEvent对象调用该方法可以获取发生ActionEvent事件时，和该事件相关的一个命令。
(3) ItemEvent-Ereignis
ItemEvent-Ereignisquelle : Auswahlfeld, Dropdown-Liste kann ItemEvent-Ereignis auslösen. Die Änderung des Auswahlstatus des Auswahlfelds und die Bestätigung der Auswahl jedes Elements in der Dropdown-Liste kann das Ereignis auslösen.
Registrieren eines Monitors : Die Komponente, die das Ereignis auslösen kann, registriert mit addItemListener (ItemListener listen) eine Instanz der Klasse, die die ItemListener-Schnittstelle implementiert, als Monitor der Ereignisquelle.
ItemLisenter-Schnittstelle : Nachdem die Ereignisquelle das Ereignis ausgelöst hat, ruft der Monitor die einzige Methode public void itemStateChanged (ItemEvent e) in dieser Schnittstelle auf, um das Ereignis zu verarbeiten.
(4) DocumentEvent-Ereignis
Dokumentereignisquelle : Der Textbereich enthält eine Instanz, die die Dokumentschnittstelle implementiert, die als vom Text verwaltetes Dokument bezeichnet wird. Das Dokument kann das DocumentEvent-Ereignis auslösen, und der Textbereich ruft die Methode get Document auf, um das verwaltete Dokument zurückzugeben.
Registrieren des Monitors : Die Ereignisquelle, die das Ereignis auslösen kann, registriert mit addDocumentListener (DocumentLis tener listen) die Instanz der Klasse, die die DocumentListener-Schnittstelle implementiert, als Monitor der Ereignisquelle.
DocumentListener-Schnittstelle : Diese Schnittstelle verfügt über drei Methoden:
public void changedUpdate(DocumentEvent e) //变化更新
public void removeUpdate(DocumentEvent e) //删除更新
public void insertUpdate(DocumentEvent e) //输入更新
Nachdem die Ereignisquelle das Dateiereignis ausgelöst hat, ruft der Monitor die entsprechende Methode in der Schnittstelle auf, um das Ereignis zu behandeln.
(5) MouseEvent-Ereignis
Jede Komponente kann ein Mausereignis auslösen. Die MouseEvent-Klasse erstellt also automatisch ein Ereignisobjekt. Die Methode der Ereignisquellenüberwachung ist addMouseListener(MouseListener listener).
Verwenden der MouseListener-Schnittstelle zum Behandeln von Mausereignissen : Diese Schnittstelle kann Mausoperationen aus fünf Triggerereignisquellen verarbeiten: Drücken, Loslassen, Klicken, Eingeben und Beenden.
Wichtige Methoden der MouseEvent-Klasse:
getX() 获取鼠标指针在事件源坐标系中的x坐标
getY() 获取鼠标指针在事件源坐标系中的y坐标
getModifiers() 获取鼠标的左键或右键。分别用InputEvent类中的常量BUTTON1_MASK和BUTTON3_MASK表示
getClickCount() 获取鼠标被单击的次数
getSource() 获取发生鼠标事件的事件源
MouseListener的重要方法：
mousePressed(MouseEvent e) 处理在组件上按下鼠标触发的鼠标事件
mouseReleased(MouseEvent e) 处理在组件上释放鼠标键触发的鼠标操作
mouseEntered(MouseEvent e) 处理鼠标进入组件触发的鼠标事件
mouseExited(MouseEvent e) 处理鼠标离开组件触发的鼠标事件
mouseClicked(MouseEvent e) 处理在组件上单击鼠标键触发的鼠标事件
Wichtige Methoden von MouseListener:
mousePressed(MouseEvent e) 处理在组件上按下鼠标触发的鼠标事件
mouseReleased(MouseEvent e) 处理在组件上释放鼠标键触发的鼠标操作
mouseEntered(MouseEvent e) 处理鼠标进入组件触发的鼠标事件
mouseExited(MouseEvent e) 处理鼠标离开组件触发的鼠标事件
mouseClicked(MouseEvent e) 处理在组件上单击鼠标键触发的鼠标事件
Verwenden Sie die MouseMotionListener-Schnittstelle, um Mausereignisse zu behandeln : Diese Schnittstelle behandelt die Vorgänge, die durch Ziehen und Bewegen der Maus auf der Ereignisquelle ausgelöst werden. Die am häufigsten verwendeten Methoden sind:
addMouseMotionListener(MouseMotionListener listener) 注册监视器
mouseDragged(MouseEvent e) 处理拖动鼠标触发的事件
mouseMoved(MouseEvent e) 处理鼠标移动触发的事件
(6) Fokusereignisse
Komponenten können Fokusereignisse auslösen. Die Komponente kann zur addFocusListener(FocusListener listener)Registrierung als Fokusereignismonitor verwendet werden. Nachdem die Komponente den Fokusmonitor erhalten hat, wird das FocusEvent-Ereignis ausgelöst, wenn sich der Eingabefokus der Komponente ändert. Die Klasse, die den Monitor erstellt, muss die FocusListener-Schnittstelle implementieren, die zwei Methoden hat:
public void focusGained(FocusEvent e) 组件从无输入焦点变为有输入焦点时，监视器调用该方法
public void focusLost(FocusEvent e) 组件从有输入焦点变为无输入焦点时，监视器调用该方法
Der Benutzer klickt auf eine Komponente, um den Fokus zu erhalten, während andere Komponenten ebenfalls den Fokus verlieren . Eine Komponente kann eine public boolean requestFocusInWindow()Methode aufrufen , um den Eingabefokus zu erhalten
(7) Tastaturereignisse
Drücken Sie eine Taste auf der Tastatur, lassen Sie sie los oder drücken Sie sie, um ein Tastaturereignis auszulösen. Verwenden Sie die KeyListener-Oberfläche, um Tastaturereignisse zu verarbeiten. Sie können addKeyListener (KeyListener e) verwenden, um den Monitor zu registrieren. Die Schnittstelle verfügt über die folgenden drei Methoden:
public void keyPressed(KeyEvent e) 处理按下键盘触发的键盘事件
public void keyTyped(KeyEvent e) 处理敲击（按下又释放）触发的事件
public void keyReleased(KeyEvent e) 处理释放键盘触发的键盘事件
Verwenden Sie die Methode public int getKeyCode () [Schlüsselschlüsselwert zurückgeben] oder public char getKeyChar () [Zeichen auf dem Schlüssel zurückgeben] der KeyEvent-Klasse, um zu bestimmen, welche Taste gedrückt, getippt und losgelassen wird
(8) Fensterereignis
JFrame ist eine Unterklasse von Window, und alle Objekte, die von der FanshiWindow-Unterklasse erstellt wurden, können Fensterereignisereignisse haben.
WindowListener-Schnittstelle : Wenn ein Fenster geöffnet, geschlossen, symbolisiert ... wird ein Fensterereignis ausgelöst, dh WindowEvent erstellt ein Fensterereignisobjekt. Rufen Sie die Methode getWindow () auf, um das Fenster abzurufen, in dem das Fensterereignis aufgetreten ist. Das Fenster verwendet die addWindowlistener-Methode, um den Monitor abzurufen. Die Klasse des Objekts, das den Monitor erstellt, muss die WindowListener-Schnittstelle implementieren, die über 7 Methoden verfügt:
public void windowActivated(WindowEvent e) 窗口从激活到未激活状态调用该方法。
public void windowDeactivated(WindowEvent e)窗口从激活状态到未激活状态调用该方法。
public void windowClosing(WindowEvent e) 当窗口正在关闭时，调用该方法。
public void windowClosed(WindowEvent e) 当窗口关闭后，调用该方法。
public void windowIconified(WindowEvent e) 当窗口图标化后，调用该方法。
public void windowDeiconified(WindowEvent e) 当窗口撤销图标化后，调用该方法。
public void windowOpened(WindowEvent e) 当窗口打开时，调用该方法。
在调用图标化时，会同时调用撤销激活方法；在撤销图标化时，会同时调用激活方法。关闭窗口时，监视器首先调用正在关闭方法再调用关闭后方法。
WindowAdapter-Adapter : Wenn Java mehr als eine Methode zur Behandlung von Ereignissen bereitstellt, stellt Java eine entsprechende Adapterklasse bereit. Der Adapter hat die entsprechende Schnittstelle implementiert, sodass Sie das von der Unterklasse der Adapterklasse erstellte Objekt direkt als Monitor verwenden und die erforderliche Methode in der Unterklasse überschreiben können.
(9) Eine anonyme Klasseninstanz oder ein Fenster wird als Monitor verwendet.
Eine anonyme Klasseninstanz wird als Monitor verwendet : Wenn eine Instanz einer internen Klasse als Monitor verwendet wird, ist es für den Monitor einfacher, die Mitglieder zu bedienen, wenn ein Ereignis eintritt der externen eingebetteten Klasse, in der sich die Ereignisquelle befindet. Es ist nicht erforderlich, die Referenz des Objekts an den Monitor zu übergeben.
Fenster als Monitor : Wenn das Fenster, in dem sich die Komponente befindet, als Monitor verwendet wird, kann der Monitor bequem andere Mitglieder des Fensters bedienen.
Fünf, Dialogfeld
Die JDialog-Klasse und die JFrame-Klasse sind beide Unterklassen von Window, und die Instanzen von beiden sind der zugrunde liegende Container. Es gibt zwei Arten von Dialogfeldern: Modeless und Modal. Wenn ein modales Dialogfeld aktiviert ist, können andere Fenster des Programms, in denen sich das Dialogfeld befindet, nicht aktiviert werden. Es gibt keine solche Einschränkung, wenn es keinen Modus gibt. (Normalerweise wird vor dem Ausführen einer wichtigen Operation ein modales Dialogfeld angezeigt, um die Wichtigkeit der Operation anzuzeigen.)
(1) Meldungsdialogfeld
Dieses Dialogfeld ist ein modales Dialogfeld. Bevor Sie eine wichtige Operation ausführen, wird am besten ein angezeigt Rahmen des Nachrichtendialogfelds. Verwenden Sie die statische Methode der JOptionPane-Klasse, um ein Nachrichtendialogfeld zu erstellen: Der public static void showMessageDialog (Component parentComponent,String message,String title,int messageType)
erste Parameter gibt die Position des Dialogfelds an, wenn es sichtbar ist, der zweite Parameter gibt die im Dialogfeld angezeigten Informationen an, der dritte Parameter gibt den Titel an und der vierte Parameter Nimmt den Wert der JOptionPane-Klassenkonstanten in der Klasse an, mit denen das Dialogfeld angezeigt wird:INFORMATION_MESSAGE、WARNING_MESSAGE、ERROR_MESSAGE、QUESTION_MESSAGE、PLAIN_MESSAGE
(2) Eingabedialogfeld
Dieses Dialogfeld enthält ein Textfeld, in das der Benutzer Text eingeben, Schaltflächen bestätigen und abbrechen kann, und ist ein modales Dialogfeld. Eine Zeichenfolge ist erforderlich. Verwenden Sie die statische Methode der JOptionPane-Klasse, um einen Eingabedialog zu erstellen: Der public static String showInputDialog(Component parentComponent,Object message,String title,int message)
erste Parameter gibt die Komponente an, von der der Eingabedialog abhängt, die vierte Komponente gibt das Erscheinungsbild an und die konstanten Werte sind dieselben wie oben.
(3) Bestätigungsdialogfeld
Dieses Dialogfeld ist ein modales Dialogfeld. Die statische Methode der JOptionPane-Klasse erstellt ein Bestätigungsdialogfeld: Der public static int showConfirmDialog(Component parentComponent,Object message,String title,int optionType)
erste Parameter gibt die Position an, an der das Dialogfeld angezeigt wird, und der vierte Parameter kann die Klassenkonstante übernehmen Geben Sie das Erscheinungsbild an: YES_NO_OPTION、YES_NO_CANCEL_OPTION、OK_CANCEL_OPTION
Diese Methode gibt einen der folgenden ganzzahligen Werte zurück:JOptionPane.YES_OPTION、JOptionPane.NO_OPTION、JOptionPane.CANCEL_OPTION、JOptionPane.OK_OPTION、JOptionPane.CLOSED_OPTION
(4)
Die statische Methode des Farbdialogfelds Die JOptionPane-Klasse erstellt ein Farbdialogfeld: Der public static Color showDialog(Component component,String title,Color initialColor)
dritte Parameter gibt die vom Farbdialogfeld zurückgegebene Anfangsfarbe an
(5) Benutzerdefiniertes Dialogfeld
. Erstellen Sie eine Dialogfeldklasse, indem Sie eine Unterklasse von JDialog erstellen. Eine Instanz dieser Klasse ist ein Dialogfeld. Das Dialogfeld ist ein Container und das Standardlayout ist BorderLayout. Zwei gängige Konstruktionsmethoden für Dialogfelder:
JDialog() 构造一个无标题的初始不可见的对话框
JDialog(JFrame owner) 构造一个无标题的初始不可见的无模式的对话框，owner是对话框所依赖的窗口。
Sechs, Baumkomponenten und Tabellenkomponenten
(1) Baumkomponente: Das Objekt der JTree-Klasse wird als Baumkomponente bezeichnet.
DefaultMutableTreeNode-Knoten : Um eine Baumkomponente zu erstellen, müssen Sie zuvor ein Knotenobjekt dafür erstellen. Jedes Objekt, das von einer Klasse erstellt wird, die die MutableTreeNode-Schnittstelle implementiert, kann zu einem Knoten in der Baumstruktur werden. Es gibt nur einen Wurzelknoten im Baum, und alle anderen Knoten führen von hier aus. Andere Knoten sind in Verzweigungsknoten mit untergeordneten Knoten und Blattknoten ohne untergeordnete Knoten unterteilt. Jeder Knoten verfügt über eine eigene Textbezeichnung und ein eigenes Bildsymbol. Die Default MutableTreeNode-Klasse erstellt Knoten im Baum. Die häufig verwendeten Konstruktionsmethoden für diese Klasse sind:
DefaultMutableTreeNode(Object userObject)
DefaultMutableTreeNode(Object userObject,boolean allowChildren)
TreeSelectionEvent-Ereignis im Baum: Die Baumkomponente kann das TreeSelectionEvent-Ereignis auslösen, und die Baumverwendungsmethode addTreeSelectionListener(TreeSelectionListener listener)erhält einen Monitor. Wenn die Maus auf den Knoten klickt, ruft der Monitor die Methode automatisch in der Schnittstelle auf
(2) Tabellenkomponenten:
Drei häufig verwendete Konstruktionsmethoden für JTable:
JTable() 创建默认的表格模型
JTable(int a,int b) 创建a行，b列的默认模型表格
JTable(Object data[][],Object columnName[]) 创建默认表格模型，并且显示由data指定的二维数组的值，其列名由columnName指定