1. Inhalt

2. Dialogarten. 2

2.1. JFrame Form.. 2

2.2. JInternalFrame Form.. 2

3. Einzelkomponenten. 5

3.1. JButton. 5

3.2. JRadioButton. 6

3.2.1. Vorauswahl einer Option. 7

3.3. JCheckBox. 7

3.4. JComboBox. 8

3.5. JSlider. 9

3.6. JTabbedPane. 10

3.7. JTable. 12

3.7.1. DefaultTableModel 13

3.7.2. AbstractTableModel 14

3.7.3. TableCellRenderer. 16

3.8. JList. 18

3.9. JDateChooser. 19

3.9.1. JDateChooser einbinden. 19

3.9.2. JDateChooser verwenden. 22

4. Programmiertechniken. 22

4.1. Rückfragen und Hinweise an den User. 22

4.2. PopUp Steuerung mit Werteübergabe an das aufrufende Fenster. 23

4.2.1. Fenster 1. 23

4.2.2. Fenster 2. 23

4.2.3. Ausführen. 24

4.3. Tastaturereignisse abfangen. 25

 

2. Dialogarten

Ein Programm kann als eigenständiges Programm JFrame Form gestartet werden, oder als JInternalFrame Form. In der 2. Variante läuft es als Fenster in einem anderen Programm ab.

2.1. JFrame Form

Das JFrame Form ist die einfache Variante eines Programms. Es wird wie folgt erzeugt.

Das JFrame Form hat eine eigene Main Methode und kann somit eigenständig gestartet werden. Immer darauf achten, dass die defaultCloseOperation richtig angegeben ist, da das Fenster sonst nicht mehr geschlossen werden kann.

2.2. JInternalFrame Form

Zuerst legen wir uns wieder ein JFrame Form an, das sozusagen unser Rahmenprogramm wird in dem die JInternalFrames gestartet werden.

Jetzt fügen wir eine JMenueBar hinzu. Direkt darunter eine Toolbar. Auf dieser können Buttons angeordnet werden. Diese können Text oder Icons tragen. Die JMenueBar lässt sich erweitern mit einem JMenue bzw. einem JMenueItem. Die JMenueBar lässt sich auch als untere Statuszeile einsetzen.

In den darunter liegenden freien Raum setzen wir eine JDesktopPane. Das ist dann der Bereich in dem die JInternalFrame angezeigt werden.

Nun erstellen wir in einer neuen Klasse ein JInternalFrame, das auf der JDesktopPane des Rahmenprogramms angezeigt werden soll.

Wir fügen ein Label hinzu, damit wir das Fenster in der Teststellung wieder identifizieren können.

Zurück im MainFrame erstellen wir das Event welches das interne Fenster startet,

und hinterlegen den folgenden Code:

Bei Bedarf kann über setLocation(xPos,yPos) eine Position für das InternalFrame festgelegt werden.

So weit, so gut:

Wir müssen das Fenster jetzt noch schließbar machen. Dies geschieht im Konstruktor des JInternalFrame nach der Initialisierung der Komponenten. Jeder der 3 Buttons zur Fenstersteuerung kann extra angeschaltet werden.

Jetzt passen wir noch das Aussehen an den Windows Client an. Das geschieht in der Main-Methode des Hauptprogramms.

Jetzt noch die Hintergrundfarbe des jDesktopPane anpassen. Fertig!

3. Einzelkomponenten

3.1. JButton

Zuerst ein JFrame Form anlegen. Darauf dann 2 Buttons und ein Label setzen.

Nun einen Namen für die Buttons und das Label vergeben.

Für beide Buttons das actionPerformed Event hinzufügen.

Dadurch wird automatisch eine entsprechende Methode im Quelltext erstellt, die dann mit Kommandos gefüllt werden kann.

3.2. JRadioButton

Zuerst ein neues JFrame erzeugen und 3 RadioButtons anlegen. Ebenso einen JButton „Bestellen“, ein Label und eine ButtonGroup. Diese muss einfach nur auf das JFrame gezogen werden und taucht in der Anzeige nicht auf, da es nur ein logisches und kein grafisches Element ist.

Nun alle JRadioButtons markieren und mit der RMB die Eigenschaften aufrufen. Jetzt kann allen markierten Elementen in einem Rutsch die neue ButtonGroup zugeordnet werden. Dadurch kann immer nur ein Button innerhalb der Gruppe aktiv sein.

Wir fügen nun unserem „Bestellen“ JButton wieder das ActionPerformed Event hinzu und programmieren den folgenden Quelltext.

3.2.1. Vorauswahl einer Option

3.3. JCheckBox

Wir fügen unserem JFrame noch 2 Checkboxen hinzu.

Da diese für sich allein funktionieren, müssen Sie nicht gruppiert werden. Allerdings können Sie wieder Default belegt werden.

Nun noch der dazugehörige Quelltext.

Zeilenumbrüche in einem Label werden durch HTML erreicht.

3.4. JComboBox

Wir erstellen uns eine JComboBox.

Soll diese über die grafische Oberfläche von Netbeans gefüllt werden, so geschieht das hier:

Hier löst die JComboBox ein Ereignis aus.

Steuerung im Programmcode

3.5. JSlider

Zuerst erstellen wir uns wieder ein JFrame Form.

Nach der Vergabe von passenden Namen können für den JSlider diverse Werte angepasst werden.

Minimum und Maximum stehen dabei für den Wertebereich, den der Slider verwalten soll. paintTicks sagt aus ob der JSlider mit Strichen zur Orientierung versehen werden soll und mayorTickSpacing gibt die Schrittweite an. snapToTicks sagt aus ob der JSlider auf den Ticks einrasten soll und value ist der Wert mit dem der JSlider gestartet werden soll.

Jetzt fügen wir das Event stateChange hinzu

und ergänzen die Methode entsprechend.

Im Ergebnis ändert sich der Wert jedes Mal wenn der JSlider bewegt wird.

3.6. JTabbedPane

Zuerst fügen wir ein JTabbedPane einem JFrame Form hinzu.

Um Reiter zu bekommen ziehen wir ein normales Panel an die Stelle an der der Reiter erscheinen soll.

Um die Beschriftung zu ändern klickt man mit RMB auf den Reiter.

Die Reihenfolge der Reiter kann man über den RMB ändern.

 

3.7. JTable

Zuerst erstellen wir uns ein JFrame Form und ziehen einen JTable darauf.

Jetzt muss der JTable noch bearbeitet werden.

Hierzu wählen wir den Eintrag „Table Contents..“ und editieren in dem Reiter Colums die Spaltenanzahl, den jeweiligen Titel und ob die Spalte editierbar sein soll. Ebenso kann hier die default Breite eingestellt werden.

Im Reiter Row löschen wir alle per Default vergebenen Zeilen raus.

Wir erweitern das JFrame um die folgenden Elemente.

3.7.1. DefaultTableModel

Nun brauchen wir noch das Model, das die Daten für unseren JTable verwaltet. Da wir keine selbst berechneten Spalten haben, können wir uns das DefaultTableModel unseres JTable holen. Dieses kann erst nach dem Aufruf von initComponents() geladen werden.

3.7.1.1. Daten hinzufügen

Um Daten in die Tabelle hinzuzufügen, befüllen wir das ActionPerformed Event des Button „Hinzufügen“ .

3.7.1.2. Werte aus einer Zelle holen und Daten löschen

Um Daten zu löschen, befüllen wir entsprechend das ActionPerformed Event des Buttons „Löschen“.

3.7.1.3. Alle Datensätze aus Model entfernen

3.7.2. AbstractTableModel

Soll ein komplexeres Datenmodell verwendet werden, das also beispielsweise eine selbst berechnende Logik für die Inhalte verwendet, so muss das AbstractTableModel verwendet werden.

Wir erzeugen uns eine neue Klasse mit dem Namen SquareTableModelSimple das von AbstractTableModel erbt. Damit haben wir ein entsprechendes Datenmodel. Die 3 Methoden getRowCount(), getColumnCount() und getValueAt() müssen implementiert werden, da AbstractTableModel das Interface TableModel einbindet und die Methoden dort abstract sind. Man kann sich Ärger sparen wenn die Methode getValueAt() nur Strings zurück gibt. Ansonsten gibt es Probleme wenn wie in der Vorlage die Daten wieder Rausgeholt und auf einen String gekarstet werden sollen.

Wie man sieht, so bietet das Datenmodell viele weitere Methoden an. Wir setzten das mit einem Minimum an zu überschreibenden Methoden um.

Jetzt muss das JTable noch mit dem neuen Model verbunden werden. Hierzu kann man es direkt im Konstruktor an das JTable übergeben. Da der entsprechende Bereich im Quellcode zum Bearbeiten gesperrt ist, muss man den Weg über die Eigenschaften (1) des JTables gehen und das Model bearbeiten. Hierzu stellt man auf Custom Code(2) um und erstellt ein neues SquareTableModelSimple() (3).

Oder man ändert das Model für den JTable nachträglich ab.

Ergebnis:

3.7.3. TableCellRenderer

Um das Aussehen der einzelnen Zellen zu ändern muss ein TableCellRenderer hinzugefügt werden. Dieser enthält die Logik welche Zelle welche Formatierung bekommen soll.

Eingebunden wird dieser entweder nach der Initialisierung der Komponenten im Konstruktor des JFrame als Default, oder wie später gezeigt für jede Spalte einzeln.

Object.class steht dabei für den Zellentyp der von der Formatierung betroffen ist. Genauso wäre Long.class oder ähnliches möglich. Die neu erstellte Klasse MyRenderer ist vom Interface TableCellRenderer abgeleitet. Dieses schreibt lediglich die Methode getTableCellRendererComponent(..) vor. In dieser wird gemäß der hinterlegten Logik ein Label mit den entsprechenden Einstellungen erzeugt.

Nun muss der CellRenderer noch mit den einzelnen Spalten verbunden werden. Dies ist natürlich nur dann erforderlich wenn er nicht schon Default zum Table hinzugefügt wurde. Hierzu für jede Spalte die Property Render konfigurieren.

Ergebnis:

3.8. JList

Wir erstellen uns ein JFrame Form mit einer JList. Der Text aus der Textbox soll in die Liste eingetragen werden, sobald man auf „Hinzufügen“ klickt. Klickt man auf „Löschen“, so wird der markierte Eintrag aus der Liste wieder entfernt.

Wir fügen nun ein Model hinzu das die Daten für unsere Liste aufnimmt.

Jetzt teilen wir unserer Liste mit auf welches Model sie hören soll.

Und dann noch der Programmcode für unsere 2 Buttons.

3.9. JDateChooser

Der JDateChooser ist eine zusätzliche JavaBean die erst eingebunden werden muss.

3.9.1. JDateChooser einbinden

RMB auf die Palette

JAR File hinzufügen

Komponente auswählen.

Ordner auswählen in dem die Komponente auftauchen soll.

Schon ist er verfügbar.

3.9.2. JDateChooser verwenden

Wir fügen den JDateChooser einem JFrame hinzu.

Hier der Programmcode um den JDateChooser aus dem Quelltext heraus anzusprechen.

4. Programmiertechniken

4.1. Rückfragen und Hinweise an den User.

Zur Demonstration hier der Quelltext für 2 Buttons.

Je nach Belegung von „int antwort“ kann man im Programm feststellen auf welchen Button Button gedrückt wurde.

Bei einem Hinweis gibt es keinen Rückgabewert.

4.2. PopUp Steuerung mit Werteübergabe an das aufrufende Fenster.

4.2.1. Fenster 1

Wir erstellen uns einen Dialog der einen Button, und ein Label trägt.

In den Button programmieren wir die folgende Funktionalität.

 

4.2.2. Fenster 2

Wir erstellen ein Fenster mit einem Textfeld und einem Button.

Das Fenster muss von JDialog erben. Außerdem erstellen wir noch eine Variable zum Speichern des Textfeldes.

Die defaultCloseOpperation des Frames stellen wir auf Dispose, da wir sonst nach dem Beenden nicht mehr auf den Wert zugreifen können.

Nun fügen wir noch einen 2. Konstruktor hinzu.

Eine Methode über die wir unseren Wert holen wollen,

und die Ausprogrammierung des Buttons.

4.2.3. Ausführen

Starten wir nun DlgPopUp, können wir direkt den 2. Dialog starten.

Geben wir nun etwas in das Textfeld ein und klicken auf Beenden, so wird der Wert direkt vom 1. Fenster über die Methode getInfo() geholt, die wir in das 2. Fenster programmiert haben.

4.3. Tastaturereignisse abfangen

Wir erstellen ein JFrame das nur ein Textfeld hat. An dieses hängen wir das Ereignis keyPressed.

Nun das Ereignis noch abfangen und was damit machen.