Byte-Welt Wiki - Benutzerbeiträge [de]

JTable (Tutorial)©

2016-02-06T11:25:21Z

Beni:

© August 2004
Dieses Tutorial unterliegt dem Copyright, Kopien (auch nur von Teilen) sind nur für nicht-komerzielle Zwecke gestattet; Detailfragen (insbesondere bei Unsicherheiten), bitte direkt an die Autoren.

==Einführung==
Von allen Components in ganz AWT und Swing, ist das [[JTable_(Java_API)|JTable]] wohl die komplexeste überhaupt (allenfalls kann der [http://wiki.byte-welt.net/wiki/JTree_(Tutorial)© JTree] noch mithalten).

Ziel ist es, dem Leser einen Überblick zu verschaffen, und ihn an die wichtigsten Konzepte heranzuführen. Dabei soll hier nur jedes Themengebiet für sich alleine betrachtet werden, die Kombination aller [[TableModel]]s, [[TableCellRenderer]], [[JTableHeader]]s, [[TableColumnModel]]s und [[TableCellEditor]]s können hier nicht behandelt werden, da wir schliesslich kein Buch schreiben wollen.

Dieses Tutorial ist eigentlich eine grosse Sammlung von Beispielen. Am meisten lernt man immer noch, wenn man selbst rumspielen darf, deshalb: kopiere alle Beispiele und führ sie aus. Verändere ein paar Werte, und schau was passiert. Versuch selbst was sinnvolles zu schreiben.

Dabei konnte nicht immer die beste Implementation gewählt werden, wiel dies das Konzept (von vorne beginnen) gründlich durcheinander gebracht hätte.

===1. Die JTable===
Sollte diese Component wirklich unbekannt sein, von dem hier sprechen wir:<br>
[[Bild:JTableTutorial1.png]]

===2. API===
Anlaufstelle Nr. 1 ist, wie so oft, die API {{JAPI|JTable}}. ''JTable'' findet man im Package ''javax.swing'', und eine ganze Reihe von hilfreichen Klassen und Interfaces im Unterpackage ''javax.swing.table''.

===3. Tutorials und anderes im WWW===
- Das [http://docs.oracle.com/javase/tutorial/uiswing/components/table.html How to use JTable] von Oracle bietet einen einfachen Überblick.
- [http://www.javaworld.com/javaworld/javatips/jw-javatip116.html#resources Javatip 116] bietet ebenfalls eine kleine Einführung.
- [http://www.javaworld.com/javaworld/javatips/jw-javatip102.html Javatip 102] beschäftigt sich mit dem CellEditor, insbesondere mit verschiedenen CellEditors in derselben Column.
- Ein weiteres Tutorial und eine thematische Sortierung von Methoden, etc... findet sich in dem Handout des Kurses [http://www.cs.cf.ac.uk/Dave/HCI/HCI_Handout_CALLER/node165.html Human Computer Interaction]
- Die [https://github.com/donpir/jdyntable/ jDynTable] ist eine Erweiterung der normalen JTable, und erlaubt auch verschmolzene Zellen (Zellen über mehrere Spalten).

===4. Scrolling===
Keine Tabelle wäre vollständig ohne Scrollbars und Titelleiste ({{JAPI|JTableHeader}}). Diese Funktionalität erhält man erst, wenn man die ''JTable'' mit einem {{JAPI|JScrollPane}} kombiniert. Das macht man am besten mit dem Konstruktor der ''JScrollPane'':

<code=java>
// Das JTable
JTable table = ...

// Der Container, dem das JTable hinzugefügt wird
Container content = ...

// Ein JScrollPane erstellen, und zwischen dem Table und dem Container einfügen.
content.add( new JScrollPane( table ));
</code=java>

Für diejenigen die einfache Lösungen nicht gerne haben, mit ''getTableHeader'' kommt man direkt an die Titelliste und kann sie irgendwohin schieben:
<code=java>
// dem Container das [[BorderLayout]] setzen
content.setLayout(new BorderLayout());

// den Header der JTable holen und ihn in den oberen Bereich des Containers setzen
content.add(table.getTableHeader(), BorderLayout.PAGE_START);

// das JTable in die Mitte des Containers setzen
content.add(table, BorderLayout.CENTER);
</code=java>

Man kann unendlich viele Dinge mit einer ''JTable'' tun, aber nicht Alles ist sinnvoll. Im letzten Beispiel hat der Benutzer keine möglichkeit die Tabelle umherzuschieben und verdeckte Zellen in den Sichtbarkeitsbereich zu scrollen.

==Wie kommen Daten in die Tabelle?==
'' JTable'' selbst hat nur die Aufgabe Daten hübsch darzustellen. Die Tabelle versteht weder woher die Daten kommen, noch was die Daten bedeuten. Wie also kommen die Daten in die Tabelle?

===1. Möglichkeit - 2d Array===
Die wohl einfachste Methode ist einen 2-dimensionalen Array zu benutzen.
Das JTable bietet einen entsprechenden Konstruktor:
<code=java>import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;

public class JTableDemo{
public static void main( String[] args ){
// Die Daten für das Table
String[][] data = new String[][]{
{"a", "b", "c", "d"},
{"e", "f", "g", "h"},
{"i", "j", "k", "l"}
};

// Die Column-Titles
String[] title = new String[]{
"A", "B", "C", "D"
};

// Das JTable initialisieren
JTable table = new JTable( data, title );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}
</code=java>

[[Bild:JTableTutorial2.png]]
Diese Methode ist sehr statisch, es ist später nicht mehr gut möglich, Daten zu ändern.

===2. Möglichkeit - Vectoren===
Mit ineinander gesetzten Vektoren:
<code=java>
import java.util.Vector;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;

public class JTableDemo{
public static void main( String[] args ){
// Die Daten für das Table
Vector data = new Vector();
Vector rowA = new Vector();
rowA.add( "1" );
rowA.add( "2" );
rowA.add( "3" );
rowA.add( "4" );
Vector rowB = new Vector();
rowB.add( "5" );
rowB.add( "6" );
rowB.add( "7" );
rowB.add( "8" );
Vector rowC = new Vector();
rowC.add( "9" );
rowC.add( "10" );
rowC.add( "11" );
rowC.add( "12" );

data.add( rowA );
data.add( rowB );
data.add( rowC );

// Die Titel für das Table
Vector title = new Vector();
title.add( "A" );
title.add( "B" );
title.add( "C" );
title.add( "D" );

// Das JTable initialisieren
JTable table = new JTable( data, title );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}
</code=java>
[[Bild:JTableTutorial3.png]]

Das hat natürlich den Vorteil, dass man die Vektoren an verschiedenen Orten zusammenbauen kann, doch auch hier gilt: nachdem das JTable initialisiert wurde, kann man nichts mehr verändern.

===3. Möglichkeit - DefaultTableModel===
Mit einem [[DefaultTableModel (API) | DefaultTableModel]].

Ein DefaultTableModel kann man sich auch als 2-dimensionalen Array vorstellen. Allerdings besitzt es Methoden, um neue Rows/Columns hinzuzufuegen, oder zu entfernen, z.B. addRow.

Was ein TableModel ist, wird im naechsten Teil behandelt.
<code=java>
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

public class JTableDemo{
public static void main( String[] args ){
// Die Namen der Columns
String[] titles = new String[]{ "A", "B", "C", "D" };

// Das Model das wir verwenden werden. Hier setzten wir gleich die
// Titel, aber es ist später immer noch möglich weitere Columns oder
// Rows hinzuzufügen.
final DefaultTableModel model = new DefaultTableModel( titles, 0 );

// Das JTable initialisieren
JTable table = new JTable( model );

// Buttons, damit das alles schöner aussieht.
final JButton buttonAddRow = new JButton( "add row" );
final JButton buttonRemRow = new JButton( "remove row" );
final JButton buttonAddCol = new JButton( "add column" );

buttonRemRow.setEnabled( false );

// Den Buttons ein paar Reaktionen geben
buttonAddRow.addActionListener( new ActionListener(){
public void actionPerformed(ActionEvent e) {
// Die Anzahl Columns (Breite) der Tabelle
int size = model.getColumnCount();

// einen neuen Vector mit Daten herstellen
Vector newDatas = createDataVector( "row", size );

// eine neue Row hinzufügen
model.addRow( newDatas );

// das Entfernen erlauben
buttonRemRow.setEnabled( true );
}
});

buttonAddCol.addActionListener( new ActionListener(){
public void actionPerformed(ActionEvent e) {
int size = model.getRowCount();
Vector newDatas = createDataVector( "column", size );
String name = String.valueOf( model.getColumnCount() );
model.addColumn( name, newDatas );
}
});

buttonRemRow.addActionListener( new ActionListener(){
public void actionPerformed(ActionEvent e) {
int size = model.getRowCount();
int index = (int)(Math.random() * size);
model.removeRow( index );

buttonRemRow.setEnabled( size > 1 );
}
});

JFrame frame = new JFrame( "Demo" );

Container content = frame.getContentPane();

content.add( new JScrollPane( table ), BorderLayout.CENTER );
content.add( buttonAddRow, BorderLayout.NORTH );
content.add( buttonRemRow, BorderLayout.SOUTH );
content.add( buttonAddCol, BorderLayout.WEST );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}

public static Vector createDataVector( String prefix, int size ){
Vector vector = new Vector( size );
for( int i = 0; i < size; i++ )
vector.add( prefix + " : " + size + " : " + i );

return vector;
}
}
</code=java>
[[Bild:JTableTutorial4.png]]

Was geschieht hier?
Es gibt 3 JButtons, welche jeweils eine Row oder Column hinzufügen, oder eine Row entfernen.
Die seltsame Schreibweise addActionListener( ... ) stellen anonyme Klassen dar.

Die eigentliche Hauptaktion macht das DefaultTableModel "model", alles andere dient nur dazu, dem Benutzer eine Möglichkeit zu bieten mit der Tabelle zu spielen.

===4. Möglichkeit - TableModel===
Mit Hilfe eines TableModels.
Das TableModel ist ein Interface. Das JTable ruft über die Methode TableModel#getValueAt( int rowIndex, int columnIndex) für jede einzelne Zelle den Wert ab.
Das muss nicht in einer bestimmten Reihenfolge geschehen, das JTable nimmt einfach gerade das, was es benötigt.

Das folgende kleine Beispiel zeigt: die Klasse Vehicel, die eigentlich überhaupt nichts mit einer Tabelle zu tun hat, kann mit Hilfe eines TableModels auf die JTable gebracht werden. Wichtig dabei ist: man muss nicht zuerst "von Hand" die Daten vorsortieren, sondern man gibt sie einfach dann zurück, wenn sie auch tatsächlich benötigt werden.

Was ist nun, falls die Daten veraendert wurden (z.B. eine Row hinzugefuegt)?
Man muss die Methoden #addTableModelListener und #removeTableModelListener implementieren. Diese Methoden werden von verschiedenen Orten aufgerufen, zum Beispiel von JTable selbst, aber mögleicherweise auch vom Look And Feel.
All diese Listener interessieren sich fuer Veränderungen des Models. Sobald sich die Daten ändern, muss man bei allen Listenern die Methode tableChanged( TableModelEvent event) aufrufen.

Das TableModelEvent enthält alle Informationen über die Veränderungen. Die Werte für das Event können nur über den Konstruktor gesetzt werden, ein paar einfache Beispiele aus der API:
<code=java>
// source Das TableModel, welches verändert wurde

TableModelEvent(source); // Sämtliche Daten von source wurden verändert
TableModelEvent(source, TableModelEvent.HEADER_ROW); // Die Struktur der Daten wurde verändert, die Columns werden auf den Ursprungszustand gesetzt.
TableModelEvent(source, 1); // Row 1 wurde verändert
TableModelEvent(source, 3, 6); // Row 3, 4, 5, 6 wurden verändert
TableModelEvent(source, 2, 2, 6); // Die Zelle (2, 6) wurde verändert
TableModelEvent(source, 3, 6, TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT); // Es wurden neue Rows hinzugefügt, sie haben nun die Indices 3, 4, 5 und 6
TableModelEvent(source, 3, 6, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE); // Die Rows mit den Indices 3, 4, 5 und 6 wurden gelöscht.

TableModelEvent(source, 2, 3, 5, TableModelEvent.INSERTED ) // Fehler: Es ist nicht möglich, dass Zelle (2,5) und (3,5) hinzugefügt werden.
</code=java>

Sicher bekannt ist das Verhältnis zwischen Button und ActionListener.
Sobald jemand den Button drückt, wird der ActionListener aufgerufen. Der Button ist sozusagen für die Aktion, der ActionListener für die Reaktion zuständig.
Hier ist es genau umgekehrt: das TableModel startet die Aktion, die TableModelListener reagieren darauf.

Das folgende Beispiel zeigt, wie man dem JTable (indirekt) sagen kann, dass eine neue Row hinzugefügt wurde.
Genau gleich wie hier das Hinzufügen von neuen Vehikeln, kann man auch das Löschen von einzelnen Columns, die Veränderung des Inhalts einer Zelle, etc... implementieren.

mehr zu Listeners.

Zuerst das Frame, wie wir es verwenden möchten:
<code=java>import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;

public class JTableDemo{
public static void main( String[] args ){
// Unser TableModel (siehe unten)
final Model model = new Model();

// Das JTable initialisieren
JTable table = new JTable( model );

// Buttons, damit das alles schöner aussieht.
final JButton buttonVehicel = new JButton( "add vehicel" );

// Den Buttons ein paar Reaktionen geben
buttonVehicel.addActionListener( new ActionListener(){
public void actionPerformed(ActionEvent e) {
// Die Anzahl Columns (Breite) der Tabelle
int size = model.getRowCount();

// einen neuen Vector mit Daten herstellen
Vehicel vehicel = createVehicel( size );

// ein neues Vehikel hinzufügen
model.addVehicle( vehicel );
}
});

JFrame frame = new JFrame( "Demo" );

Container content = frame.getContentPane();

content.add( new JScrollPane( table ), BorderLayout.CENTER );
content.add( buttonVehicel, BorderLayout.SOUTH );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}

// Stellt einfach eine neue Instanz eines Vehikels her.
public static Vehicel createVehicel( int index ){
index = index % 5; // Modulo

switch( index ){
case 0: return new Vehicel( "Fahrrad", 1, 2, false );
case 1: return new Vehicel( "Bus", 20, 4, true );
case 2: return new Vehicel( "Pferd", 1, 0, false );
case 3: return new Vehicel( "Zug", 1000, 80, true );
case 4: return new Vehicel( "Truck", 2, 10, true );
default: return null;
}

}
}
</code=java>
Der Code für eine Datenstruktur "Vehicel":
<code=java>// Das Vehikel ist eine total unabhängige Klasse, die mit einer
// Tabelle eigentlich gar nichts zu tun hat.
class Vehicel{
private String name;
private int places, wheels;
private boolean motor;

public Vehicel( String name, int places, int wheels, boolean motor ){
this.name = name;
this.places = places;
this.wheels = wheels;
this.motor = motor;
}

public String getName(){ return name; }
public int getPlaces(){ return places; }
public int getWheels(){ return wheels; }
public boolean hasMotor(){ return motor; }
}
</code=java>
Das Model, dass die Vehicel in eine Form übersetzt, welche das JTable anzeigen kann:
<code=java>
// Unsere Implementation des TableModels
class Model implements TableModel{
private Vector vehicels = new Vector();
private Vector listeners = new Vector();

public void addVehicle( Vehicel vehicel ){
// Das wird der Index des Vehikels werden
int index = vehicels.size();
vehicels.add( vehicel );

// Jetzt werden alle Listeners benachrichtigt

// Zuerst ein Event, "neue Row an der Stelle index" herstellen
TableModelEvent e = new TableModelEvent( this, index, index,
TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT );

// Nun das Event verschicken
for( int i = 0, n = listeners.size(); i<n; i++ ){
((TableModelListener)listeners.get( i )).tableChanged( e );
}
}

// Die Anzahl Columns
public int getColumnCount() {
return 4;
}

// Die Anzahl Vehikel
public int getRowCount() {
return vehicels.size();
}

// Die Titel der einzelnen Columns
public String getColumnName(int column) {
switch( column ){
case 0: return "Name";
case 1: return "Fahrgäste";
case 2: return "Räder";
case 3: return "Besitzt Motor";
default: return null;
}
}

// Der Wert der Zelle (rowIndex, columnIndex)
public Object getValueAt(int rowIndex, int columnIndex) {
Vehicel vehicle = (Vehicel)vehicels.get( rowIndex );

switch( columnIndex ){
case 0: return vehicle.getName();
case 1: return new Integer( vehicle.getPlaces() );
case 2: return new Integer( vehicle.getWheels() );
case 3: return vehicle.hasMotor() ? Boolean.TRUE : Boolean.FALSE;
default: return null;
}
}

// Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden soll
public Class getColumnClass(int columnIndex) {
switch( columnIndex ){
case 0: return String.class;
case 1: return Integer.class;
case 2: return Integer.class;
case 3: return Boolean.class;
default: return null;
}
}

public void addTableModelListener(TableModelListener l) {
listeners.add( l );
}
public void removeTableModelListener(TableModelListener l) {
listeners.remove( l );
}

public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
// nicht beachten
}
}
</code=java>

[[Bild:JTableTutorial5.png]]

====API - TableModel====
Ein Überblick aller Methoden, die das Interface TableModel vorschreibt.

''int getColumnCount()''
Gibt die Anzahl Columns (Spalten) zurück. Dieser Wert muss natürlich >= 0 sein.

''String getColumnName(int columnIndex)''
Gibt den Namen einer Column zurück. Der Name wird als Titel im JTableHeader verwendet.

''int getRowCount()''
Gibt die Anzahl Rows (Zeilen) zurück. Wie der Wert bei "getColumnCount" muss dieser Wert >= 0 sein.

''Object getValueAt(int rowIndex, int columnIndex)''
Gibt den Wert der Zelle (rowIndex, columnIndex) zurück.
Dieses Object wird dem TableCellRenderer (siehe nächstes Kapitel) übergeben. Der Renderer ist eine Component, welche das Object irgendwie darstellen kann (z.B. ein JLabel das einen String als Text anzeigt.)

Primitive Datentypen wie int, double, ... werden am einfachsten in ihrere Wrapperklasse Integer, Double, ... zurückgegeben.

Das Object das hier zurückgegeben wird, muss eine Instanc von der Klasse sein, die bei #getColumnClass zurückgegeben wird.

''Class getColumnClass(int columnIndex)''
Gibt die Klasse (oder Superklasse) aller Zellenwerte der Column columnIndex zurück. Das JTable verwendet diese Klasse, um herauszufinden, wie es diese Column am besten darstellt. z.B. Werden Icons anders dargestellt als Booleans...

z.B. die Klasse von String kann man so herausfinden:
<code=java>Class string = String.class;</code=java>
''boolean isCellEditable(int rowIndex, int columnIndex)''
Gibt an, ob diese Zelle editiert werden kann.
Falls ja, kann das JTable einen Editor (eine andere Component) in dieser Zelle darstellen, sollte der Benutzer sie selektieren (es gibt also immer höchstens einen sichtbaren Editor pro JTable).
Wird das Editieren beendet (z.B. durch einen Druck auf ENTER), gibt der Editor ein Object zurueck, welches mit #setValueAt an das TableModel übertragen wird.

''void setValueAt(Object aValue, int rowIndex, int columnIndex)''
Setzt an einer Stelle der Tabelle einen neuen Wert. Dieser neue Wert wird durch den Benutzer eingegeben. Diese Methode wird niemals aufgerufen, wenn #isCellEditable( rowIndex, columnIndex ) false zurueckgibt.

Sollte dem JTable nichts Spezielles gesagt worden sein, und gibt getColumnClass( columnIndex ) weder String, noch Boolean, Integer,..., oder Date zurück, wird aValue ein String sein. Dann muss das TableModel diesen String selbst übersetzen.

''void addTableModelListener(TableModelListener l)''
Registriert einen TableModelListener bei diesem Model. Dieser Listener muss immer dann aufgerufen werden, sobald die Daten im Model verändert wurden (z.B. eine zusätzliche Row hineingeschoben wurde).
Listener können vom JTable oder von anderen Klassen kommen, es muss das Model nicht interessieren.

''void removeTableModelListener(TableModelListener l)''
Entfernt einen TableModelListener. z.B. muss das JTable ja nicht mehr über Veränderungen informiert werden, falls das Model vom Table entfernt wurde...

====API - TableModelEvent====
Das TableModelEvent befördert Informationen von einem TableModel zu seinen TableModelListenern.

=====Konstruktoren=====
Das TableModelEvent hat verschiedene Konstruktoren. Je nach dem welcher mit welchen Argumenten benutzt wurde, bekommt das Event eine andere Bedeutung.

source ist immer das TableModel, in dem etwas passiert ist.

''TableModelEvent(TableModel source)''
Benutzen, falls die Veränderungen zu komplex für eine Beschreibung sind. Dann verliert das JTable allerdings viele Benutzereinstellungen, wie z.B. die Selektion.

''TableModelEvent(TableModel source, int row)''
Gibt an, dass eine Row (mit dem Index row) verändert wurde.
Allerdings kann row auch die Konstante HEADER_ROW sein, falls sich etwas mit der Titelleiste des JTables veraendert hat (z.B. ein Titel).

''TableModelEvent(TableModel source, int firstRow, int lastRow)''
Gibt an, dass alle Rows von firstRow bis und mit lastRow verändert wurden.

''TableModelEvent(TableModel source, int firstRow, int lastRow, int column)''
Gibt an, dass alle Rows von firstRow bis und mit lastRow verändert wurden.
column kann der Index einer einzigen Column sein, oder aber die Konstante ALL_COLUMNS falls mehrere Columns verändert wurden.

''TableModelEvent(TableModel source, int firstRow, int lastRow, int column, int type)''
Gibt an, dass alle Rows von firstRow bis und mit lastRow verändert wurden.
column kann der Index einer einzigen Column sein, oder aber die Konstante ALL_COLUMNS falls mehrere Columns verändert wurden.
type ist einer von INSERT, DELETE oder UPDATE.

=====Konstanten=====
''static int ALL_COLUMNS''
Wird für das Argument column verwendet, und gibt an, dass alle Columns betroffen sind.

''static int DELETE''
Wird für das Argument type verwendet, und gibt an, dass Rows gelöscht wurden.

''static int HEADER_ROW''
Gibt an, dass die Titelleiste von irgendwelchen Veränderungen betroffen ist.

''static int INSERT''
Wird für das Argument type verwendet, und gibt an, dass Rows eingefügt wurden.

''static int UPDATE''
Wird für das Argument type verwendet, und gibt an, dass sich der Inhalt der Rows verändert hat.

====Info - Aufruf von getValueAt====
Es wurde ja schon gesagt: das JTable holt sich die Informationen in keiner bestimmten Reihenfolge. Das kann man sichtbar machen (aber Achtung, der Code nun folgt, sollte nicht so verwendet werden).

Die Tabelle
<code=java>import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;

public class JTableDemo{
public static void main( String[] args ){
// Unser TableModel (siehe unten)
final Model model = new Model(50, 60);

// Das JTable initialisieren
JTable table = new JTable( model );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}
</code=java>
Ein TableModel das Integer ausgiebt, und mitzählt, wieoft "getValueAt" aufgerufen wurde (für jede Zelle einzeln)
<code=java>class Model implements TableModel{
private int width, height;

int[][] calls;

public Model( int width, int height ){
this.width = width;
this.height = height;
calls = new int[ width ][ height ];
}

// Die Anzahl Columns
public int getColumnCount() {
return width;
}

// Die Anzahl Vehikel
public int getRowCount() {
return height;
}

// Die Titel der einzelnen Columns
public String getColumnName(int column) {
return String.valueOf( column );
}

// Der Wert der Zelle (rowIndex, columnIndex)
public Object getValueAt(int rowIndex, int columnIndex) {
// bei jedem Aufruf wird dieser Wert um 1 erhöht
return new Integer( calls[ columnIndex ][ rowIndex ]++ );
}

// Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden soll
public Class getColumnClass(int columnIndex) {
return Integer.class;
}

public void addTableModelListener(TableModelListener l) {}
public void removeTableModelListener(TableModelListener l) {}
public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {}
}
</code=java>
[[Bild:JTabelTutorial6.png]]
Dieses TableModel zählt für jede Zelle, wie oft sie aufgerufen wurde.

====Ausblick - Eingeben von Daten====
Es wäre doch schön, wenn der Benutzer auch Daten eingeben könnte.
Die JTable und das TableModel sind bereits darauf vorbereitet, und es ist nicht viel vonnöten, bis das Beispiel aus 4. veränderbare Vehikel besitzt:

Das Vehicel benötigt noch neue Methoden:
<code=java>class Vehicel{
... // der ganze Rest

// Diese 4 Methoden müssen dem Vehikel noch hinzugefügt werden:
public void setName( String name ){ this.name = name; }
public void setPlaces( int places ){ this.places = places; }
public void setWheels( int wheels ){ this.wheels = wheels; }
public void setHasMotor( boolean motor ){ this.motor = motor; }
}
</code=java>
Die letzen beiden Methoden von "Model" müssen angepasst werden, so dass auch Daten gesetzt werden können
<code=java>class Model implements TableModel{

... // der ganze Rest

// Die beiden letzten Methoden (siehe 4.) müssen noch verändert werden.

// Gibt nun an, dass jede Zelle editierbar ist.
public boolean isCellEditable(int rowIndex, int columnIndex) {
return true;
}

// Wird von der JTable aufgerufen, falls in eine Zelle ein neuer Wert gesetzt werden soll
// Praktischerweise ist "aValue" ein Objekt desselben Types, welchen wir bei
// "public Class getColumnClass(int columnIndex)" zurückgegeben haben (Also String, Integer oder Boolean)
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
Vehicel vehicel = (Vehicel)vehicels.get( rowIndex );

switch( columnIndex ){
case 0:
vehicel.setName( (String)aValue );
break;
case 1:
vehicel.setPlaces( ((Integer)aValue).intValue() );
break;
case 2:
vehicel.setWheels( ((Integer)aValue).intValue() );
break;
case 3:
vehicel.setHasMotor( ((Boolean)aValue).booleanValue() );
break;
}
}
}
</code=java>
[[Bild:JTableTutorial7.png]]

==Breite der Spalten==
Die Breite der Spalten lässt sich über die Objekte der Klasse TableColumn, die eine Spalte der JTable repräsentiert, verändern.
Dabei benutzt man nicht die Methode setWidth, sondern die Methode setPreferredWidth.
Natürlich kann man die Breite der Spalten erst festlegen, nachdem man das Model mit der Anzahl Spalten übergeben hat.

===1. Möglichkeit - Direkt===

Man kann die TableColumns über ihren Titel abrufen.
<code=java>import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;

public class JTableDemo{
public static void main( String[] args ){
// Die Daten für das Table
String[][] data = new String[][]{
{"a", "b", "c", "d"},
{"e", "f", "g", "h"},
{"i", "j", "k", "l"}
};

// Die Column-Titles
String[] title = new String[]{
"A", "B", "C", "D"
};

// Das JTable initialisieren
JTable table = new JTable( data, title );

// Das automatische Neusetzen der Grösse würde das Vorhaben, die Grösse selbst
// zu setzen, stören.
table.setAutoResizeMode( JTable.AUTO_RESIZE_OFF );

table.getColumn( "A" ).setPreferredWidth( 20 );
table.getColumn( "B" ).setPreferredWidth( 50 );
table.getColumn( "C" ).setPreferredWidth( 80 );
table.getColumn( "D" ).setPreferredWidth( 110 );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}
</code=java>
[[Bild:JTableTutorial8.png]]

===2. Möglichkeit - Mit Indices über das TableColumnModel===

Nicht immer gibt es ein eindeutiges Objekt, welches eine Column identifiziert. Ein simples Beispiel: es wird zweimal derselbe Titel gewählt, oder die Titel sind dynamisch, und man weiss nicht, wann welcher Titel angezeigt wird.

In diesem Fall muss man tiefer in das JTable hineinlangen, um die Columns zu erreichen. Man muss das TableColumnModel befragen.
<code=java>import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.TableColumnModel;

public class JTableDemo{
public static void main( String[] args ){
// Die Daten für das Table
String[][] data = new String[][]{
{"a", "b", "c", "d"},
{"e", "f", "g", "h"},
{"i", "j", "k", "l"}
};

// Die Column-Titles
String[] title = new String[]{
"A", "A", "A", "A"
};

// Das JTable initialisieren
JTable table = new JTable( data, title );

// Das automatische Neusetzen der Grösse würde das Vorhaben, die Grösse selbst
// zu setzen, stören.
table.setAutoResizeMode( JTable.AUTO_RESIZE_OFF );

// Über das TableColumnModel kommt man an die wichtigen Daten
TableColumnModel columnModel = table.getColumnModel();

// Die einzelnen Columns ansprechen und die Grösse setzen
columnModel.getColumn( 0 ).setPreferredWidth( 20 );
columnModel.getColumn( 1 ).setPreferredWidth( 50 );
columnModel.getColumn( 2 ).setPreferredWidth( 80 );
columnModel.getColumn( 3 ).setPreferredWidth( 110 );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}
</code=java>
[[Bild:JTableTutorial8.png]]

===3. Der Auto-Resize-Modus===

In den beiden vorangegangen Beispielen wurd der Autoresize-Modus deaktiviert.
<code=java>table.setAutoResizeMode( JTable.AUTO_RESIZE_OFF );</code=java>
Wenn man diese Zeile weglässt, versucht das JTable die Grösse der Spalten anzupassen. Dabei benutzt es die Einstellungen der "preferredWidth", welche man ja verändert hat:

a) mit dem normalen Resize-Mode:

[[Bild:JTableTutorial9.png]]

b) zum Vergleich, mit deaktiviertem Resize-Mode:

[[Bild:JTableTutorial8.png]]

==Darstellung der Daten==

Bereits in im vorhergehenden Teil hat man gesehen, dass das JTable offenbar mehr kann als nur Text zu zeichnen:

[[Bild:JTableTutorial12.png]]

===1. Das Standardverhalten===
Mit Hilfe der Methode TableModel#getColumnClass versucht das JTable herauszufinden, wie diese Column am besten dargestellt werden kann.

Ein Blick in den Quellcode von JTable verrät, dass Number, Float, Double, Date, Icon, ImageIcon und Boolean eine Spezialbehandlung erhalten.

Sollte ein Object nicht dazu passen, wird die "toString" Methode benutzt.

Demonstrieren wir mal, wie das aussieht:
<code=java>import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.util.Date;

import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;

public class JTableDemo{
public static void main( String[] args ){
// Unser TableModel (siehe unten)
Model model = new Model();

// Das JTable initialisieren
JTable table = new JTable( model );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}
</code=java>
Ein einfaches Icon, damit man nicht Bilder laden, etc... muss:
<code=java>class DemoIcon implements Icon{
public int getIconHeight() {
return 15;
}
public int getIconWidth() {
return 15;
}
public void paintIcon(Component c, Graphics g, int x, int y) {
g.setColor( Color.DARK_GRAY );
g.fillOval( x, y, 10, 10 );
g.setColor( Color.GREEN );
g.fillOval( x+5, y+5, 10, 10 );
}
}
</code=java>
Wiedereinmal ein TableModel. Diesmal wird AbstractTableModel als Basisklasse benutzt, denn so muss man weniger Methoden implementieren:
<code=java>class Model extends AbstractTableModel{
private Object[] objects;
private Class[] classes;

public Model(){
objects = new Object[]{
"Text",
Float.valueOf( 5.123f ),
Boolean.valueOf( true ),
new Date( System.currentTimeMillis() ),
new DemoIcon(),
Color.RED
};

classes = new Class[]{
String.class,
Float.class,
Boolean.class,
Date.class,
Icon.class,
Color.class
};
}

// Die Anzahl Columns
public int getColumnCount() {
return objects.length;
}

// Die Anzahl Rows
public int getRowCount() {
return 1;
}

// Die Titel der einzelnen Columns (Der Name der Klasse die Dargestellt wird)
public String getColumnName(int column) {
return getColumnClass( column ).getName();
}

// Der Wert der Zelle (rowIndex, columnIndex)
public Object getValueAt(int rowIndex, int columnIndex) {
return objects[ columnIndex ];
}

// Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden soll
public Class getColumnClass(int columnIndex) {
return classes[columnIndex];
}
}
</code=java>
[[Bild:JTableTutorial13.png]]

Wie man sieht, wurde das Color-Objekt nicht gerade schön dargestellt. Da das JTable nicht wusste, wie es mit einem Color-Objekt umgehen soll, wurde einfach die "toString"-Methode benutzt.

===2. Ein einfacher TableCellRenderer===
Tabellenzellen werden standardmäßig quasi von {{JAPI|JLabel}} dargestellt. Ein {{JAPI|DefaultTableCellRenderer}} erbt von JLabel und implementiert neben weiteren Interfaces auch {{JAPI|TableCellRenderer}}, welches die Methode
<code=java>
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column)
</code=java>
einführt. In seiner einfachsten Variante braucht ein TableCellRenderer nur die setValue()-Methode zu überschreiben. Das empfiehlt sich, wenn man die o.g. Standarddatentypen, wie String, Boolean, Number usw. in ihrer Darstellung, mit den von JLabel angebotenen Möglichkeiten, anpassen möchte.

Wenn eine Zelle ein Color-Objekt darstellen soll, kann die Farbe direkt dargestellt werden:
<code=java>
public class ColorTableCellRenderer extends DefaultTableCellRenderer {

@Override
protected void setValue(Object value) {
if (value instanceof Color) { //Wenn das TableModel für diese Zelle ein Color-Objekt zurück gibt
Color color = (Color)value;
setText( color.getRed() + ", " + color.getBlue() + ", " + color.getGreen() );
setBackground( color );
setHorizontalAlignment(JLabel.CENTER);
} else {
super.setValue(value); //ansonsten möchten wir das Verhalten vom DefaultTableCellRenderer
}
}
}
</code=java>

Eine weitere Möglichkeit besteht im Überschreiben der Methode getTableCellRendererComponent(), in der die gewünschten Manipulationen programmiert werden.
Wie kann man dem JTable also nun sagen, dass Color auch speziell angezeigt werden soll?
Indem man einen TableCellRenderer implementiert, und dem JTable über die Methode JTable#setDefaultRenderer übergibt.

Der Einfachheit halber, wird für das Beispiel ein DefaultTableCellRenderer genommen, und ein bisschen verändert.
Die bekannte Tabelle mit einem zusätzlichen Befehl
<code=java>public class JTableDemo{
public static void main( String[] args ){
// Unser TableModel (siehe unten)
Model model = new Model();

// Das JTable initialisieren
JTable table = new JTable( model );

// Hier wird der JTable gesagt, dass Objekte des Types "Color" vom "ColorTableCellRenderer" dargestellt werden
table.setDefaultRenderer( Color.class, new ColorTableCellRenderer() );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}
</code=java>
Das DemoIcon bleibt unverändert:
<code=java>class DemoIcon implements Icon{
...
}
</code=java>
Auch an "Model" muss nichts verändert werden:
<code=java>class Model extends AbstractTableModel{
...
}
</code=java>
Und jetzt kommt der neue TableCellRenderer.
<code=java>class ColorTableCellRenderer extends DefaultTableCellRenderer{
public Component getTableCellRendererComponent(JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {
super.getTableCellRendererComponent(table, value, isSelected,
hasFocus, row, column);

Color color = (Color)value;

setText( color.getRed() + ", " + color.getBlue() + ", " + color.getGreen() );
setForeground( color );

return this;
}
}
</code=java>
[[Bild:JTableTutorial14.png]]

Das JTable erwartet von einem TableCellRenderer eine Component, welche genau eine Zelle darstellt. Allerdings wird diese Component nicht für immer behalten, sondern sie muss nur kurz diese Zelle zeichnen, und wird danach nicht mehr benötigt.

Was macht "ColorTableCellRenderer"?
Sobald das JTable vom ColorTableCellRenderer eine Component haben möchte, ruft es ersteinmal die entsprechende Methode von DefaultTableCellRenderer auf. Dort werden Hintergrundfarbe und Schriftart gesetzt.
Danach setzt ColorTableCellRenderer einen Text der zu der Farbe passt (die RGB-Werte), und verändert die Schriftfarbe.
Und dann gibt er sich selbst zurück, denn betrachtet man die API, so sieht man, dass DefaultTableCellRenderer eine Unterklasse von JLabel (und damit auch von Component) ist, und dies deshalb ohne Probleme geht.

'''Wichtig!''' Es muss nie eine neue Component hergestellt werden, das Schlüsselwort new hat hier nichts verloren.

===3. Alles zum gleichen TableCellRenderer===
Manchmal möchte man vielleicht mehr Kontrolle über die Art, wie die Zellen dargestellt werden.
Eine einfache Variante ist folgende: Das TableModel gibt für alle ColumnClasses an, sie seien vom Typ Object. Und für den Typ Object setzt man einen eigenen TableCellRenderer.

Die Tabelle mit anderem TableCellRenderer:
<code=java>import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.util.Date;

import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellRenderer;

public class JTableDemo{
public static void main( String[] args ){
// Unser TableModel (siehe unten)
Model model = new Model();

// Das JTable initialisieren
JTable table = new JTable( model );

// Den Spezial-CellRenderer übergeben.
table.setDefaultRenderer( Object.class, new Renderer() );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();

frame.setVisible( true );
}
}
</code=java>
Das DemoIcon bekommt noch die Möglichkeit, andere Farben zu benutzen:
<code=java>class DemoIcon implements Icon{
private Color top, bottom;

public DemoIcon( Color top, Color bottom ){
this.top = top;
this.bottom = bottom;
}

public int getIconHeight() {
return 15;
}
public int getIconWidth() {
return 15;
}
public void paintIcon(Component c, Graphics g, int x, int y) {
g.setColor( top );
g.fillOval( x, y, 10, 10 );
g.setColor( bottom );
g.fillOval( x+5, y+5, 10, 10 );
}
}
</code=java>
Das TableModel gibt nun für jede Column an, dass Object's angezeigt werden
<code=java>private Object[][] objects;

public Model(){
objects = new Object[][]{
{"Text",
new Float( 5.123f ),
new Boolean( true ),
new Date( System.currentTimeMillis() ),
new DemoIcon( Color.DARK_GRAY, Color.GREEN ),
Color.RED},

{"Hallo",
new Double( 531.45 ),
new Boolean( false ),
new Date( System.currentTimeMillis() + 50000000 ),
new DemoIcon( Color.BLUE, Color.GRAY ),
Color.CYAN},

{"Tschau",
new Integer( 123 ),
new Boolean( true ),
"unbekannt",
new DemoIcon( Color.LIGHT_GRAY, Color.MAGENTA ),
Color.PINK}
};
}

// Die Anzahl Columns
public int getColumnCount() {
return 6;
}

// Die Anzahl Rows
public int getRowCount() {
return 3;
}

// Die Titel der einzelnen Columns
public String getColumnName(int column) {
return String.valueOf( column );
}

// Der Wert der Zelle (rowIndex, columnIndex)
public Object getValueAt(int rowIndex, int columnIndex) {
return objects[ rowIndex ][ columnIndex ];
}

// Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden soll
public Class getColumnClass(int columnIndex) {
return Object.class;
}
}
</code=java>
Der neue TableCellRenderer entscheidet für jede Zelle einzeln, wie sie dargestellt werden soll.
<code=java>class Renderer extends JLabel implements TableCellRenderer{
private Color colorSelected = new Color( 200, 255, 200 );
private Color colorFocus = new Color( 255, 200, 200 );
private Color colorNormal = new Color( 200, 200, 255 );

public Renderer(){
setOpaque( true );
}

public Component getTableCellRendererComponent(JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {

// die normalen Farben
setForeground( Color.BLACK );
if( hasFocus )
setBackground( colorFocus );
else if( isSelected )
setBackground( colorSelected );
else
setBackground( colorNormal );

setText( null );
setIcon( null );

if( value instanceof Date )
setText( ((Date)value).toGMTString() );
else if( value instanceof Icon )
setIcon( (Icon)value );
else if( value instanceof Color ){
Color color = (Color)value;
setForeground( color );
setText( color.getRed() + ", " + color.getGreen() + ", " + color.getBlue() );
}
else if( value instanceof Boolean ){
if( ((Boolean)value).booleanValue() )
setText( "yes" );
else
setText( "no" );
}
else
setText( value.toString() );

return this;
}
}
</code=java>
[[Bild:JTableTutorial15.png]]

Man beachte: in Column 3, ganz unten, ist ein String, und kein Date-Object. Da der Renderer für jede Zelle einzeln entscheiden kann, gibt es hier keine Probleme.

===4. Darstellung auf Zeilen- oder Tabellen-Ebene===
Normalerweise werden Renderer für eine bestimmte Datenklasse oder Datenspalte geschrieben.

Aber wie kann man Zeilen-abhängige oder Tabellen-abhängige Erfordnisse angehen?
Z.B. wie kann man:

a) Zeilen abwechselnd in einer Tabelle färben
b) Den Rand der selektierten Zelle ändern

Am einfachsten geht das indem man die Methode prepareRenderer() der Klasse JTable überschreibt:
<code=java>import java.awt.*;
import java.text.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.*;
public class TableRowRendering extends JFrame{
public TableRowRendering(){
// Model:
Object[] columnNames = {"Type", "Date", "Company", "Shares", "Price"};
Object[][] data =
{
{"Buy", new Date(), "IBM", new Integer(1000), new Double(80.50)},
{"Sell",new Date(), "MicroSoft", new Integer(2000), new Double(6.25)},
{"Sell",new Date(), "Apple", new Integer(3000), new Double(7.35)},
{"Buy", new Date(), "Nortel", new Integer(4000), new Double(20.00)}
};
DefaultTableModel model = new DefaultTableModel(data, columnNames) {
public Class getColumnClass(int column) {
return getValueAt(0, column).getClass();
}
};
// prepareRenderer überschreiben:
table = new JTable( model ) {
public Component prepareRenderer(
TableCellRenderer renderer, int row, int column) {
Component c = super.prepareRenderer(renderer, row, column);
if (!isRowSelected(row)) {
String type = (String)getModel().getValueAt(row, 0);
c.setBackground(row % 2 == 0 ? null : Color.LIGHT_GRAY );
}
if (isRowSelected(row) && isColumnSelected(column))
((JComponent)c).setBorder(selected);
return c;
}
};
table.setPreferredScrollableViewportSize(table.getPreferredSize());
getContentPane().add(new JScrollPane( table ), BorderLayout.CENTER);
}
private JTable table;
private Border selected = new LineBorder(Color.GREEN);
public static void main(String[] args) {
TableRowRendering frame = new TableRowRendering();
frame.setDefaultCloseOperation( EXIT_ON_CLOSE );
frame.pack();
frame.setLocationRelativeTo( null );
frame.setVisible(true);
}
}
</code=java>

===5. Wichtige Bemerkung===
Man sollte ''niemals'' einen Code schreiben, der so aussieht
<code=java>
public class Renderer implements TableCellRenderer {

[...]

public Component getTableCellRendererComponent(JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {

JLabel label = new JLabel(); // FALSCH

[...]

return label;
}
}
</code=java>
Wieso nicht? Weil man ''immer wieder dieselbe Component verwenden kann''. Denn das JTable ruft die getTableCellRendererComponent-Methode auf, und ruft gleich anschliessend den paint-Befehl der erhaltenen Component auf. Erst danach wird die "nächste" Component geholt.

Es ist wie das Tragen von Wasser: entweder läuft man mit einem Eimer zum Fluss, wieder zurück und wirft denn Eimer dann fort (weil er ja gebraucht ist), kauft sich dann einen neuen; ''oder'' man läuft mit demselben Eimer zurück zum Fluss. Ziemlich offensichtlich, dass die zweite Variante die bessere ist.

==Verändern von Daten==

Am Ende des 2. Teils wurde gezeigt, dass man auch Daten eingeben kann. Jetzt soll das nocheinmal vertieft behandelt werden.

Damit eine Zelle editiert werden kann, müssen die folgenden zwei Methoden im TableModel korrekt implementiert werden. Als Beispiel zeigen wir die Implementationen aus dem "DefaultTableModel":

<code=java> public boolean isCellEditable(int row, int column) {
return true;
}
</code=java>
<code=java> public void setValueAt(Object aValue, int row, int column) {
Vector rowVector = (Vector)dataVector.elementAt(row);
rowVector.setElementAt(aValue, column);
fireTableCellUpdated(row, column);
}
</code=java>

Bei dem Versuch, eine Zelle zu editieren, ruft das System zunächst die Methode "TableModel#isCellEditable" auf. Gibt sie "false" zurück, ist ein Editieren dieser Zelle nicht möglich. Gibt sie "true" zurück, kann der Wert der Zelle verändert werden. Wenn das geschehen ist, muss der neue Wert aber noch im TableModel abgespeichert werden. Dazu ruft das System automatisch die Methode "TableModel#setValueAt" auf und übergibt ihr den neuen Wert der Zelle. Die Methode "setValueAt" ist dann dafür verantwortlich, diesen Wert im TableModel abzuspeichern.

===1. Der einfache Weg===

Das JTable unterstützt von sich aus das Editieren von Zahlen und von Booleans. Alles andere wird wie ein String behandelt, d.h. da der Benutzer nur einen Text eingeben kann, wird dem Model ein String übergeben, welches es selbst in ein Objekt übersetzen muss.

Die Verwendung der Table-eigenen Editoren ist einfach:

Zuerst die Tabelle
<code=java>import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;

public class JTableDemo{
public static void main( String[] args ){
// Unser TableModel (siehe unten)
Model model = new Model();

// Das JTable initialisieren
JTable table = new JTable( model );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}</code=java>
Jetzt das Model. Jede Zelle ist editierbar, doch jede Column wird anders behandelt.
<code=java>
class Model extends AbstractTableModel{
private String[] strings;
private int[] integers;
private double[] doubles;
private boolean[] booleans;

public Model(){
strings = new String[]{ "hallo", "ich", "bin", "eine", "Demo" };
integers = new int[]{ 1, 2, 3, 4, 5 };
doubles = new double[]{ 1.2, 3.4, 5.6, 7.8, 9.11 };
booleans = new boolean[]{ true, false, false, true, true };
}

// Die Anzahl Columns
public int getColumnCount() {
return 4;
}

// Die Anzahl Rows
public int getRowCount() {
return 5;
}

// Die Titel der einzelnen Columns
public String getColumnName(int column) {
switch( column ){
case 0: return "String";
case 1: return "Integer";
case 2: return "Double";
case 3: return "Boolean";
default: return null;
}
}

// Der Wert der Zelle (rowIndex, columnIndex)
public Object getValueAt(int rowIndex, int columnIndex) {
switch( columnIndex ){
case 0: return strings[ rowIndex ];
case 1: return new Integer( integers[ rowIndex ] );
case 2: return new Double( doubles[ rowIndex ] );
case 3: return new Boolean( booleans[ rowIndex ] );
default: return null;
}
}

// Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden soll
public Class getColumnClass(int columnIndex) {
switch( columnIndex ){
case 0: return String.class;
case 1: return Integer.class;
case 2: return Double.class;
case 3: return Boolean.class;
default: return null;
}
}

// Jede Zelle ist editierbar
public boolean isCellEditable(int rowIndex, int columnIndex) {
return true;
}

// Wird aufgerufen, falls der Wert einer Zelle verändert wurde
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
switch( columnIndex ){
case 0:
strings[ rowIndex ] = aValue.toString();
break;
case 1:
integers[ rowIndex ] = ((Integer)aValue).intValue();
break;
case 2:
doubles[ rowIndex ] = ((Double)aValue).doubleValue();
break;
case 3:
booleans[ rowIndex ] = ((Boolean)aValue).booleanValue();
}
}
}</code=java>
[[Bild:JTableTutorial14.png]]
Es wichtig, dass man nicht vergisst, dass dies ausschliesslich für Strings (oder Objekte die als String dargestellt werden können, z.B. ein Datum), Nummern und Booleans so funktioniert!

===2. Mit Hilfe eines TableCellEditors===
Es ist möglich, eigene Editoren einzusetzen. Die Editoren werden vom JTable mit allen möglichen Informationen versorgt, welche sie irgendwie darstellen müssen. Die JTable wird dann warten, bis der Editor meldet, dass alle Daten eingegeben wurden.

Zuerst wird ein JTable aufgesetzt. Mit "setDefaultEditor" wird ein Editor mit einem Typ verbunden. Z.B. könnte der IntegerEditor mit "Integer.class" verbunden werden. Der Typ bezieht sich auf die Rückgabe von TableModel.getColumnClass.
<code=java>
import java.awt.Color;
import java.awt.Component;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.EventObject;
import java.util.List;

import javax.swing.*;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellEditor;

public class JTableDemo{
public static void main( String[] args ){
// Einige Testdaten generieren
DefaultTableModel model = new DefaultTableModel( new Object[]{ "A", "B" }, 0);
model.addRow( new Object[]{ "1", "2" });
model.addRow( new Object[]{ "3", "4" });
model.addRow( new Object[]{ "5", "6" });
model.addRow( new Object[]{ "7", "8" });
JTable table = new JTable( model );
// Den TestEditor einbinden. Er wird alle Spalten die als Typ
// "Object" haben, bearbeiten.
table.setDefaultEditor( Object.class, new TestEditor());

// Die Tabelle anzeigen
JFrame frame = new JFrame();
frame.add( new JScrollPane( table ));
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setLocationRelativeTo( null );
frame.setVisible( true );
}
}
</code=java>
Der Editor selbst ist eine ziemlich unabhängige Komponente. Oft ist es am einfachsten, direkt von einer Component zu erben, und zusätzlich das Interface TableCellEditor zu implementieren.
<code=java>
//Der Editor selbst ist ein einfaches JTextField
class TestEditor extends JTextField implements TableCellEditor, DocumentListener{
private List<CellEditorListener> listeners = new ArrayList<CellEditorListener>();

public TestEditor(){
// Der Editor hört sich selbst ab, so kann er auf jede Benutzereingabe reagieren
getDocument().addDocumentListener( this );
}

public Component getTableCellEditorComponent( JTable table, Object value, boolean isSelected, int row, int column ) {
// Diese Methode wird von der JTable aufgerufen, wenn der Editor angezeigt werden soll
setText( value.toString() );
return this;
}

public void addCellEditorListener( CellEditorListener l ) {
listeners.add( l );
}

public void cancelCellEditing() {
// Falls abgebrochen wird, werden alle Listeners informiert
ChangeEvent event = new ChangeEvent( this );
for( CellEditorListener listener : listeners.toArray( new CellEditorListener[ listeners.size() ] ))
listener.editingCanceled( event );
}

public Object getCellEditorValue() {
// Gibt den aktuellen Wert des Editors zurück
return getText();
}

public boolean isCellEditable( EventObject anEvent ) {
// Im Falle eines MouseEvents, muss ein Doppelklick erfolgen, um den Editor zu aktivieren.
// Ansonsten wird der Editor auf jeden Fall aktiviert
if( anEvent instanceof MouseEvent )
return ((MouseEvent)anEvent).getClickCount() > 1;

return true;
}

public void removeCellEditorListener( CellEditorListener l ) {
listeners.remove( l );
}

public boolean shouldSelectCell( EventObject anEvent ) {
return true;
}

public boolean stopCellEditing() {
// Sollte die Eingabe falsch sein, darf das editieren nich gestoppt werden
if( !isValidText() )
return false;

// Ansonsten werden die Listener vom stop unterrichtet
ChangeEvent event = new ChangeEvent( this );
for( CellEditorListener listener : listeners.toArray( new CellEditorListener[ listeners.size() ] ))
listener.editingStopped( event );

return true;
}

public void changedUpdate( DocumentEvent e ) {
update();
}

public void insertUpdate( DocumentEvent e ) {
update();
}

public void removeUpdate( DocumentEvent e ) {
update();
}

private boolean isValidText(){
// Bestimmt, was eine gültige Eingabe ist.
return getText().matches( "[1-9]+" );
}

public void update(){
// Verändert die Umrandung des Editors, jenachdem, ob eine gültige
// oder eine ungültige Eingabe gemacht wurde
Color color;
if( isValidText() )
color = Color.GREEN;
else
color = Color.RED;

setBorder( BorderFactory.createLineBorder( color ));
}
}
</code=java>
===3. TableCellEditor für eigene Typen===
Schon in Teil 3 wurde gezeigt, dass das JTable Objekte des Types "Date" nicht richtig unterstützt. Das soll jetzt geändert werden.

Die Tabelle, man beachte, dass ein "DateRenderer" und ein "DateEditor" registriert werden.
<code=java>
import java.awt.Component;
import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.EventObject;
import java.util.Vector;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JSpinner;
import javax.swing.JTable;
import javax.swing.SpinnerDateModel;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellEditor;

public class JTableDemo{
public static void main( String[] args ){
// Unser TableModel (siehe unten)
Model model = new Model();

// Das JTable initialisieren
JTable table = new JTable( model );

// Renderer und Editor für "Date" werden registriert
table.setDefaultRenderer( Date.class, new DateRenderer() );
table.setDefaultEditor( Date.class, new DateEditor() );

JFrame frame = new JFrame( "Demo" );
frame.getContentPane().add( new JScrollPane( table ) );

frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}
}</code=java>

Die Tabelle soll was sinnvolles darstellen: Notizen die aus einem Datum und aus einem Ereignis bestehen
<code=java>// Eine einfache Klasse die Notizen beschreibt
class Note{
private Date date;
private String event;

public Note( String event, Date date ){
setEvent( event );
setDate( date );
}

public String getEvent(){ return event; }
public Date getDate(){ return date; }

public void setEvent( String event ){ this.event = event; }
public void setDate( Date date ){ this.date = date; }
}</code=java>

Das TableModel, man beachte, dass es keine Verbindungen zum Renderer oder zum Editor besitzt! Allerdings kann durch das Wissen, dass "Date" nun unterstützt wird, in der Methode "setValueAt" ein Cast "Object -> Date" durchgeführt werden.
<code=java>class Model extends AbstractTableModel{
private Note[] notes;

public Model(){
notes = new Note[]{
new Note( "Mit Hund rausgehen", new Date( 104, 5, 2, 14, 0 ) ),
new Note( "Kino", new Date( 104, 5, 7, 21, 30 ) ),
new Note( "Abschlussprüfung", new Date( 104, 8, 14, 7, 0 ) ),
new Note( "Einkaufen gehen", new Date( 104, 5, 2, 16, 0 ) ),
new Note( "Rechnung bezahlen", new Date( 110, 11, 30, 23, 59 ) ),
};
}

// Die Anzahl Columns
public int getColumnCount() {
return 2;
}

// Die Anzahl Rows
public int getRowCount() {
return 5;
}

// Die Titel der einzelnen Columns
public String getColumnName(int column) {
if( column == 0 )
return "Ereignis";
else
return "Datum";
}

// Der Wert der Zelle (rowIndex, columnIndex)
public Object getValueAt(int rowIndex, int columnIndex) {
if( columnIndex == 0 )
return notes[ rowIndex ].getEvent();
else
return notes[ rowIndex ].getDate();
}

// Eine Angabe, welchen Typ von Objekten in den Columns angezeigt werden soll
public Class getColumnClass(int columnIndex) {
if( columnIndex == 0 )
return String.class;
else
return Date.class;
}

// Jede Zelle ist editierbar
public boolean isCellEditable(int rowIndex, int columnIndex) {
return true;
}

// Wird aufgerufen, falls der Wert einer Zelle verändert wurde
// Der Wert kommt entweder als String, oder von dem
// DateEditor (und daher als Date).
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
if( columnIndex == 0 )
notes[ rowIndex ].setEvent( (String)aValue );
else
notes[ rowIndex ].setDate( (Date)aValue );
}
}</code=java>
Der Renderer, der "Date" auf eine brauchbare Art darstellt ist einfach gehalten:
<code=java>
class DateRenderer extends DefaultTableCellRenderer{
private DateFormat format;

public DateRenderer(){
format = DateFormat.getDateTimeInstance();
}

public Component getTableCellRendererComponent(JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {

// Date's werden auf einem einfache Weg in lesbare Texte umgewandelt.
String text = format.format( (Date)value );

return super.getTableCellRendererComponent(table, text, isSelected,
hasFocus, row, column);
}
}
</code=java>
Der Editor. Der Editor erbt von JSpinner. Glücklicherweise unterstützt der JSpinner "Date", und so kann man das meiste an den JSpinner delegieren
<code=java>
class DateEditor extends JSpinner implements TableCellEditor{
private SpinnerDateModel model;

private List listeners = new ArrayList();

// Standardkonstruktor
public DateEditor(){
model = new SpinnerDateModel();
model.setCalendarField( Calendar.DAY_OF_YEAR );
setModel( model );
}

// Möglicherweise möchte jemand über Ereignisse des Editors
// informiert werden
public void addCellEditorListener(CellEditorListener l) {
listeners.add( l );
}

// Ein CellEditorListener entfernen
public void removeCellEditorListener(CellEditorListener l) {
listeners.remove( l );
}

// Gibt den aktuellen Wert des Editors zurück.
public Object getCellEditorValue() {
return model.getDate();
}

// Gibt eine Component zurück, welche auf dem JTable dargestellt wird,
// und mit der der Benutzer interagieren kann.
public Component getTableCellEditorComponent(JTable table, Object value,
boolean isSelected, int row, int column) {

model.setValue( value );
return this;
}

// Gibt an, ob die Zelle editierbar ist. Das EventObject kann
// ein MouseEvent, ein KeyEvent oder sonst was sein.
public boolean isCellEditable(EventObject anEvent) {
return true;
}

// Gibt an, ob die Editor-Component selektiert werden muss, um
// sie zu benutzen. Diese Editor soll immer selektiert werden,
// deshalb wird hier true zurückgegeben
public boolean shouldSelectCell(EventObject anEvent) {
return true;
}

// Bricht das editieren der Zelle ab
public void cancelCellEditing() {
fireEditingCanceled();
}

// Stoppt das editieren der Zelle, sofern möglich.
// Da der JSpinner immer einen gültigen Wert anzeigt, kann auch
// jederzeit gestoppt werden (return-Wert = true)
public boolean stopCellEditing() {
fireEditingStopped();
return true;
}

// Benachrichtig alle Listener, dass das Editieren abgebrochen wurde
protected void fireEditingCanceled(){
ChangeEvent e = new ChangeEvent( this );
for( int i = 0, n = listeners.size(); i<n; i++ )
((CellEditorListener)listeners.get( i )).editingCanceled( e );
}

// Benachrichtig alle Listener, dass das Editieren beendet wurde
protected void fireEditingStopped(){
ChangeEvent e = new ChangeEvent( this );
for( int i = 0, n = listeners.size(); i<n; i++ )
((CellEditorListener)listeners.get( i )).editingStopped( e );
}
}
</code=java>
[[Bild:JTableTutorial15.png]]
Also: der Editor ist eine Component die auf das JTable gesetzt wird, einen bestimmten Wert zugewiesen bekommt, und diesen Wert verändern darf. Klickt der Benutzer an eine andere Stelle, wird das Editieren entweder abgebrochen (cancelCellEditing) oder beendet (stopCellEditing), und der Wert dem TableModel über die Methode setValueAt überwiesen.

==JTableHeader, TableColumn und das TableColumnModel==

===JTableHeader===
Der JTableHeader ist ein Component, der die Darstellung der Tabellenspalten einer JTable übernimmt. Meistens braucht an diesen Component nicht, da JTable ihn standardmäßig mitinstantiiert. Die beiden Methoden getTableHeader() und setTableHeader() in JTable bieten an mit dem JTableHeader zu arbeiten. JTableHeader ist nicht dazu da um Spalten hinzuzufügen oder zu entfernen, sondern nur für die Darstellung zuständig. Für die Daten der Spalten ist das TableColumnModel zuständig, welches man wahlweise der JTable oder dem JTableHeader übergeben kann.

JTableHeader, in javax.swing.table, bietet einige interessante Methode an um die Spalten zu manipulieren. Die gebräuchlichsten beiden Methoden sind, finde ich, setReorderingAllowed(boolean reorderingAllowed) und setResizingAllowed(boolean resizingAllowed). Sie sollten selbsterklärend sein. Hier ein kleiens Beispielprogramm:
<code=java>
import javax.swing.*;
import javax.swing.table.JTableHeader;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableColumn;

class TableHeaderTest {

public static void main(String[] args) {
// JTable initialisieren und mit Inhalt füllen; siehe dazu Teil 2
JTable table = new JTable(new String[][]{{"1", "2", "3"},{"4", "5", "6"}}, new String[]{"A", "B", "C"});

// JTableHeader holen
JTableHeader header = table.getTableHeader();

// ColumnModel holen:
TableColumnModel columnModel = header.getColumnModel();

// TableColumn erstellen
TableColumn aColumn = new TableColumn();
// setHeaderValue() setzt den Titel
aColumn.setHeaderValue("D");
// modelIndex zeigt an von welcher Spalte im DatenModel die neue Spalte ihre Werte holen soll
aColumn.setModelIndex(1); // Index 1 im Model sind also "2" und "5"
columnModel.addColumn(aColumn);

// eine spalte verschieben
columnModel.moveColumn(0, 2); // Spalte 0 (mit Titel "A") verschieben an Position 2 im Model

// Spalten nicht resizable machen, nicht zulassen dass die Spaltenreihenfolge geändert werden kann
header.setResizingAllowed(false);
header.setReorderingAllowed(false);

// JFrame konstruieren
JFrame frame = new JFrame("JTableHeader test");
// Table in JScrollPane einfügen und dem Frame hinzufügen
frame.getContentPane().add(new JScrollPane(table));
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}
</code=java>
[[Bild:JTableTutorial15.png]]
Erklärung:
Zuerst wird die Tabelle ganz normal angelegt, dann holt sich das Programm den JTableHeader der Tabelle. Vom TableHeader das DolumnModel, was aber auch direkt über die JTable gehen würde. Dann wird eine Spalte hinzugefügt, mit dem Model Index 1 (Das TableModel ist in Teil 2 erklärt). Danach wird die Spalte an position 0 ("A") vershcoben an position 2. Man muss immer daran denken dass das Zählen bei 0 anfängt, also sind mit den Zahlen immer die Positionen im Model gemeint. Letztendlich wird noch verboten die Spaltengröße, und die Spaltenreihenfolge zu ändern.

===Header selber zeichnen===

Eine weitere Möglichkeit von JTableHeader und TableColumn ist, wie auch bei JTable möglich, den Renderer für die Spalte zu setzen.
Es wird das gleiche Renderer Interface benutzt wie bei der JTable: javax.swing.table.TableCellRenderer. Zugewiesen wird der Renderer mit setDefaultRenderer(TableCellRenderer defaultRenderer);

Beispiel:
<code=java>
import java.awt.Component;
import java.awt.Color;
import javax.swing.*;
import javax.swing.table.JTableHeader;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableColumn;
import javax.swing.table.TableCellRenderer;

class TableHeaderTest {

public static void main(String[] args) {
// JTable initialisieren und mit Inhalt füllen; siehe dazu Teil 2
JTable table = new JTable(new String[][]{{"1", "2", "3"},{"4", "5", "6"}}, new String[]{"A", "B", "C"});

// JTableHeader holen
JTableHeader header = table.getTableHeader();

// ColumnModel holen:
TableColumnModel columnModel = header.getColumnModel();

// TableColumn erstellen
TableColumn aColumn = new TableColumn();
// setHeaderValue() setzt den Titel
aColumn.setHeaderValue("D");
// modelIndex zeigt an von welcher Spalte im DatenModel die neue Spalte ihre Werte holen soll
aColumn.setModelIndex(1); // Index 1 im Model sind also "2" und "5"
columnModel.addColumn(aColumn);

// eine spalte verschieben
columnModel.moveColumn(0, 2); // spalte 0 (mit Tiel "A") verschieben an position 2 im model

// spalten nicht resizable machen, nicht zulassen dass die spaltenreihenfolge geändert werden kann
header.setResizingAllowed(false);
header.setReorderingAllowed(false);

// Renderer zuweisen
header.setDefaultRenderer(new MyHeaderCellRenderer());

// JFrame konstruieren
JFrame frame = new JFrame("JTableHeader test");
// Table in JScrollPane einfügen und dem Frame hinzufügen
frame.getContentPane().add(new JScrollPane(table));
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}

// Eigener CellRenderer für die spaltenköpfe. Liefert immer ein
// JLabel zurück, und implementiert TableCellRenderer
class MyHeaderCellRenderer extends JLabel implements TableCellRenderer {

// einzig wichtige methode
public Component getTableCellRendererComponent(JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {
// text
setText(value.toString());
// normale schriftart
setFont(table.getFont());
// der standard rahmen für spaltenköpfe
setBorder(UIManager.getBorder("TableHeader.cellBorder"));
// text zentiriert darstellen
setHorizontalAlignment(SwingConstants.CENTER);
// tooltip
setToolTipText("Colum No. "+(column+1));
// undurchsichtig damit man die hintergrundfarbe sieht.
setOpaque(true);
// je nach spalte die hintergrundfarbe setzen
switch(column) {
case 0: setBackground(Color.GREEN); break;
case 1: setBackground(Color.BLUE); break;
case 2: setBackground(Color.YELLOW); break;
case 3: setBackground(Color.RED); break;
default: setBackground(Color.LIGHT_GRAY);
}
return this;
}
}
</code=java>
[[Bild:JTableTutorial16.png]]
Hier wird zwar nur die Hintergrundfarbe geändert, Aber es gibt noch sehr viel mehr Möglichkeiten Die Spaltenköpfe zu manipulieren mithilfe des CellRenderers. Genau wie in Teil 3 beschrieben kann man auch andere komponenten die Darstellung der Header übernehmen lassen. Dazu muss man allerdings den CellRenderer anpassen (siehe auch Teil:

<code=java>class MyHeaderCellRenderer implements TableCellRenderer {

// einzig wichtige methode
public Component getTableCellRendererComponent(JTable table, Object value,
boolean isSelected, boolean hasFocus, int row, int column) {
JComponent c = null;
if(value instanceof String ) {
c = new JLabel((String)value);
((JLabel)c).setHorizontalAlignment(SwingConstants.CENTER);
} else if(value instanceof JCheckBox) {
c = (JCheckBox) value;
} else if(value instanceof JComboBox) {
c = (JComboBox) value;
} else {
c = new JLabel(value.toString());
((JLabel)c).setHorizontalAlignment(SwingConstants.CENTER);
}
c.setEnabled(true);
// normale schriftart
c.setFont(table.getFont());
// der standard rahmen für spaltenköpfe
c.setBorder(UIManager.getBorder("TableHeader.cellBorder"));
// text zentiriert darstellen
c.setToolTipText("Colum No. "+(column+1));
// undurchsichtig damit man die hintergrundfarbe sieht.
c.setOpaque(true);
// je nach spalte die hintergrundfarbe setzen
switch(column) {
case 0: c.setBackground(Color.GREEN); break;
case 1: c.setBackground(Color.BLUE); break;
case 2: c.setBackground(Color.YELLOW); break;
case 3: c.setBackground(Color.RED); break;
default: c.setBackground(Color.LIGHT_GRAY);
}
return c;
}
</code=java>
Jetzt gibt es aber das Problem dass man die Komponenten nicht ändern kann. Das ist auch etwas komplizierter, aber gute Tutorials,
die sich damit eingehender beschäftigen findet man z.B. hier:
http://www.objects.com.au/java/examples/swing/EditableTableHeader.do
Dort sind auch andere mehrere tiefergehende Beispiele zu JTableHeader und TableColumn.

==Ein Header für die Rows==
Standartmässig unterstützt das JTable nur einen Header, der über den Spalten steht.

Es ist aber kein grosses Problem eine Component - TableRowHeader - zu erstellen, welche dem JScrollPane übergeben werden kann auf dem das JTable sitzt.
Dazu wird die Methode JScrollPane#setRowHeader benutzt.

Da man es sich nicht leisten kann, bei jedem Aufruf von paint den gesammten Header neu darzustellen (sobald die Tabelle viele Einträge kriegt (1000 oder mehr), würde enorm viel Zeit in das Zeichnen investiert werden), zeichnet die der Header nur gerade die "Knöpfe", welche auch sichtbar sind.

Da die Spalten einer JTable nicht immer gleichhoch sein müssen, muss der Header jede Spalte einzeln beachten, und nicht einfach eine Rechnung machen, um herauszufinden wo gezeichnet, und wo nicht gezeichnet werden muss.

Das Demoframe. Man beachte, dass der Header dem ScrollPane übergeben werden muss.
<code=java>
public class JTableDemo {
public static void main( String[] args ) {
// Das JTable initialisieren
Vector title = new Vector();
title.add( "A" );
title.add( "B" );
title.add( "C" );
title.add( "D" );

JTable table = new JTable( createData(), title );

// Jede 10. Reihe wird vergrössert, um zu demonstrieren, wie sich der TableRowHeader anpasst.
int rows = table.getRowCount();
for( int i = 0; i < rows; i += 10 )
table.setRowHeight( i, 2*table.getRowHeight( i ) );

JFrame frame = new JFrame( "Demo" );
JScrollPane pane = new JScrollPane( table );

// mit diesem Befehl wird die Leiste links angesetzt.
pane.setRowHeader( new TableRowHeader( table, pane ) );

frame.getContentPane().add( pane );
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}

// Produziert genug Daten, dass man scrollen kann.
private static Vector createData(){
Vector data = new Vector();

for( int i = 0; i < 10000; i++ ){
Vector temp = new Vector();
for( int j = 0; j < 4; j++ )
temp.add( String.valueOf( Math.random() ) );

data.add( temp );
}

return data;
}
}
</code=java>
Der TableRowHeader. Eigentlich nichts weiter als eine ganz normale Component.
<code=java>
public class TableRowHeader extends JViewport implements AdjustmentListener{
private JTable table;
private Cell cell;

public TableRowHeader( JTable table, JScrollPane parent ) {
this.table = table;
cell = new Cell();
setView( new Dummy() );
setPreferredSize( new Dimension( 100, 0 ) );

parent.getVerticalScrollBar().addAdjustmentListener( this );
parent.getHorizontalScrollBar().addAdjustmentListener( this );
}

public void adjustmentValueChanged( AdjustmentEvent e ) {
repaint();
}

protected void paintComponent(Graphics g){
super.paintComponent( g );
Rectangle rec = TableRowHeader.this.getViewRect();

int y = 0;
int rows = table.getRowCount();
int index = 0;

if( rows == 0 )
return;

if( y + table.getRowHeight( 0 ) < rec.y ){
while( index < rows ){
int height = table.getRowHeight( index );

if( y + height < rec.y ){
y += height;
index++;
}
else
break;
}
}

int max = rec.y + rec.height;
int width = getWidth();

while( y < max && index < rows ){
int height = table.getRowHeight( index );
cell.set( index );
SwingUtilities.paintComponent( g, cell, this, 0, y-rec.y, width, height );

y += height;
index++;
}
}

// Nur eine leere Hülle, damit eine "Simulation" aufgebaut werden kann.
private static class Dummy extends JComponent{
public void paint( Graphics g ){
// do nothing
}

public void update( Graphics g ) {
// do nothing
}
}

// Stellt den Knopf für eine Reihe dar.
private class Cell extends JLabel {
public void set( int row ) {
setHorizontalAlignment( CENTER );
setForeground( TableRowHeader.this.getForeground() );
setBackground( TableRowHeader.this.getBackground() );
setFont( TableRowHeader.this.getFont() );
setText( "Row " + row );
setBorder( UIManager.getBorder( "TableHeader.cellBorder" ) );
}
}
}
</code=java>
Und daraus ergibt sich schliesslich dieses Bild:
[[Bild:JTableTutorial15.png]]
Selbstverständlich könnte man den Header ausbauen. So wäre vielleicht ein verschieben von Zeilen möglich... Ein Beispiel das die Möglichkeiten zeigt gibt es ja: den JTableHeader.

==Weitere Links==
[[JTable sortieren]]

[[Kategorie:Java]]
[[Kategorie:Tutorials (Java)]]
[[Kategorie:Swing]]
[[Kategorie:JTable]]

--[[Benutzer:Beni | Beni]] (© Benjamin Sigg, 04.06.2004, 20:30)

Reflection (Java)

2007-02-27T22:42:44Z

Beni:

Reflection in [[Java_(Programmiersprache)|Java]] ist eine Möglichkeit, Informationen über [[Klasse_(Java)|Klassen]], [[Methode_(Java)|Methoden]] und andere Sprachelemente zu erhalten, ohne diese Elemente während dem Programmieren zu kennen.

Eine kleine Auswahl von Informationen:
* Eine Liste aller Methoden einer Klasse
* Die Argumente einer Methode
* Die [[Modifier_(Java)|Sichtbarkeit]] einer [[Variable]]
* Die [[Annotation_(Java)|Annotationen]] eines Elementes

Diese Informationen können auch dazu verwendet werden, [[Objekt|Objekte]] einer bestimmten Klasse herzustellen, die Methoden des Objektes aufzurufen, oder Felder des Objektes abzuändern. Der Typ des Objektes muss wiederum nicht im vornherein bekannt sein.

= Arbeiten mit Reflection =
Um mit Reflection zu arbeiten, benötigt man ein [[Class_(Java_API)|Class]]-Objekt desjenigen Typen, mit dem man arbeiten will. Dieses Objekt erhält man üblicherweise auf einem der folgenden Wege:
* Mittels dem Syntax "x.class", wobei "x" ein beliebiger Typ sein kann.
<code=java>Class<?> classString = String.class;
Class<?> classInt = int.class;
Class<?> classFloatArray = float[].class;</code=java>
* Mit der Methode "getClass", welche jedes Objekt besitzt.
<code=java>Object unknown = ...
Class<?> classUnknown = unknown.getClass();</code=java>
* Über einen [[ClassLoader_(Java_API)|ClassLoader]], der diesen Typ kennt.
<code=java>ClassLoader loader = ClassLoader.getSystemClassLoader();
Class<?> classFrame = loader.loadClass( "javax.swing.JFrame" );</code=java>

== Zugriff auf Informationen ==
Die Klasse ''Class'' bietet verschiedene Methoden mehr über die dargestellte Klasse herauszufinden. Das geht von dem Namen der Klasse ("getName"), über die Klasse von der geerbt wurde ("getSuperclass") bis zu allen Methoden ("getDeclaredMethods"), [[Konstruktor_(Java)|Konstruktoren]] ("getConstructors") und Feldern ("getFields").

Über einzelne Felder, Methoden, ... lassen sich dann wiederum zusätzliche Informationen abrufen, z.B. die Argumente eines Konstruktors.

== Objekte generieren ==
Besitzt man erstmal die Klasse, will man meist auch ein Objekt dieser Klasse haben.

Dazu gibt es zwei einfache Wege:
* Direkt über die Methode "newInstance" von ''Class'' kann ein Objekt erzeugt werden. Das entspricht genau dem Verhalten, wie wenn man den [[Defaultkonstruktor_(Java)|Defaultkonstruktor]] aufrufen würde. Wenn kein solcher Konstruktor vorhanden ist, wird eine [[Exception_(Java)|Exception]] geworfen.
* Über ein [[Constructor_(Java)|Constructor]]-Objekt, indem die Methode "newInstance" mit passenden Argumenten aufgerufen wird.

Im folgenden Beispiel wird ein Punkt erzeugt, und ausgegeben:
<code=java>Class<?> point = Class.forName( "java.awt.Point" );
Constructor<?> constructor = point.getConstructor(
new Class[]{ int.class, int.class });
Object object = constructor.newInstance( new Object[]{ 45, 97 });

System.out.println( object );</code=java>

== Aufrufe tätigen ==
Mit Reflection kann man auch Methoden aufrufen oder Felder ändern.
* Anstelle des normalen Methodenaufrufes "object.x( y, z )" benutzt man das [[Method_(Java_API)|Method]]-Objekt, welches die Methode "x" darstellt, und ruft "x.invoke( object, x, y )" auf.
* Anstelle einer Zuweisung "object.x = y" benutzt man das [[Field_(Java_API)|Field]]-Objekt, welches "x" darstellt, und ruft "x.set( object, y )" auf.

= Beispiele =
== Restriktionen aushebeln ==
Das folgende Beispiel benutzt Reflection um auf den, eigentlich geschützten, char-[[Array]] eines [[String_(Java_API)|Strings]] zuzugreiffen.
<code=java>
import java.lang.reflect.Field;

public class Evil {
public static void main( String[] args ) throws Exception{
// Die Ausgabe dieses Programmes ist...
System.out.println( "Hallo Welt" );
// ... jedenfalls nicht "Hallo Welt"
}

static{
try{
// Repräsentation der String-Klasse abrufen
Class<String> clazz = String.class;

String object = "Hallo Welt";
String text = "Ich bin böse!";

// Zugriff auf die Felder "value" und "count" erlangen
Field value = clazz.getDeclaredField( "value" );
Field count = clazz.getDeclaredField( "count" );

// Die Sichtbarkeit der Felder von private auf public erhöhen
value.setAccessible( true );
count.setAccessible( true );

// Den Feldern neue Werte zuweisen
value.set( object, text.toCharArray() );
count.setInt( object, text.length() );
}
catch( Exception ex ){
ex.printStackTrace();
}
}
}
</code=java>

== Objekt herstellen und Methoden aufrufen ==

Dieses Beispiel zeigt, wie eine Klasse, von der man nur den Namen kennt, und die garantiert noch nicht im System existiert, geladen wird. Danach wird eine [[Instanz]] dieser Klasse angelegt, und eine Methode aufgerufen.
<code=java>package hidden;

import java.lang.reflect.Method;

public class Hidden {
public static void main( String[] args ) throws Exception{
Loader loader = new Loader();
Class<?> clazz = loader.loadClass( "hidden.Riddle" );

Object object = clazz.newInstance();
Method run = clazz.getMethod( "run", new Class[0] );
run.invoke( object, new Object[0] );
}

private static class Loader extends ClassLoader{
@Override
protected Class<?> findClass( String name ) throws ClassNotFoundException {
if( name.equals( "hidden.Riddle" )){
return defineClass( "hidden.Riddle", CODE, 0, CODE.length );
}
else
return super.findClass( name );
}
}

public static final byte[] CODE = {
-54, -2, -70, -66, 0, 0, 0, 49, 0, 78, 7,
0, 2, 1, 0, 13, 104, 105, 100, 100, 101, 110,
47, 82, 105, 100, 100, 108, 101, 7, 0, 4, 1,
0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103,
47, 79, 98, 106, 101, 99, 116, 1, 0, 5, 118,
97, 108, 117, 101, 1, 0, 1, 73, 1, 0, 6,
60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41,
86, 1, 0, 4, 67, 111, 100, 101, 10, 0, 3,
0, 11, 12, 0, 7, 0, 8, 10, 0, 13, 0,
15, 7, 0, 14, 1, 0, 14, 106, 97, 118, 97,
47, 108, 97, 110, 103, 47, 77, 97, 116, 104, 12,
0, 16, 0, 17, 1, 0, 6, 114, 97, 110, 100,
111, 109, 1, 0, 3, 40, 41, 68, 6, 64, 89,
0, 0, 0, 0, 0, 0, 9, 0, 1, 0, 21,
12, 0, 5, 0, 6, 1, 0, 15, 76, 105, 110,
101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108,
101, 1, 0, 18, 76, 111, 99, 97, 108, 86, 97,
114, 105, 97, 98, 108, 101, 84, 97, 98, 108, 101,
1, 0, 4, 116, 104, 105, 115, 1, 0, 15, 76,
104, 105, 100, 100, 101, 110, 47, 82, 105, 100, 100,
108, 101, 59, 1, 0, 3, 114, 117, 110, 7, 0,
28, 1, 0, 17, 106, 97, 118, 97, 47, 117, 116,
105, 108, 47, 83, 99, 97, 110, 110, 101, 114, 9,
0, 30, 0, 32, 7, 0, 31, 1, 0, 16, 106,
97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 121,
115, 116, 101, 109, 12, 0, 33, 0, 34, 1, 0,
2, 105, 110, 1, 0, 21, 76, 106, 97, 118, 97,
47, 105, 111, 47, 73, 110, 112, 117, 116, 83, 116,
114, 101, 97, 109, 59, 10, 0, 27, 0, 36, 12,
0, 7, 0, 37, 1, 0, 24, 40, 76, 106, 97,
118, 97, 47, 105, 111, 47, 73, 110, 112, 117, 116,
83, 116, 114, 101, 97, 109, 59, 41, 86, 9, 0,
30, 0, 39, 12, 0, 40, 0, 41, 1, 0, 3,
111, 117, 116, 1, 0, 21, 76, 106, 97, 118, 97,
47, 105, 111, 47, 80, 114, 105, 110, 116, 83, 116,
114, 101, 97, 109, 59, 8, 0, 43, 1, 0, 38,
71, 105, 98, 32, 101, 105, 110, 101, 32, 90, 97,
104, 108, 32, 122, 119, 105, 115, 99, 104, 101, 110,
32, 48, 32, 117, 110, 100, 32, 49, 48, 48, 32,
101, 105, 110, 58, 32, 10, 0, 45, 0, 47, 7,
0, 46, 1, 0, 19, 106, 97, 118, 97, 47, 105,
111, 47, 80, 114, 105, 110, 116, 83, 116, 114, 101,
97, 109, 12, 0, 48, 0, 49, 1, 0, 5, 112,
114, 105, 110, 116, 1, 0, 21, 40, 76, 106, 97,
118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114,
105, 110, 103, 59, 41, 86, 10, 0, 27, 0, 51,
12, 0, 52, 0, 53, 1, 0, 10, 104, 97, 115,
78, 101, 120, 116, 73, 110, 116, 1, 0, 3, 40,
41, 90, 10, 0, 27, 0, 55, 12, 0, 56, 0,
57, 1, 0, 7, 110, 101, 120, 116, 73, 110, 116,
1, 0, 3, 40, 41, 73, 8, 0, 59, 1, 0,
7, 82, 105, 99, 104, 116, 105, 103, 10, 0, 45,
0, 61, 12, 0, 62, 0, 49, 1, 0, 7, 112,
114, 105, 110, 116, 108, 110, 8, 0, 64, 1, 0,
16, 70, 97, 108, 115, 99, 104, 44, 32, 122, 117,
32, 107, 108, 101, 105, 110, 8, 0, 66, 1, 0,
16, 70, 97, 108, 115, 99, 104, 44, 32, 122, 117,
32, 103, 114, 111, 115, 115, 8, 0, 68, 1, 0,
24, 68, 97, 115, 32, 115, 111, 108, 108, 32, 101,
105, 110, 101, 32, 90, 97, 104, 108, 32, 115, 101,
105, 110, 63, 10, 0, 27, 0, 70, 12, 0, 71,
0, 72, 1, 0, 4, 110, 101, 120, 116, 1, 0,
20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97,
110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1,
0, 1, 115, 1, 0, 19, 76, 106, 97, 118, 97,
47, 117, 116, 105, 108, 47, 83, 99, 97, 110, 110,
101, 114, 59, 1, 0, 5, 99, 104, 101, 99, 107,
1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105,
108, 101, 1, 0, 11, 82, 105, 100, 100, 108, 101,
46, 106, 97, 118, 97, 0, 33, 0, 1, 0, 3,
0, 0, 0, 1, 0, 2, 0, 5, 0, 6, 0,
0, 0, 2, 0, 1, 0, 7, 0, 8, 0, 1,
0, 9, 0, 0, 0, 67, 0, 5, 0, 1, 0,
0, 0, 17, 42, -73, 0, 10, 42, -72, 0, 12,
20, 0, 18, 107, -114, -75, 0, 20, -79, 0, 0,
0, 2, 0, 22, 0, 0, 0, 14, 0, 3, 0,
0, 0, 5, 0, 4, 0, 6, 0, 16, 0, 5,
0, 23, 0, 0, 0, 12, 0, 1, 0, 0, 0,
17, 0, 24, 0, 25, 0, 0, 0, 1, 0, 26,
0, 8, 0, 1, 0, 9, 0, 0, 0, -33, 0,
3, 0, 3, 0, 0, 0, 105, -69, 0, 27, 89,
-78, 0, 29, -73, 0, 35, 76, -78, 0, 38, 18,
42, -74, 0, 44, 43, -74, 0, 50, -103, 0, 65,
43, -74, 0, 54, 61, 28, 42, -76, 0, 20, -96,
0, 14, -78, 0, 38, 18, 58, -74, 0, 60, -89,
0, 57, 28, 42, -76, 0, 20, -94, 0, 14, -78,
0, 38, 18, 63, -74, 0, 60, -89, -1, -55, 28,
42, -76, 0, 20, -92, -1, -63, -78, 0, 38, 18,
65, -74, 0, 60, -89, -1, -74, -78, 0, 38, 18,
67, -74, 0, 60, 43, -74, 0, 69, 87, -89, -1,
-90, -79, 0, 0, 0, 2, 0, 22, 0, 0, 0,
62, 0, 15, 0, 0, 0, 9, 0, 11, 0, 11,
0, 19, 0, 12, 0, 26, 0, 13, 0, 31, 0,
14, 0, 39, 0, 15, 0, 47, 0, 16, 0, 50,
0, 18, 0, 58, 0, 19, 0, 69, 0, 21, 0,
77, 0, 22, 0, 88, 0, 26, 0, 96, 0, 27,
0, 101, 0, 30, 0, 104, 0, 31, 0, 23, 0,
0, 0, 32, 0, 3, 0, 0, 0, 105, 0, 24,
0, 25, 0, 0, 0, 11, 0, 94, 0, 73, 0,
74, 0, 1, 0, 31, 0, 57, 0, 75, 0, 6,
0, 2, 0, 1, 0, 76, 0, 0, 0, 2, 0, 77 };
}
</code=java>

[[Kategorie:Java]]

Array

2007-02-27T21:03:54Z

Beni: Fehler im Beispielcode korrigiert

Ein Array ist ein Konstrukt in dem mehrere Objekte eins Datentyps hintereinander aufgereiht stehen. (Es wird hier immer von Objekten geredet egal ob es in der Programmiersprache Objekte gibt oder nicht)
Diese Konstrukte werden oft verwendet wenn man eine große Ansammlung von gleichen Daten eines Objekts hat, durch die Verwendung von Arrays muss man nicht viele Variablen anlegen und hat so alles übersichtlicher. In den meisten Sprachen haben Arrays jedoch den Nachteil das sie statisch sind, d.h. man legt einmal ihre Größe fest und danach kann man es nicht mehr ändern, will man mehr Objekte ablegen dann muss man sich einen neuen Array anlegen. Daher haben Arrays in diesen Sprachen aber auch einen Vorteil gegen über den dynamischen Strukturen wie Listen, da sie eine fest definierte Größe haben kann man sie über einen Index anlegen und so über den Index darauf zugreifen, dies ist meistens eine schnellere Möglichkeit als bei anderen Strukturen möglich ist.

Für die Erzeugung von Arrays gibt es unterschiedliche Wege, jedoch haben sie meistens gemeinsam das eckige Klammern([]) einen Array symbolisieren. So wird in C und C++ ein Array mit <code>typ name[];</code> deklariert und die Initialisierung kann auf zwei unterschiedliche Wege erfolgen, <code> name = typ[anzahl]</code> oder <code>name = malloc(sizeof(typ)*anzahl)</code>, bzw. <code>name = new typ[anzahl]</code>. Der Unterschied zwischen den beiden Arten ist, dass bei der ersten Möglichkeit der Speicher vom Compiler festgelegt wird und so nicht mehr freigegeben werden muss und bei der zweiten Art zur Laufzeit angelegt wird, welchen man dann auch selbst freigeben muss. Will nab in C# oder Java einen Array anlegen geschied dies mit <code>typ[] name;</code> und die Initialisierung erfolgt über <code>name = new typ[anzahl]()</code>. In Java ist es auch möglich die Arrays wie in C++ anzulegen.

Bei der Sprache C# wurde noch ein weiterer Arraytyp eingeführt. Hier sind in jeder Zeile immer gleich viele Objekte, diese werden mit <code>typ[,] name = new typ[anzahl,anzahl]();</code> angelegt. In allen anderen Sprachen lassen sich Arrays auch mit mehreren Dimensionen anlegen, hierzu muss nur ein weiteres Klammerpaar hinzugefügt werden. Diese neuen Arrays in dem bestehenden Array müssen auch nicht gleich initialisiert werden sondern können auch erst später angelegt werden um so besser auf die Gegebenheiten angepasst zu sein. Daher ist es möglich das eine Zeile mal 4 Objekte enhält und eine mal garkeine, dies muss dann im Programm alles gesondert behandelt werden.

Neben der Möglichkeit des Anlegen von leeren Arrays ist es auch Möglich Arrays gleich mit vorhandenen Daten anzulegen. In den meisten Sprachen ist dies einfach möglich indem man nach der normalen Syntax für die Initialisierung des Arrays gleich in geschweiften Klammern die Objekte durch Kommas getrennt einfügt, z.B. in Java:
<code=java>
String s = new String[]{"Hallo"," ","Hallo","!!!"};
</code=java>
In einigen Sprachen ist es auch möglich bei der Deklaration der Variablen gleich die Werte zuzuweisen ohne die übliche Initialisierungssyntax, z.B. in Java:
<code=java>
String[] s = {"Hallo"," ","Hallo","!!!"};
</code=java>

[[Kategorie:Programmiersprachen]]

Annotation (Java)

2007-02-27T18:29:21Z

Beni: Die Seite wurde neu angelegt: In Java kann mit einer ''Annotation'' Metainformation in den Quellcode eines Programmes eingefügt werden. Annotation können von untersc...

In [[Java_(Programmiersprache)|Java]] kann mit einer ''Annotation'' Metainformation in den Quellcode eines Programmes eingefügt werden.

Annotation können von unterschiedlichsten Tools ausgelesen werden. So kann bereits ein [[Compiler]] einige Annotationen verwenden, z.B. um Warnungen zu unterdrücken oder zu generieren.

= Eigene Annotationen =
Es ist möglich, eigene Annotationen zu schreiben. Der Syntax einer Annotation gleicht dem Syntax eines [[Interface_(Java)|Interfaces]]. Wie ein Interface muss auch eine Annotation in einer eigenen Java-Datei gespeichert werden.

== Annotation definieren ==
Verglichen mit einem Interface hat eine Annotation folgende Unterschiede:
* Dem Schlüsselwort "interface" wird ein @ vorangestellt.
* Lediglich Methoden ohne Argumente und ohne [[Exception_(Java)|throws-Klauseln]] sind erlaubt
* Rückgabewert der Methoden dürfen alle [[Primitiv_(Java)|primitiven Datentypen]], [[String_(Java_API)|String]], [[Class_(Java_API)|Class]], [[Enumeration_(Java)|Enumerationen]], Annotationen und [[Array_(Java)|Arrays]] der eben gennanten sein.
* Methoden können einen "default"-Wert besitzen.

Ein Beispiel:
<code=java>
@Retention( RetentionPolicy.RUNTIME )
@Target( ElementType.METHOD )
public @interface IntegerSetter {
int min();
int max();
int start() default 1;
}
</code=java>
Die hier definierte Annotation ''IntegerSetter'' besitzt drei Elemente: "min", "max" und "start". Alle drei sind vom Typ "int". Das Element "start" besitzt einen Default-Wert von 1.

''Retention'' und ''Target'' sind andere Annotationen, welche eine Aussage über den Gültigkeitsbereich der Annotation ''IntegerSetter'' machen. Hier wird gesagt, dass die Annotation ''IntegerSetter'' zur Laufzeit sichtbar ist, und nur für Methoden verwenden werden kann.

== Annotation anwenden ==
Annotationen werden vor das zu markierende Element geschrieben, einfach indem nach einem @ der Name der Annotation ausgeschrieben wird. Falls die Annotation Elemente besitzt, müssen die Elemente noch gesetzt werden. Dazu schreibt man, in runden Klammern, "Element = Wert"-Paare.

Beispiel:
<code=java>public class Point {
private int x, y;

@IntegerSetter( min=0, max=5 )
public void setX( int x ){
this.x = x;
}

@IntegerSetter( min=0, max=20, start=5 )
public void setY( int y ){
this.y = y;
}

public static void main( String[] args ) throws Exception{
list( Point.class );
}
}</code=java>
Hier werden die beiden Methoden "setX" und "setY" mit ''IntegerSetter'' markiert. Da das Element "start" einen Default-Wert besitzt, ist es nicht notwendig, das Element jedesmal neu zu definieren.

== Annotation zur Laufzeit auslesen ==
Selbstgeschriebene Annotation werden oft zur Laufzeit benötigt. Mit [[Reflection_(Java)|Reflection]] können die Annotation ausgelesen werden. Die meisten Reflection-Klassen bieten eine entsprechende [[Methode_(Java)|Methode]] "getAnnotation(s)"

Beispiel:
<code=java> public static void main( String[] args ) throws Exception{
list( Point.class );
}

public static void list( Class<?> clazz ) throws Exception{
for( Method method : clazz.getMethods() ){
IntegerSetter value = method.getAnnotation(
IntegerSetter.class );
if( value != null ){
System.out.printf(
"%s: min=%d, max=%d, start=%d\n",
method.getName(), value.min(),
value.max(), value.start() );
}
}
}</code=java>
Die Ausgabe dieses Programmes ist:
<pre>setX: min=0, max=5, start=1
setY: min=0, max=20, start=5
</pre>

Wie man an dem Beispiel sieht, können Annotationen wie normale Objekte behandelt werden.

= Vordefinierte Annotationen =
Es gibt bereits einige vordefinierte Annotationen, dieser Abschnitt präsentiert eine Auswahl aus verschiedenen [[Package_(Java)|Packages]].

== java.lang ==
{| width="100%" align="left" border="1"
! width="20%" | Name
! width="80%" | Zweck
|-
| @Deprecated
| Markiert Elemente (Klassen, Methoden, ...), die veraltet sind, oder aus anderen Gründen nicht benutzt werden sollten. Siehe auch [[Deprecated]].
|-
| @SuppressWarnings
| Veranlasst den [[Compiler]] einen oder mehrere Typen Warnungen nicht zu melden.
|-
| @Override
| Markiert eine Methode, die eine andere Methode [[Überschreiben_(Java)|überschreibt]]. Ein Compiler kann dank dieser Annotation sicher sein, dass der Programmierer eine Methode absichtlich überschrieben hat.
|}

== java.lang.annotation ==
{| width="100%" align="left" border="1"
! width="20%" | Name
! width="80%" | Zweck
|-
| @Retention
| Regelt die Sichtbarkeit einer Annotation. Dazu wird eine ''RetentionPolicy'' gesetzt.
* '''Source''': Die Annotation ist nur im Quellcode sichtbar.
* '''Class''': Die Annotation ist auch in der Class-Datei, also im Kompilat, vorhanden.
* '''Runtime''': Die Annotation wird während der Laufzeit von der [[JVM]] geladen. Nur mit dieser Policy kann eine Annotation per Reflection ausgelesen werden.
|-
| @Target
| Wird ebenfalls für Annotationen angewandt. Das ''@Target'' sagt dem Compiler, welche Elemente eine Annotation markieren darf. ''@Target'' erwartet ein Array von ''ElementType''.

Beispiel: Eine Annotation die für Methoden und Typen verwendet werden kann:
<code=java>@Target( {ElementType.TYPE, ElementType.METHOD} )
public @interface Something{
...
}</code=java>

|-
| @Documented
| Wird für Annotationen verwendet, die von [[Javadoc_(Java)|Javadoc]], und ähnlichen Programmen, dokumentiert werden sollen. Das ist insbesondere wünschenswert für Annotationen, deren Vorhandensein einen direkten Einfluss auf das Programm haben.
|-
| @Inherited
| Markiert eine Annotation, welche vererbt werden soll. Damit ist gemeint: wenn die Annotation eine [[Klasse_(Java)|Klasse]] markiert, sind automatisch alle Unterklassen ebenfalls markiert.
|}

[[Kategorie:Java]]

Methode (Java)

2007-02-27T10:33:27Z

Beni: /* finale Methoden */

In [[Java_(Programmiersprache)|Java]] ist eine Methode eine sequenzielle Sammlung von ausführbaren Befehlen.

Methoden müssen stets in einer [[Klasse_(Java)|Klasse]] oder einem [[Interface_(Java)|Interface]] definiert werden. Zur [[Laufzeit]] gehört eine normale Methode dann zu einem [[Objekt]], und hat lesenden und schreibenden Zugriff auf das Objekt. Ausnahme sind sog. "statische Methoden" welche zu keinem Objekt gehören.

= Syntax =
Eine Methode besteht aus einem Kopf und einem Rumpf. Der Kopf stellt die Schnittstelle zur Aussenwelt dar, der Rumpf hingegen ist der Code, der tatsächlich ausgeführt wird.
<code=java>Kopf{
Rumpf
}</code=java>
Der Kopf ist stets vor dem Rumpf, der Rumpf stets durch geschweifte Klammern gekennzeichnet.

== Methodenkopf ==
Der Kopf besteht, von links nach rechts, aus folgenden Elementen:
* verschiedene Modifier (optional)
* Definitionen lokaler [[Generics_(Java)|Generics]] (optional)
* Typ der Rückgabe (erforderlich)
* Name der Methode (erforderlich)
* Liste der Argumente (erforderlich)
* Liste von Ausnahmen (optional)

Ein Beispiel:
<code=java>public static <X> X getRandom( List<X> list ) throws ListEmptyException;</code=java>

Die Modifier sind hier "public static", es gibt ein Generic "X", die Rückgabe der Methode ist ein [[Objekt]] des Types "X", die Methode heisst "getRandom", erwartet wird ein Argument "list" vom Typ "List<X>", und die Methode kann eine "ListEmptyException" werfen, falls die Liste leer ist.

=== Modifier ===
Als Modifier sind die bekannten [[Modifier_(Java)|Sichtbarkeits-Modifier]] "public", "protected" und "private" erlaubt.
Die Effekte von "static", "final" und "abstract" sind weiter unten in diesem Artikel erklärt.
Mit "synchronized" kann dem aufrufenden [[Thread_(Java)|Thread]] exklusiver Zugriff auf das Objekt, auf dem die Methode aufsetzt, gegeben werden.

=== Lokale Generics ===
In spitzen Klammern geschrieben, und mit Komma getrennt, können beliebige [[Generics_(Java)|Generics]] definiert werden. Diese Generics können dann in der gesammten Methode verwendet werden.

=== Rückgabetypen ===
Eine Methode kann einen Wert an den Aufrufer zurückgeben. Dabei ist jeder Typ erlaubt, egal ob Klasse, Generic oder [[Primitiv_(Java)|primitiver Datentyp]].
Falls eine Methode kein Rückgabe hat, wird dies mit dem Schlüsselwort "void" angezeigt:
<code=java>public void hide();</code=java>

=== Methodennamen ===
Der Name einer Methode muss mit einem Buchstaben beginnen, danach können Buchstaben, Ziffern und einige Sonderzeichen folgen.

Üblicherweise beginnen Namen mit einem Kleinbuchstaben, und sind Verben.

=== Argumente ===
Die Argumente sind [[Variable|Variablen]] die der Aufrufer der Methode ausfüllen muss. Die Argumente werden durch eine Komma-getrennte Liste von "Typ"-"Namen"-Paaren angegeben. Diese Argument-Liste wird in runden Klammern geschrieben.

Falls eine Methode keine Argumente benötigt, so schreibt man einfach "()" als Argumentliste.

Argumente werden stets bei [[call-by-value]] übergeben.

Beispiele:
Eine Methode die zwei int-Argumente benötigt:
<code=java>public int max( int a, int b );</code=java>

Eine Methode ohne Argumente:
<code=java>public int max();</code=java>

=== Ausnahmen ===
Methoden können [[Exception_(Java)|Exceptions]] werfen. Die checked-Exceptions müssen aufgelistet werden, dazu wird das Schlüsselwort "throws" verwendet.

Beispiel: Eine Methode die zwei unterschiedliche Exceptions werfen kann:
<code=java>public void writeFile( String path )
throws NoSuchFileException, ReadOnlyFileException;</code=java>

== Methodenrumpf ==
=== Variablen ===
Innerhalb des Rumpfes kann man jederzeit neue Variablen definieren, und ihnen Werte zuweisen.
<code=java>// neue Variablen
int x;
int y = 4;

// Zuweisung
x = y + 1;</code=java>
Die Variablen sind ausserhalb der Methode nicht sichtbar.
=== Verzweigungen ===
Mit [[if_(Java)|if-else]] können Verzweigungen in den ausgeführten Code eingebaut werden.
Beispiel: hier wird der Variable "z" stehts der kleinere Wert der beiden Variablen "x" und "y" zugewiesen:
<code=java>if( x < y ){
z = x;
}
else{
z = y;
}</code=java>
=== Schleifen ===
Die verschiedenen [[Schleife|Schleifen]] von Java können benutzt werden. Dies sind [[While-Schleife|while]], [[do-while_(Java)|do-while]], [[For-Schleife|for]] und [[For each-Schleife|for-each]].
=== Ausnahmen ===
Sollte eine Ausnahme, ein Ereignis, das die korrekte Beendingung der Methode verhindert, auftreten, so kann eine Exception geworfen werden. Hierzu wird das Schlüsselwort "throw" benutzt:
<code=java>if( !file.exists() )
throw new NoSuchFileException( file.getPath() );
</code=java>
=== Klassen / Interfaces ===
Innerhalb einer Methode können auch ganze Klassen oder Interfaces definiert werden. Mit Ausnahme der [[anonyme_Klasse_(Java)|anonymen Klassen]] ist es aber höchst ungewöhnlich, so etwas zu tun.
=== Rücksprung ===
Sofern ein Rückgabewert definiert wurde (also nicht "void" ist), und die Methode keine [[Endlosschleife]] besitzt, muss mit "return" ein Wert an den Aufrufer zurückgegeben werden.

Beispiel: hier wird der Wert der Variable "x" zurückgegeben:
<code=java>return x;</code=java>

Eine Methode kann auch mehrere return-Befehle besitzen, allerdings wird immer nur einer ausgeführt. Der return-Befehl ist stets der letzte Befehl der ausgeführt wird, sämtliche nachfolgenden Befehle werden ignoriert.

Falls der Rückgabetyp "void" ist, kann man return einfach verwenden, um aus der Methode zu springen:
<code=java>return;</code=java>

== Aufruf ==
Beim Aufruf einer Methode müssen alle Argumente der Methode ausgefüllt werden. Lokale Generics werden vom Compiler automatisch berechnet, und der Rückgabewert kann ignoriert werden.

Ein Aufruf kann z.B. so aussehen:
<code=java>int summe = plus( 23, 47 );</code=java>
Hier wird die Methode "plus" mit den Argumenten "32" und "47" aufgerufen. Die Rückgabe von "plus" wird in der Variable "summe" gespeichert.

Da normale Methoden zu einem Objekt gehören, muss man oft das Objekt angeben, auf dem die Methode laufen wird:
<code=java>File file = ... // Eine Datei
String name = file.getName();</code=java>
Hier wird die Methode "getName" eines ''File''-Objektes aufgerufen.

= Spezielle Typen =
Nebst den "normalen Methoden" gibt es einige Methoden die sich etwas speziell verhalten.

== statische Methoden ==
Statische Methoden, mit dem Modifier "static" markiert, gehören nicht zu einem Objekt, sondern zu einer Klasse. Diese Methoden haben deshalb keinen direkten Zugriff auf irgendwelche Variablen eines Objektes, da für sie schlicht kein Objekt existiert. Sie haben aber immernoch privilegierte Zugriffsrechte für alle Objekte, deren Typ der Klasse entspricht, in der die statische Methode definiert wurde.

Beispiel, folgendes funktioniert nicht:
<code=java>public class Point{
private int x, y;

public static String asString(){
// FEHLER: x und y gehören zu einem Objekt, die
// statische Methode hingegen zu einer Klasse
return "X=" + x + ", Y=" + y;
}
}</code=java>

Aber eine statische Methode kann sogar private Felder lesen:
<code=java>public class Point{
private int x, y;

public static Point max( Point a, Point b ){
Point result = new Point();

// Zugriff auf die privaten Felder x und y:
result.x = a.x > b.x ? a.x : b.x;
result.y = a.y > b.y ? a.y : b.y;

return result;
}
}</code=java>

Da statische Methoden zu Klassen gehören, müssen sie anders aufgerufen werden, als normale Methoden:
<code=java>Point a = ...
Point b = ...

// Aufruf einer normalen Methode: das Objekt wird angesprochen
int x = a.getX();

// Aufruf einer statischen Methode: die Klasse wird angesprochen
Point m = Point.max( a, b );</code=java>

== abstrakte Methoden ==
Als abstrakte Methoden bezeichnet man Methoden, die keinen Rumpf besitzen (anstelle des Rumpfes wird ein Semikolon geschrieben). Abstrakte Methoden können nur in [[abstrakte_Klasse_(Java)|abstrakten Klassen]] oder [[Interface_(Java)|Interfaces]] vorkommen. Sie müssen stets von einer erbenden Klasse Implementiert werden.
<code=java>public abstract int operation( int a, int b );</code=java>
Abstrakte Methoden können nicht statisch oder private sein, da sie sonst nicht überschreibbar wären.

== finale Methoden ==
Finale Methoden lassen sich nicht überschreiben. Das kann theoretisch Geschwindigkeitsvorteile ergeben, macht aber die Verwendung der Klasse, in der die finale Methode ist, mühselig.

Das Schlüsselwort "final" wird verwendet, um eine finale Methode zu definieren:

<code=java>public final double min( double a, double b ){
if( a < b )
return a;
else
return b;
}</code=java>

[[Kategorie:Java]]

API Dokumentation (Java)

2007-02-26T21:35:35Z

Beni: Links korrigiert

Das Java Runtime Environment (kurz [[JRE]]) bietet viele tausend [[Klasse_(Java)|Klassen]], und nochmehr [[Methode_(Java)|Methoden]]. Es ist nur schwer möglich, den Überblick über soviele Informationen zu behalten, wenn man nur den Quellcode zur verfügung hat.

Deshalb wurde die "API Dokumentation" geschrieben.

Die API Dokumentation, kurz API, kann man bei Sun [http://java.sun.com/] herunterladen, für Java 1.5 gibt es auch eine Onlineversion [http://java.sun.com/j2se/1.5.0/docs/api/index.html].

== Aufbau der API Dokumentation ==
Die API besteht aus 3 Fenstern:
* Oben links sind sämtliche [[Package_(Java)|Packages]] aufgeführt
* Unten links sind die [[Klasse_(Java)|Klassen]] des aktuell gewählten Packages aufgelistet
* Rechts ist ein Multifunktionsfenster

Zusätzlich gibt es einige Demonstrationen und Tutorials [http://java.sun.com/j2se/1.5.0/docs/#demos] in der API Dokumentation zu finden.

== Das Multifunktionsfenster ==
Das Fenster auf der rechten Seite der API hat 8 Funktionen, welche in den Leisten oben und unten ausgewählt werden können. Die Funktionen sind:
===Overview===
Eine Liste aller verfübgarer Packages. Auf der linken Seite der Tabelle befindet sich der Name des Packages, rechts eine Beschreibung, für was die Klassen des Packages verwendet werden.

===Package===
Eine Liste aller Elemente welche in einem Package sind. Für jedes Element gibt es eine kurze Beschreibung, wofür es verwendet wird.
Elemente können [[Interface_(Java)|Interfaces]], [[Klasse_(Java)|Klassen]], [[Exception_(Java)|Exceptions]], [[Error_(Java)|Errors]], [[Enum_(Java)|Enumerationen]] oder [[Annotation_(Java)|Annotations]] sein.

===Class===
Diese Ansicht wird verwendet um Elemente eines Packages genauer zu beschreiben. Hauptsächlich sind dies Klassen, aber auch Interfaces, Enumerationen o.ä. wird hier angezeigt.

Diese Ansicht besteht aus 3 Sektionen:
* '''Beschreibung''': Eine Beschreibung des aktuellen Elementes. Dies beinhaltet die Vererbungshierarchie und einen längeren Text.
* '''Zusammenfassung''': Eine Liste aller [[Innere_Klasse_(Java)|inneren Klassen]], [[Variable|Variablen]], [[Konstruktor_(Java)|Konstruktoren]] und Methoden.
* '''Details''': Für jeden Eintrag in der Zusammenfassung gibt es noch eine detailierte Beschreibung.

===Use===
Use zeigt an, wo ein Element (Klasse, Interface, Enumeration, etc.) benutzt wird. Sortiert nach Packages wird gezeigt, wer von dem Element erbt, wer das Element als Variable benutzt, wo das Element als Argument oder Rückgabewert einer Methode vorkommt, etc.

===Tree===
Hier wird die komplette Vererbungshierarchie entweder aller Klassen überhaupt, oder aller Klasen eines Packages, angezeigt.

===Deprecated===
Eine Liste aller Klassen, Interfaces, Methoden, etc. welche [[Deprecated]] (veraltet) sind.

===Index===
Index ist eine alphabetische Liste aller Elemente welche in der API Dokumentation gefunden werden können.

===Help===
Eine Hilfe welche dasselbe erzählt, was auch auf dieser Page steht.

[[Kategorie:Java]]

TableRowSorter (Java API)

2007-02-25T13:09:26Z

Beni:

Der ''TableRowSorter'' ist ein [[RowSorter_(Java_API)|RowSorter]] der speziell für die Verwendung mit einem [[JTable_(Java_API)|JTable]] geschrieben wurde.

Üblicherweise wird die Methode '''getColumnClass''' vom zu sortierenden [[TableModel_(Java_API)|TableModel]] benutzt, um herauszufinden, welcher Typ Objekte in einer Spalte angezeigt werden. Besitzt der Typ eine natürliche Sortierung (durch das [[Interface_(Java)|Interface]] [[Comparable_(Java_API)|Comparable]] angezeigt), so wird diese Sortierung verwendet. Andernfalls werden die Zellen in [[String_(Java_API)|Strings]] umgewandelt, und alphabetisch geordnet.

Man kann allerdings mit der Methode '''setComparator''' für jede einzelne Spalte angeben, welcher [[Comparator_(Java_API)|Comparator]] verwendet werden soll, um zwei Zellen zu vergleichen.

Zusätzlich kann man einen ''TableStringConverter'' setzen, der jede Zelle der Tabelle in einen ''String'' umwandeln kann, dabei aber nicht denselben ''String'' produzieren muss, wie in der ''JTable'' angezeigt wird.

[[Kategorie:Java_API]]

JTableHeader (Java API)

2007-02-25T13:09:21Z

Beni:

Der ''JTableHeader'' ist eine [[Component_(Java_API)|Component]] die oberhalb eines [[JTable_(Java_API)|JTables]] angezeigt wird. Für jede Spalte der Tabelle zeichnet der ''JTableHeader'' einen Titel. Diesen Titel kann der Benutzer mit der Maus ergreiffe, hin- und herschieben, oder die Breite der Spalte verändern.

Wie die Titel normalerweise gezeichnet werden, kann über die [[Methode_(Java)|Methode]] '''setDefaultRenderer''', die einen [[TableCellRenderer_(Java_API)|TableCellRenderer]] erwartet, bestimmt werden. Der Renderer zeichnet jeden einzelnen Titel unabhängig von den anderen Titeln.

Ist mehr Kontrolle erfoderlich, kann auch der Header-Renderer der Spalte direkt gesetzt werden. Dazu wird die Methode '''setHeaderRenderer''' der [[TableColumn_(Java_API)|TableColumn]] benutzt, deren Titel gesetzt werden soll.

[[Kategorie:Java_API]]

RowSorter (Java API)

2007-02-25T13:09:17Z

Beni:

Der ''RowSorter'' wird verwendet, um irgendeine graphische Tabelle (oder Liste) zu sortieren. Der ''RowSorter'' wird derzeit hauptsächlich von der [[JTable_(Java_API)|JTable]] verwendet, um die Zeilen nach einer oder mehreren Spalten zu sortieren, und um Zeilen auszublenden. Entsprechend wird in diesem Artikel immer davon ausgegangen, dass eine ''JTable'' involviert ist.
Der ''RowSorter'' ändert nicht direkt etwas an der ''JTable'' oder am [[TableModel_(Java_API)|TableModel]], er bietet nur Informationen, welche Zeile mit welcher vertauscht werden soll.

Bevor man einen ''RowSorter'' implementiert, sollte man einen Blick auf die schon existierende Implementation [[TableRowSorter_(Java_API)|TableRowSorter]] werfen. In den meisten Fällen werden alle benötigten Funktionen schon vom ''TableRowSorter'' abgedeckt.

Die [[Methode_(Java)|Methoden]] des ''RowSorters'' lassen sich grob in 3 Gruppen gliedern:
= Konvertierung =
* Die Methode '''convertRowIndexToView''' bekommt als Argument eine Zeile des Models, und sagt dem Aufrufer, an welcher Position diese Zeile angezeigt werden soll. Wenn die Zeile garnicht gezeigt werden soll, so gibt diese Methode -1 zurück.
* Die Methode '''convertRowIndexToView''' bekommt als Argument die Position an der etwas gezeichnet wird, und sagt dem Aufrufer, welche Zeile dies im Model entspricht.

= Interaktion =
* Wann immer der Benutzer die Tabelle neu sortieren möchte, wird '''toggleSortOrder''' aufgerufen. Das einzige Argument sagt dem ''RowSorter'', welche Spalte betroffen ist. Nachdem der ''RowSorter'' seine internen Strukturen aktualisiert hat, muss er allfällige [[RowSortListener_(Java_API)|RowSortListener]] über die Veränderung informieren.
* Die Methoden '''get/setSortKeys''' werden benutzt, um die Sortierungen direkt zu setzen oder abzufragen. Der erste Eintrag der Liste ist der wichtigste, der letzte hingegen der unbedeutendste. Eine ''JTable'' zeichnet meist einen kleinen Pfeil über der Spalte, die vom ersten Eintrag betroffen ist.

= Information =
* Die verschiedenen Methoden '''rowsInserted/Updated/Removed''' und '''allRowsChanged''' werden automatisch aufgerufen, wenn das benutzte Model verändert wird (der ''RowSorter'' muss also keine Observer beim Model registrieren).
* '''add/removeRowSorterListener''' registriert oder entfernt einen [[RowSorterListener_(Java_API)|RowSorterListener]]. Diese Listener müssen aufgerufen werden, wenn die Sortierreihenfolge verändert wurde.
* '''getModel''', '''getView/ModelRowCount''' liefern schliesslich zusätzliche Informationen über das Model und die Ansicht.

[[Kategorie:Java_API]]

TableColumnModel (Java API)

2007-02-18T22:03:16Z

Beni:

Das ''TableColumnModel'' ist eine Sammlung von [[TableColumn_(Java_API)|TableColumns]], welche von einer [[JTable_(Java_API)|JTable]] verwendet werden. Das ''TableColumnModel'' sorgt für die Reihenfolge, Bewegung und auch die Selektion der Spalten.

Ein ''TableColumnModel'' ist nur ein [[Interface_(Java)|Interface]], das [[Methoden_(Java)|Methoden]] vorschreibt, um Spalten hinzuzufügen, zu entfernen, oder zu verschieben. Ausserdem sollen Implementationen die Möglichkeit bieten, alle Spalten aufzulisten. Die Kommunikation mit der "Aussenwelt" erfolgt über [[TableColumnModelListener_(Java_API)|TableColumnModelListeners]].

''TableColumnModel'' wird von [[DefaultTableColumnModel_(Java_API)|DefaultTableColumnModel]] implementiert. Dieses ''DefaultTableColumnModel'' wird auch normalerweise von der ''JTable'' verwendet.

[[Kategorie:Java_API]]

TableColumn (Java API)

2007-02-18T21:00:54Z

Beni:

Eine ''TableColumn'' stellt eine einzelne Spalte in einer [[JTable_(Java_API)|JTable]] dar. Eine ''TableColumn'' kann, muss aber nicht, spezielle Informationen zu der repräsentierten Spalte haben:
* Den [[TableCellRenderer_(Java_API)|TableCellRenderer]] mit dem einzelne Zellen der Spalte gezeichnet werden.
* Den [[TableCellEditor_(Java_API)|TableCellEditor]] mit dem der Benutzer einzelne Zellen der Spalte verändern kann.
* Grössenangaben wie minimale/maximale und bevorzugte Grösse

Die ''JTable'' erzeugt normalerweise ''TableColumns'' automatisch, sobald sie benötigt werden. Man kann dieses Verhalten aber mit der [[Methode_(Java)|Methode]]'' setAutoCreateColumnsFromModel'' abschalten, und jede Spalte selbst erzeugen. Das folgende Beispiel zeigt eine ''JTable'', deren ''TableModel'' drei Spalten vorgibt, die aber vier Spalten anzeigt.

<code=java>package demo;

import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.*;

public class JTableDemo{
public static void main( String[] args ){
// Die JTable initialisieren
JTable table = new JTable();

// Spalten sollen nicht automatisch erzeugt werden
table.setAutoCreateColumnsFromModel( false );

// Daten setzen
table.setModel( createModel() );

// Spalten bestimmen
table.setColumnModel( createColumnModel() );

// Tabelle anzeigen
JFrame frame = new JFrame( "Demo" );
frame.add( new JScrollPane( table ), BorderLayout.CENTER );
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.pack();
frame.setVisible( true );
}

public static TableColumnModel createColumnModel(){
// Ein Behälter für die Spalten erzeugen
TableColumnModel columns = new DefaultTableColumnModel();

// Die 4 Spalten erzeugen. Jede Spalte kann verschiedene
// Eigenschaften haben.
TableColumn c1 = new TableColumn( 0 );
c1.setHeaderValue( "ColA" );
c1.setPreferredWidth( 35 );
c1.setMaxWidth( 50 );

TableColumn c2 = new TableColumn( 1 );
c2.setHeaderValue( "ColB" );
c2.setPreferredWidth( 60 );
c2.setMinWidth( 60 );
c2.setMaxWidth( 120 );

TableColumn c3 = new TableColumn( 2 );
c3.setHeaderValue( "ColC" );
c3.setPreferredWidth( 10 );
c3.setResizable( false );

// Die letzte Spalte zeigt stets dasselbe wie die
// zweitletzte Spalte, denn beide Spalten benutzen
// dieselbe Model-Spalte als Datenquelle
TableColumn c4 = new TableColumn( 2 );
c4.setHeaderValue( "ColC-2" );
c4.setPreferredWidth( 10 );

columns.addColumn( c1 );
columns.addColumn( c2 );
columns.addColumn( c3 );
columns.addColumn( c4 );

return columns;
}

public static TableModel createModel(){
DefaultTableModel model = new DefaultTableModel(
new Object[]{ "A", "B", "C" }, 0);

model.addRow( new Object[]{ "C1", "C2", "C3" });
return model;
}
}</code=java>

[[Kategorie:Java_API]]

TableCellEditor (Java API)

2007-02-18T20:59:07Z

Beni:

Ein ''TableCellEditor'' wird von einer [[JTable_(Java_API)|JTable]] benutzt, um dem Benutzer die Möglichkeit zu bieten, einzelne Zellen der Tabelle zu bearbeiten. Die ''JTable'' geht dabei immer gleich vor: zuerst wird die [[Methode_(Java)|Methode]] ''getTableCellEditor'' aufgerufen. Diese Methode gibt eine [[Component_(Java_API)|Component]] zurück, welche auf der ''JTable'' angezeigt wird. Der Benutzer kann diesen Editor solange verwenden, bis der ''TableCellEditor'' oder die ''JTable'' die Methode ''stopCellEditing'' oder ''cancelCellEditing'' aufruft. Diese Methoden feuern ein Event in die registrierten [[CellEditorListener_(Java_API)|CellEditorListener]], müssen aber weiter nichts tun.
Wurde das Stop-Event gefeuert, so wird der Editor nach seinem aktuellen Wert befragt (über die Methode ''getCellEditorValue''), und dieser Wert wird in das [[TableModel_(Java_API)|TableModel]] geschrieben. Wurde hingegen das Cancel-Event gefeuert, wird die Aktion einfach abgebrochen, und die Veränderungen verworfen.

Ein einfacher ''TableCellEditor'' könnte folgendermassen aussehen:
<code=java>import java.awt.Component;
import java.util.ArrayList;
import java.util.EventObject;
import java.util.List;

import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.table.TableCellEditor;

/**
* Ein einfacher TableCellEditor der ein String in einem
* Textfeld darstellt.
*/
public class DemoEditor implements TableCellEditor{
/** das Textfeld des Editors */
private JTextField textField = new JTextField();
/** Observer des Editors */
private List<CellEditorListener> listeners = new ArrayList<CellEditorListener>();

// Prepariert den Editor, so dass ein neuer Wert angezeigt wird.
public Component getTableCellEditorComponent(
JTable table, Object value, boolean isSelected, int row, int column ){

textField.setText( String.valueOf( value ) );
return textField;
}

public void addCellEditorListener( CellEditorListener l ){
listeners.add( l );
}

public void removeCellEditorListener( CellEditorListener l ){
listeners.remove( l );
}

// Gibt den aktuellen Wert des Editors zurück.
public Object getCellEditorValue(){
return textField.getText();
}

public boolean isCellEditable( EventObject anEvent ){
return true;
}

public boolean shouldSelectCell( EventObject anEvent ){
return true;
}

// Informiert alle Observer, dass die Aktion abgebrochen wurde.
public void cancelCellEditing(){
ChangeEvent event = new ChangeEvent( this );
for( CellEditorListener listener :
listeners.toArray( new CellEditorListener[ listeners.size() ] )){

listener.editingCanceled( event );
}
}

// Informiert alle Observer, dass der Wert gespeichert werden soll.
public boolean stopCellEditing(){
ChangeEvent event = new ChangeEvent( this );
for( CellEditorListener listener :
listeners.toArray( new CellEditorListener[ listeners.size() ] )){

listener.editingStopped( event );
}

// informiert den Aufrufer, dass der Input korrekt ist.
return true;
}
}</code=java>

[[Kategorie:Java_API]]

TableCellRenderer (Java API)

2007-02-18T20:58:28Z

Beni:

''TableCellRenderer'' ist ein [[Interface_(Java)|Interface]] der [[Java]] [[API]]. ''TableCellRenderer'' werden von der [[JTable_(Java_API)|JTable]] benutzt, um einzelne Zellen zu zeichnen.

Die ''JTable'' fordert den ''TableCellRenderer'' über die Methode ''getTableCellRendererComponent'' auf, eine graphische Darstellung, in Form einer [[Component_(Java_API)|Component]], zu generieren. Diese ''Component'' wird anschliessend in eine Zelle eingepasst, und gezeichnet. Nach dem Zeichenvorgang, wird die ''Component'' von der ''JTable'' nicht mehr benötigt, und kann vom ''TableCellRenderer'' wiederverwertet werden.

Zu beachten ist, dass der Benutzer nur ein Bild des ''TableCellEditors'' sieht, aber nichts anklicken kann. Wenn eine Zelle editiert werden soll, wird ein [[TableCellEditor_(Java_API)|TableCellEditor]] benötigt.

Das folgende Beispiel zeigt einen sehr kleinen Renderer, der für boolsche Werte eine [[JCheckBox_(Java_API)|JCheckBox]] zeichnet, für andere Werte nur ein leeres Feld.
<code=java>public class BooleanRenderer implements TableCellRenderer{
// Die zwei graphischen Repräsentationen dieses Renderers
private JCheckBox box = new JCheckBox();
private JLabel empty = new JLabel();

public Component getTableCellRendererComponent(
JTable table,
Object value,
boolean isSelected,
boolean hasFocus,
int row,
int column){

if( value instanceof Boolean ){
// Die Box selektieren
box.setSelected( Boolean.TRUE.equals( value ));
// Die Box wird nun gezeichnet
return box;
}
else{
// Das leere Feld wird nun gezeichnet
return empty;
}
}
}</code=java>
[[Kategorie:Java_API]]

TableModel (Java API)

2007-02-18T20:57:26Z

Beni:

Ein TableModel enthält Daten, welche von einer [[JTable_(Java_API)|JTable]] angezeigt werden. Das ''TableModel'' stellt eine Tabelle, eine gitterförmige Datenstruktur, dar.

Ein ''TableModel'' kommuniziert mit seiner Aussenwelt über [[TableModelListener_(Java_API)|TableModelListener]]. In einem [[MVC-Pattern]] entspricht es dem ''M''.

== Methoden ==
''TableModel'' ist ein [[Interface_(Java)|Interface]] welches folgende [[Methode_(Java)|Methoden]] vorschreibt:

* '''getColumnCount''' liefert die Anzahl Spalten der Tabelle.
* '''getRowCount''' liefert die Anzahl Zeilen der Tabelle.
* '''getColumnName''' liefert den Namen einer Spalte. Der Name wird über der Spalte in einem speziellen Feld (dem Header) angezeigt.
* '''getColumnClass''' liefert den Typ der Einträge einer Spalte. Je nach Typ kann die JTable die Spalte anders darstellen. [[Boolean_(Java)|Boolsche Werte]] werden z.B. mit einer [[JCheckBox_(Java_API)|JCheckBox]] dargestellt, [[String_(Java_API)|Strings]] hingegen als Text.
Im folgenden Stück Code wird für die erste Spalte der Typ ''String'', für die zweite Spalte der Typ [[Integer_(Java_API)|Integer]] angegeben.
<code=java>public Class<?> getColumnClass( int column ){
switch( column ){
case 0: return String.class;
case 1: return Integer.class;
default: throw new IllegalArgumentException( "unknown column: " + column );
}
}</code=java>

* '''getValueAt''' liefert den Wert einer Zelle. Der Typ dieses Wertes muss der Angabe von ''getColumnClass'' entsprechen.
* '''isCellEditable''' sagt der Tabelle, ob eine bestimmte Zelle durch den Benutzer bearbeitet werden darf. Die Methode ''getColumnClass'' bestimmt masgeblich, wie die Zelle bearbeitet wird; z.B. wird für eine Spalte mit Strings ein Textfeld angeboten.
* '''setValueAt''' ist das Gegenstück zu ''getValueAt'', mit dieser Methode wird der Wert einer Zelle gesetzt. Diese Methode wird von der JTable aufgerufen, nachdem ein [[TableCellEditor_(Java_API)|TableCellEditor]] einen Wert verändert hat.
* '''addTableModelListener''' fügt dem Model einen [[TableModelListener_(Java_API)|TableModelListener]] hinzu. Dieser Listener muss immer benachrichtigt werden, wenn sich Daten des Models verändern. Mit Hilfe des [[TableModelEvent_(Java_API)|TableModelEvents]] kann eine genau Angabe gemacht werden, welcher Teil des Models sich verändert hat. z.B. könnte eine Zeile gelöscht worden sein, oder der Wert einer Zelle wurde verändert.
* '''removeTableModelListener''' entfernt einen früher hinzugefügten ''TableModelListener''

== Implementationen ==
Es gibt zwei oft benutze Implementationen:
* Das '''AbstractTableModel''' kann als Grundlage eines eigenen TableModels dienen. Insbesondere bietet es Methoden für Verwaltung der [[TableModelListener]] an.
* Das '''DefaultTableModel''' ist ein einfaches Model, bei dem Zellen verändert, Spalten und Zeilen hinzugefügt oder gelöscht werden können. Für die meisten Anwendungen die nur einige Daten anzeigen möchten, sollte dieses Model vollständig ausreichen.

[[Kategorie:Java_API]]