Swing
EDV2 - 04 - Swing
1
Swing - AWT
EDV2 - 04 - Swing
AWT passt sein L&F der Umgebung automatisch an. Swing kann sein
L&F selbst verändern, auch zur Laufzeit dynamisch.
Swing ist ausschließlich in Java programmiert. AWT enthält viele native
Komponenten. Dadurch kann AWT nur den gemeinsamen Durchschnitt
aller Window-Oberflächen nutzen.
Swing-Komponenten können viel vielfältiger gestaltet werden. Icons auf
Buttons, Buttons können verschieden geformt werden, Rahmen können
gestaltet werden u.s.w.HTML-Text kann verwendet werden.
AWT-Frames sind zunächst leer. Swing-JFrames haben schon eine
Struktur.
2
Applikationen - Applets
EDV2 - 04 - Swing
Applets müssen immer von der Klasse JApplet abgeleitet werden.
Applets müssen den Konstruktor ohne Parameter enthalten.  Man
programmiert entweder keinen Konstruktor oder zusätzlich den ohne
Parameter.
Applets werden mit der Methode init() initialisiert.
Applets und Swing-Applikationen haben ContentPane und MenuBar
gemeinsam. Für Programme, die sowohl als Applikation als auch als
Applet genutzt werden sollen, bietet es sich also an, eine
ContentPane und einen MenuBar zu generieren und diesen den
entsprechenden Componenten zuzuweisen.
Init() enthält dann die Operationen, die nur für Applets sinnvoll sind
und main die, die nur für Applikationen sinnvoll sind.
Manchmal ist es sinnvoll sich globale flags zu definieren, sodass
später leicht entschieden werden kann, ob das Programm als Applet
oder als Applikation läuft. Die flags müssen im Konstruktor gesetzt
werden. Das Applet benötigt jedoch einen parameterlosen
Konstruktor, der dann auch geschrieben werden muss.
3
Lebensweg eines Applets
unbekannt
init()
initialisiert
start()
EDV2 - 04 - Swing
laufend
start()
stop()
gestoppt
destroy()
4
zerstört
Gerüst für Applikation/Applet
EDV2 - 04 - Swing
5
public class TestAppletApplication extends JApplet
{
private boolean isApplet=false;
private boolean isApplication=false;
public TestAppletApplication(boolean isApplication)
{
this.isApplication= isApplication;
this.isApplet= !isApplication;
}
public TestAppletApplication()
{
this(false);
}
public void init()
{
isApplet=true;
isApplication=false;
setContentPane(makeContentPane());
setJMenuBar(makeJMenuBar());
}
EDV2 - 04 - Swing
private Container makeContentPane()
{
JPanel pane = new JPanel();
...
return pane;
}
private JMenuBar makeJMenuBar()
{
JMenuBar menu = new JMenuBar();
...
return menu;
}
6
public static void main(String [] args)
{
JFrame frame = new JFrame();
TestAppletApplication t = new TestAppletApplication(true);
frame.setContentPane(t.makeContentPane());
frame.setJMenuBar(t.makeJMenuBar());
frame.pack();
EDV2 - 04 - Swing
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
7
Einfache Swing-Komponenten
Die „einfachen“ Swing-Komponenten entsprechen den AWTKomponenten. Sie haben allerdings eine größere Vielfalt an
Möglichkeiten. Das trifft z.B. zu auf:
JButton, JMenuItem, JCheckBox, JRadioButton,
JLabel, JList, JMenuBar, JScrollBar, JSlider
Dabei sind aber wesentlich mehr Gestaltungsmöglichkeiten
vorhanden.
EDV2 - 04 - Swing
8
JTabbedPane
EDV2 - 04 - Swing
JTabbedPane ermöglicht es, in einem Fenster mehrere Ebenen
darzustellen.
Die verschiedenen Ebenen können durch „Reiter“ (Tabs) ausgewählt
werden.
Zum Hinzufügen einer Ebene dienen die Methoden
public void addTab(String title,
Component component)
public void addTab(String title, Icon icon,
Component component)
public void addTab(String title, Icon icon,
Component component, String tip)
title : Name der Ebene
component : hinzuzufügende Komponente
icon : anzuzeigendes Icon
tip : ToolTip Text für diese Ebene
9
TestJTabbedPane
EDV2 - 04 - Swing
10
private Container makeContentPane()
{
JTabbedPane pane = new JTabbedPane();
JPanel tab1 = new JPanel();
JPanel tab2 = new JPanel();
JPanel tab3 = new JPanel();
JPanel tab4 = new JPanel();
tab1.add(new JLabel("Table"));
tab2.add(new JLabel("FileChooser"));
tab3.add(new JLabel("ColorChooser"));
tab4.add(new JLabel("ProgressBar"));
pane.addTab("Table", null, tab1,
"ToolTip : Table");
pane.addTab("FileChooser", null, tab2,
"ToolTip : FileChooser");
pane.addTab("ColorChooser", null, tab3,
"ToolTip : ColorChooser");
pane.addTab("ProgressBar", null, tab4,
"ToolTip : ProgressBar");
return pane;
}
Tabellen
EDV2 - 04 - Swing
Tabellen werden mit der Klasse JTable erzeugt.
JTable unterstützt den Aufbau von Tabellen mit beliebigen Inhalten.
Tabellenzellen können geändert werden oder für Änderungen
gesperrt sein.
Auf Änderungen von Zellen kann mit Listenern reagiert werden.
Um alle Funktionalitäten nutzen zu können muss man mit
TableModels arbeiten.
Für einfache Standardtabellen gibt es spezielle Konstruktoren.
public JTable(Object[][] rowData,
Object[] columnNames)
Mit diesem Konstruktor wird eine Tabelle erzeugt, die als
Überschriften die Feldelemente von columnNames hat und als
Feldinhalte die Feldelement von rowData.
Damit die Überschriften angezeigt werden und große Tabellen
dargestellt werden können bettet man die Tabelle am besten in ein
JScrollPane ein.
11
Mit der Methode
public void
setPreferredScrollableViewportSize(Dimension size)
der Klasse JTable wird die Anfangsgröße der Tabelle festgelegt.
EDV2 - 04 - Swing
12
Standardmäßig werden alle Spalten gleich breit angezeigt. Mit der
Methode
public void setPreferredWidth(int preferredWidth)
der Klasse TableColumn kann die Standardbreite einer Spalte
festgelegt werden. Wenn später die Breite der Tabelle verändert wird,
werden die Relationen der Spaltenbreiten beibehalten. Die Methode
kann folgendermaßen aufgerufen werden:
table.getColumnModel().getColumn(i).
setPreferredWidth(breite)
Einfache Tabelle
private Component makeSimpleJTable()
{
Object[][] data = {
{"Mary", "Campione", "Snowboarding", new Integer(5), new Boolean(false)},
{"Alison", "Huml", "Rowing", new Integer(3), new Boolean(true)},
{"Kathy", "Walrath", "Chasing toddlers", new Integer(2), new Boolean(false)},
{"Mark", "Andrews", "Speed reading", new Integer(20), new Boolean(true)},
{"Angela", "Lih", "Teaching high school", new Integer(4), new Boolean(false)}
};
String[] columnNames =
{"First Name","Last Name","Sport","# of Years", "Vegetarian"};
EDV2 - 04 - Swing
JTable table = new JTable(data, columnNames);
table.setPreferredScrollableViewportSize(
new Dimension(500, 70));
TableColumnModel columnModel = table.getColumnModel();
for (int i = 0; i < table.getColumnCount(); i++)
{
if(i==2)columnModel.getColumn(i).setPreferredWidth(100);
else columnModel.getColumn(i).setPreferredWidth(50);
}
return new JScrollPane(table);
}
13
TableModels
Um kompliziertere Tabellen zu erzeugen benötigt man TableModels.
Am einfachsten leitet man ein TableModel von der abstrakten Klasse
AbstractTableModel ab. Es müssen unbedingt folgende
Methoden implementiert werden:
public int getRowCount()
public int getColumnCount()
public Object getValueAt(int row, int column)
EDV2 - 04 - Swing
Weitere wichtige Methoden die implementiert werden können sind:
public String getColumnName(int column)
public Class getColumnClass(int c)
public boolean isCellEditable(int row, int col)
public void setValueAt(Object value, int row, int
col)
Mit Hilfe verschiedener fireXXX-Methoden können Listener
benachrichtigt werden. Besonders wichtig ist die Methode:
public void fireTableCellUpdated(int row,
int column)
14
Beispiel JTable1
EDV2 - 04 - Swing
15
private Component makeJTable1()
{
final Object[][] data = {...};
final String[] columnNames = {...};
AbstractTableModel tableModel = new AbstractTableModel()
{
public int getRowCount() { return data.length; }
public int getColumnCount() { return data[0].length; }
public Object getValueAt(int row, int column)
{ return data[row][column]; }
public String getColumnName(int column)
{ return columnNames[column]; }
public Class getColumnClass(int c)
{ return getValueAt(0, c).getClass(); }
public boolean isCellEditable(int row, int col)
{ return true; }
public void setValueAt(Object value, int row, int col)
{
data[row][col] = value;
fireTableCellUpdated(row, col);
}
};
EDV2 - 04 - Swing
16
JTable table = new JTable(tableModel);
table.setPreferredScrollableViewportSize(
new Dimension(500, 70));
TableColumnModel columnModel = table.getColumnModel();
for (int i = 0; i < table.getColumnCount(); i++)
{
if (i == 2)
columnModel.getColumn(i).setPreferredWidth(100);
else columnModel.getColumn(i).setPreferredWidth(50);
}
return new JScrollPane(table);
}
Zellrenderer
EDV2 - 04 - Swing
17
Jede Zelle wird bei der Darstellung durch einen Zellrenderer
bearbeitet. Welcher Zellrenderer verwendet wird hängt vom Typ, d.h.
von der Klasse des Objektes ab. Diese wird mit der Methode
getColumnClass abgefragt. Zellen in einer Spalte werden also immer
gleich gerendert. Folgende Standardrenderer sind im System
enthalten:
Boolean : als CheckBox
Number : als rechtsbündiges Label
ImageIcon : als zentriertes Bild
Andere Objekte : als linksbündige Zeichenkette des Objektes
Eigene Renderer können hinzugefügt werden.
public void setDefaultRenderer(Class columnClass,
TableCellRenderer renderer)
columnClass : Klasse für die Renderer zuständig ist
renderer : Renderer, der für diese Klasse verwendet werden soll
public void
setCellRenderer(TableCellRenderer cellRenderer)
um den Renderer eines TableColumn-Objektes zu setzen
Zelleditoren
EDV2 - 04 - Swing
18
Zelleditoren werden ähnlich wie die Renderer angewendet. Sie
dienen der Eingabe eines Wertes in einer Zelle.
Sie können ebenfall Spalten- oder Klassenabhängig definiert
werden.
Für spezielle Zelleditoren gibt es die Klasse DefaultCellEditor mit
den Konstruktoren:
public DefaultCellEditor(JTextField textField)
public DefaultCellEditor(JCheckBox checkBox)
public DefaultCellEditor(JComboBox comboBox)
Beispiel JTableEditor
JComboBox comboBox = new JComboBox();
comboBox.addItem("Snowboarding");
comboBox.addItem("Rowing");
comboBox.addItem("Chasing toddlers");
comboBox.addItem("Speed reading");
comboBox.addItem("Teaching high school");
comboBox.addItem("None");
table.getColumnModel().getColumn(2).
setCellEditor(new DefaultCellEditor(comboBox));
EDV2 - 04 - Swing
19

Swing - WIAS