Spg vedr. Swing

En JTable som eksempel udbyder noget standard funktionalitet. Ønskes der yderligere funktionalitet, kan man gøre brug af en TableModel. På den måde har man selv indflydelse på, hvordan strukturen bag en JTable fungerer.

En JTable tager som udgangspunkt et to-dimensionelt Object array med i sin contructor samt et array med kolonnenavne. Dette er brugbart, men ikke særlig dynamisk. Derfor har man mulighed for at lave en TableModel, som kan kontrollere de ting man gerne vil ha' vist i sin JTable. I din implementation af TableModel, kan du eksempelvis lave add og remove metoder, så du kan arbejde på faktiske objekter.

Svar nok? Eller var det ikke det du mente?

til en vis grad forstår jeg det, men jeg føler mig stadig usikker,hvonår jeg burde inkludere dem i min kode og hvornår jeg kan klare mig uden dem. Hmmm , hvis du havde 2 simple eks. hvor den ene er med og den anden er uden en Model, så man kunne danne sig et indtryk af hvor de kunne være nyttige, vil være godt

Det kigger jeg lige på senere idag.

Nogle køreklare eksempler:

Først en med en TableModel. Her arbejder jeg på reelle objekter - og de data der vises i tabellen hentes fra de oprettede objekter.
Med dette eksempel er det utroligt nemt at tilføje objekter dynamisk. Dette gøres blot ved at kalde add-metoden på TableModel.

import java.awt.*;
import javax.swing.table.*;
import javax.swing.*;
import java.util.*;
import java.awt.event.*;

public class JTableTest extends JFrame
{
    private MyTableModel model = new MyTableModel();
    private JTable table = new JTable (model);
    private int index = 0;
   
    public JTableTest()
    {
        this.setSize(400, 400);
        this.getContentPane().add(new JScrollPane (table), BorderLayout.CENTER);
       
        for (int i = 0; i<10; i++)
            model.addTableElement(new MyObject (i, "Navn: " + i));
           
        JButton add = new JButton ("Tilføj");
        add.addActionListener(new ActionListener()
        {
            public void actionPerformed (ActionEvent e)
            {
                addRow ();
            }
        });
       
        this.getContentPane().add(add, BorderLayout.SOUTH);
    }
   
    private void addRow ()
    {
        model.addTableElement(new MyObject(index, "Nyt element nr: " + index++));
    }
   
    private class MyObject
    {
        int id;
        String name;
       
        public MyObject (int id, String name)
        {
            this.id = id;
            this.name = name;
        }
       
        public int getId()
        {
            return id;
        }
       
        public String getName ()
        {
            return name;
        }
       
        public void setId (int id)
        {
            this.id = id;
        }
       
        public void setName (String name)
        {
            this.name = name;
        }
    }
       
    private class MyTableModel extends AbstractTableModel
    {
        private String[] columns = new String[] {"Id", "Navn"};
        private ArrayList data;

        public MyTableModel()
        {
            data = new ArrayList();
        }
       
        public int getColumnCount()
        {
            return columns.length;
        }
       
        public int getRowCount()
        {
            return data.size();
        }
       
        public String getColumnName(int column)
        {
            return columns[column];
        }
       
        public MyObject getValueAt(int row)
        {
            return (MyObject)data.get(row);
        }
       
        public Object getValueAt(int row, int column)
        {
            MyObject element = (MyObject) data.get(row);
       
            switch (column)
            {
                case 0: return String.valueOf(element.getId());
                case 1: return element.getName();
            }
            return null;
        }
       
        public Class getColumnClass(int column)
        {
            return getValueAt(0, column).getClass();
        }
       
        public boolean isCellEditable(int row, int column)
        {
            return true; // alle celler er editerbare
        }
       
        public void setValueAt(Object value, int row, int column)
        {
            switch (column)
            {
                case 0: ((MyObject) data.get(row)).setId(Integer.parseInt(value.toString())); break;
                case 1: ((MyObject) data.get(row)).setName(value.toString()); break;
            }
            fireTableCellUpdated(row, column);
        }
       
        public void addTableElement(MyObject element)
        {
            data.add(element);
            fireTableRowsInserted(data.size(), data.size());
        }
       
        public void removeTableElement(int index)
        {
            if (! (index == -1))
            {
                data.remove(index);
                fireTableRowsDeleted(index, index);
            }
        }
       
        public void removeAll()
        {
            int slut = data.size();
            data.clear();
            fireTableRowsDeleted(0, slut);
        }
    }
   
    public static void main (String[] args)
    {
        new JTableTest().setVisible(true);
    }
}


Andet eksempel. Noget mere simpelt, men også meget mere statisk. Dette er fint, hvis man blot skal vise nogle data hurtigt i en tabel.
Men skal man til at tilføje rækker og slette rækker, bliver det straks værre.

import javax.swing.*;
import javax.swing.table.*;
import java.awt.*;

public class TestJTable extends JFrame
{
    private JTable table;
    private Object[][] data;
   
    public TestJTable ()
    {
        setSize (300, 300);
        data = new Object[2][2];
        data[0][0] = "1";
        data[0][1] = "Række 1";
        data[1][0] = "2";
        data[1][1] = "Række 2";
        String[] columns = {"Række 1", "Række 2"};
        table = new JTable (data, columns);
       
               
        this.getContentPane().add(new JScrollPane (table));   
    }
   
    public static void main (String[] args)
    {
        new TestJTable().setVisible(true);
    }
}

Så det er meget situationsafhængigt om man skal vælge den ene eller den anden løsning.

Har man en tabel der jævnligt skal opdateres og med brugerinteraktion, vil jeg helt klart vælge løsning 1. Også selvom det kræver lidt mere kode.

Hvorimod, har man en tabel, hvor data er statisk og ikke ændrer sig, vil jeg vælge løsning 2.

svar tak

Kommer her.