Erste Schritte AbstractTableModel Werte setzen mit setValueAt

[EinAnfänger]

Hallo zusammen,

ich arbeite gerade das Buch die Insel durch und hänge an den JTables fest. Ich habe das Beispiel im Buch umgesetzt und versuche eine JTable zu erzeugen in der ich Werte ändern kann.

Hier der Code:

package jtable;

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

public class GUI_JTable {

    public static void main(String[] args) {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JTable table =new JTable();
        table.setModel(new Model());
        f.add (new JScrollPane(table));
        f.pack();
        f.setVisible(true);        
    }
}

package jtable;

import javax.swing.table.AbstractTableModel;

public class Model extends AbstractTableModel{
    
    public int getRowCount(){
        return 10;
    }
    
    public int getColumnCount(){
        return 3;
    }
    
    public Object getValueAt(int row, int col){
       if (col==0)
            return  row;
        else if (col==1)
            return row * row;
        else
            return row * row * row; 
    }
   public boolean isCellEditable(int rowIndex, int columnIndex){
       return columnIndex ==0;
   }  
 
   public void setValueAt(Object aValue, int rowIndex, int columnIndex){
      //System.out.println(aValue + " "+ rowIndex + " " + columnIndex); // Nur zu Kontrolle
      hier fehlt etwas, nur was?
      fireTableCellUpdated(rowIndex, columnIndex);
   }

}

Die Spalte 0, also die erste, ist zum Editieren freigegeben; mit einem Klick in die Zelle kann ich dort auch etwas eingeben. Aber irgendwie wird mir die Änderung zum Verrecken nicht angezeigt, sprich mein Problem liegt in der Methode setValueAt. Kann mir vielleicht jemand einen Hinweis geben? Wahrscheinlich sehe ich den Wald vor lauter Bäumen nicht...

Viele Grüße

Markus

 

[ARadauer]

So schlau ist die Tabelle auch wieder nicht. Du denkst zu kompliziert. Ganz einfach...Tabelle fragt was ist in zeile X Spalte Y
du sagst in spalte 1 zb ist zeile * zeile... du berechnest den inhalt deiner tabelle dynamisch.

Benutzer gibt was ein, Tabelle sagt, in zeile 3 spalte 3 hat jemand 6 eingegeben. Was willst du jetzt machen, deine Werte werden ja dynamisch errechnet... die Tabelle kann den inhalt nicht ablegen, dort wo es das machen würde ist das model. aber das ist ja deine implementierung..

1. Im konstruktor 2 dimensionales array machen und mit zwei for schleifen, vorbelegen
2. mit getValueAt den inhalt des arrays an der richtigen stelle zurück geben
3. mit setValueAt den eingegeben wert in das Array speichern

 

[EinAnfänger]

Ich bin irgendwie neben der Spur... Wie meinst Du das mit dem Konstruktor und den Schleifen?

 

[Ein Anfänger]

Ich kriege es nicht gebacken... Eigentlich möchte ich nur eine Tabelle mir vorbelegten Daten anzeigen lassen und diese dann editierbar machen. Kann sich vielleicht mal einer erbarmen und mir ein paar Codeschnipsel für getValueAt und setValueAt zuwerfen?

Soweit ich das nun verstanden habe, zeigt mir das Programm die geänderten Daten nicht an, weil diese direkt von der Methode getValueAt überschrieben werden, oder? Also muss die Methode geändert werden. Nur muss ich als Ergebnis ja ein Objekt liefern, die Frage ist nur welches???

Mich irritiert schon alleine die Bezeichnung: mit getValueAt setzte ich dann ja anscheinend Werte und mit setValueAt lese ich die dann aus. Oder bin ich jetzt komplett verwirrt?

Die Insel ist ein wirklich lehrreiches Buch, aber den Part mit dem JTable raffe ich überhaupt nicht! Es ist immer toll, wenn mit Beispielen angefangen wird, die vermeinlich aufeinander aufbauen, dem dann aber gar nicht so ist...

 

[Final_Striker]

Ich kriege es nicht gebacken... Eigentlich möchte ich nur eine Tabelle mir vorbelegten Daten anzeigen lassen und diese dann editierbar machen. Kann sich vielleicht mal einer erbarmen und mir ein paar Codeschnipsel für getValueAt und setValueAt zuwerfen?

Wie dir schon gesagt wurde, brauchst du noch etwas wo du deine Werte speicherst.
Ein 2D Array wäre da bei einer Tabelle sinnvoll.

Mich irritiert schon alleine die Bezeichnung: mit getValueAt setzte ich dann ja anscheinend Werte und mit setValueAt lese ich die dann aus. Oder bin ich jetzt komplett verwirrt?

Nein, andersherum.

 

[EinAnfänger]

Und wieso wird die Tabelle in meinem Code mit getValueAt gefüllt???

 

[triopsfreak]

Du musst das aus der Sicht der JTable sehen, die ruft die Methode

getValueAt(int x, int y)

auf, damit sie weiss was angezeigt werden soll. Wenn der User etwas eingibt, ruft die JTable

setValueAt()

auf, jetzt muss das TableModel reagieren.

 

[codechaos]

Okay, versetzen wir uns mal in eine (J)Table, also einer Tabelle. Wir sind hübsch anzusehen, weil wir Daten wunderbar tabellarisch darstellen können, allerdings wissen wir im Grunde nicht, was wir anzeigen sollen. Unser Chef sagt uns jetzt, aber dass wir gefälligst etwas anzeigen sollen und stellt uns den Kollegen TableModel zur Seite. TableModel ist nicht so hübsch anzusehen, kennt dafür aber, welche Werte in welcher Zelle gehören und die Dimensionen der Tabelle.
Um den Chef zufrieden zu stellen, fragen wir den Kollegen also, was in die Zeile y in Spalte x kommt. Das machen wir für alle Zellen, zeigen den Wert an und der Chef ist glücklich.

Konkreter:
Die Tabelle fragt das Table Model (1) wie viele Spalten zu füllen sind, (2) wie viele Zeilen zu füllen sind und (3) welche Werte dort stehen.

Wenn wir jetzt selbst ein TableModel erstellen wollen, müssen wir zumindest diese 3 Operationen erfüllen.
Um (1) zu erfüllen, müssen wir int getColumnCount() implementieren, bei (2) int getRowCount() und für (3) Object getValueAt(spalte, zeile)

Eine einfache Tabelle, die zur Veranschaulichung nur in der Konsole ausgegeben wird, könnte dann so arbeiten:

public class SimpleConsoleTable {
	private final AbstractTableModel model;
	private final int rowCount;
	private final int columnCount;

	public SimpleConsoleTable(final AbstractTableModel model) {
		this.model = model;
		this.rowCount = model.getRowCount();
		this.columnCount = model.getColumnCount();
	}
	
	public void print(){
		for(int zeile = 0; zeile < rowCount; zeile++){
			for(int spalte = 0; spalte < columnCount; spalte++){
				
				Object valueAtCurrentPosition = model.getValueAt(zeile, spalte);

				System.out.print(valueAtCurrentPosition);
				System.out.print("\t");
				
			}
			System.out.println();
		}
	}
}

Um (1), (2) und (3) implementieren zu können, musst du dir die Werte, die die Tabelle ausliest natürlich irgendwo zwischen speichern und dann nur zurück geben 😉

 

[EinAnfänger]

So hatte ich das ursprünglich auch verstanden...

Dann werde ich mich morgen mal an den Methoden versuchen 🙂 Ich denke ich schlafe da mal drüber, vielleicht Kriege ich ja noch die Erleuchtung. Bin ich denn auf dem richtigen Weg, wenn ich die Tabelle über ein Array fülle (soll erstmal als Platzhalter für eine spätere Datenbankbefüllung dienen) und dann die Set- und getValueAt Methoden aufsetze? Bloss wie sollen die aussehen...

 

[triopsfreak]

Du brauchst für die erste Kolonne ein Array oder eine Liste, darin speicherst du die Werte, die anderen sollen ja nicht editierbar sein. Das Array füllst du dann einfach mal mit Werten von 0 bis irgendwohin... in der Methode setValueAt änderst du die Werte entsprechend.

 

[EinAnfänger]

So, einmal einen klaren Kopf zu kriegen und mit neuem Schwung an die Sache zu gehen war nicht verkehrt 😉

import javax.swing.table.AbstractTableModel;

public class Model extends AbstractTableModel{
    String[] array =new String[5];
    
    public Model(){
        array[0]="A";
        array[1]="B";
        array[2]="C";
        array[3]="D";
        array[4]="E";        
    }
    
    public int getRowCount(){
        return 5;
    }
    
    public int getColumnCount(){
        return 1;
    }
    
    public Object getValueAt(int rowIndex, int columnIndex){
            return array[rowIndex];
    }
   public boolean isCellEditable(int rowIndex, int columnIndex){
       return true;
   }  
 
   public void setValueAt(Object aValue, int rowIndex, int columnIndex){
      System.out.println(aValue + " "+ rowIndex + " " + columnIndex);
      array[rowIndex] = (String)aValue; 
      fireTableCellUpdated(rowIndex, columnIndex);
   }

}

Jetzt läuft es! Mein Gedankenfehler war, dass das Model durch fireTableCellUpdated nicht nur die Änderungen berücksichtigt, sondern die komplette Tabelle neu aufgebaut wird. Also das klassische Brett vorm Kopf...

Die ganze Übung war natürlich nur ein Dummy, mit dem Ziel Tabellen aus Datenbanken zu füllen. Ich denke, ich werde versuchen Klassen über Vectoren an die Tabelle zu übergeben, das sollte dann auch ein späteres handling mit Hibernate erleichtern. Ideen oder Vorschlägen wie dies besser gemacht werden kann, bin ich natürlich immer aufgeschlossen.

Mein "Traum" wäre es ein Tabellenmodel so zu programmieren, dass sich die Tabelle anhand des unterschiedlicher Objekte eigenständig auf den Objektattributen aufbaut (Formatierung,...). Ich also sagen kann ich baue in eine GUI Tabellen ein, welche unterschiedliche Daten (Objekte) enthält, die dann durch das Tabellenmodell automatisch formatiert und angezeigt werden.

Vielen Dank an alle die mir hier auf die Sprünge geholfen haben!