Spezialkomponenten in Swing

Eine Komponente, beispielsweise eine Platte, kann auch dadurch erzeugt werden, daß eine Swing -Komponentenklasse erweitert  wird. In der Erweiterung können dann Methoden wie gewünscht überschrieben werden. So entsteht eine Spezialkomponente (custom component ).

In dem Programm "CustomPanel.java" wird eine Komponente "ButtonPanel" durch Erweitung der Klasse "javax.swing.JPanel" erzeugt. Die Klasse unterstützt damit alle Operationen der Klasse "javax.swing.JPanel". Der parameterlose Konstruktor "ButtonPanel()" wird so deklariert, daß er eine Tastfläche zu der Platte hinzuzufügt. Damit ist eine Tastflächenplatte "ButtonPanel" also eine Platte mit einer Tastfläche. In der Hauptmethode "main" wird dann eine solche Tastflächenplatte zu dem Fenster "frame" hinzugefügt.

CustomPanel.java

public class CustomPanel  
{ public static void main( String[] args ) 
  { javax.swing.JFrame.setDefaultLookAndFeelDecorated( true ); 
    javax.swing.JFrame frame = new javax.swing.JFrame( "CustomPanel" ); 
    ButtonPanel panel = new ButtonPanel(); frame.getContentPane().add( panel ); 
    frame.setDefaultCloseOperation( javax.swing.JFrame.EXIT_ON_CLOSE ); 
    frame.pack(); frame.setVisible( true ); }}

class ButtonPanel extends javax.swing.JPanel  
{ ButtonPanel() 
  { final javax.swing.JButton button = new javax.swing.JButton( "JButton" ); 
    this.add( button ); }}

Fenster

.-----------. 
| O   o O X | 
|.---------.| 
|| JButton || 
|'---------'| 
'-----------'

Erweiterung eines Fensters

Durch Erweiterung der Klasse "javax.swing.JFrame" kann ein Spezialfenster (custom frame ) erzeugt werden. Das wird häufig gemacht, um ein Fenster mit speziellen Eigenschaften zu konstruieren. Bei diesem Abschnitt wird aber ein bewußt einfaches Beispiel verwendet, in dem noch keine zusätzlichen Eigenschaften zu dem Fenster hinzugefügt werden.

Da Konstruktoren nicht vererbt werden, wird eine Konstruktordeklaration benötigt. Hier wird eine Konstruktor deklariert, der eine Kette akzeptiert und an den Konstruktor der Oberklasse weiterleitet, um damit bei der Exemplarerzeugung den Fenstertitel festsetzen zu können.

Das erzeugte Fenster ist möglicherweise zunächst recht klein, da die Erweiterung "JFrame1" keine größere Wunschgröße festgelegt hat. Die Festlegung solch einer Wunschgröße bedarf einiger Erklärungen und wird deswegen noch nicht in dieser Lektion behandelt. Das Fenster kann aber vom Bediener des Prozesses vergrößert werden, um besichtigt zu werden.

CustomFrame.java

public class CustomFrame  
{ public static void main( String[] args ) 
  { JFrame1.setDefaultLookAndFeelDecorated( true ); 
    JFrame1 frame = new JFrame1( "Custom Frame" ); 
    frame.setDefaultCloseOperation( javax.swing.JFrame.EXIT_ON_CLOSE ); 
    frame.pack(); frame.setVisible( true ); }}

class JFrame1 extends javax.swing.JFrame 
{ JFrame1( final String s ){ super( s ); }}

Fenster

.-. 
|O| 
'-'

Einbau einer statische Hauptmethode

Die statische Hauptmethode "main" kann auch in einer Klasse einer Spezialkomponente definiert werden, wenn sie eng mit dieser Spezialkomponente verbunden ist. Dabei wird in der statischen Methode "main" nun ein Exemplar der Klasse erzeugt, in der diese statische Methode enthalten ist. Eine statische Methode kann ja ausgeführt werden, ohne daß ein Exemplar ihrer Klasse existieren muß. Die Exemplarerzeugung "new JFrame1( "JFrame1" )" übergibt die Kontrolle dann an den Konstruktor "JFrame1", die wiederum den Kontruktor der Überklasse "javax.swing.JFrame" aktiviert, wodurch dann schließlich ein Fenster erzeugt wird.

JFrame1.java

class JFrame1 extends javax.swing.JFrame 
{ JFrame1( final String s ){ super( s ); }    // Konstruktor

  public static void main( String[] args ) 
  { JFrame1.setDefaultLookAndFeelDecorated( true ); 
    JFrame1 frame = new JFrame1( "JFrame1" ); // Kontrolle geht an Konstruktor 
    frame.setDefaultCloseOperation( javax.swing.JFrame.EXIT_ON_CLOSE ); 
    frame.pack(); frame.setVisible( true ); }}

Fenster

.-. 
|O| 
'-'

Kontrollfluß bei Ausführung von "java JFrame1"

.--------------------------------.
| Java-Maschine                  |
'--------------------------------'
                |
                V
.--------------------------------.
| JFrame1.main                   |
'--------------------------------'
                |
                V
.--------------------------------.
| JFrame1-Konstruktor            |
'--------------------------------'
                |
                V
.--------------------------------.
| javax.swing.JFrame-Konstruktor |
'--------------------------------'

Man kann sich vorstellen, daß man mit einer Klassendeklaration in Java  eigentlich zwei  Klassen spezifiziert: Eine „statische Klasse“ mit allen statischen Feldern und Methoden und eine „dynamische Klasse“ für Exemplare mit den nicht-statischen Feldern und Methoden. Diese beiden „Klassen“ sind durch gemeinsame Zugriffsrechte verbunden. Die statische Methode "main" gehört zu der „statischen Klasse“ "JFrame1", die dann ein Exemplar der „dynamischen Klasse“ "JFrame1" erzeugt. In dem vorherigen Abschnitt wurden dafür noch zwei getrennte Klassendeklarationen verwendet. Hier sieht man nun, daß beide „Klassen“ auch mit einer Klassendeklaration geschrieben werden können.