Displaying various objects' instance variables in a JTable and modifying them

Question

I am designing an application that has two widgets:

-A list that contains arbitrary objects
-A table that displays specific properties of the currently selected object

The goal is to be able to pick an object from the list, look at the properties, and modify them as necessary. The list can hold objects of various types.

So say the list contains Vehicle objects and Person objects

public class Person
{
  public String     name;
  public Integer    age;
}

public class Vehicle
{
  public String    make;
  public String    model;
}

If I click on a Person object, the table will display the name and age, and I can assign new values to them. Similarly, if I click on a Vehicle object, it will display the make and model in the table and allow me to modify them.

I have considered writing a method like

public String[] getFields()
{
   return new String[] {"name", "age"};
}

Which returns a list of strings that represent the instance variables I want to look at, and use some reflection methods to get/set them. I can define this getFields method in all of the classes so that I can use the table to handle arbitrary objects that might be thrown into the list.

But is there a way to design this so that I don't resort to reflection? The current approach seems like bad design.

On the other hand, I could create multiple TableModel objects, one for every possible class. The table would know what rows to display and how to access the object's instance variables. But then everytime a new class is added I would have to define a new table model, which also sounds like a weak design.

Answer 1

You have a class (Vehicle) and you know the names of some properties (make, model) that you want to be able to manipulate dynamically for an instance of this class through a JTable UI.

You have various different approaches to chose from.

A. Use the reflection API

This is what the reflection API is made for. If you want something so dynamic, there is nothing wrong with using reflection. The performance overhead will not be significant for this use case.

B. Use a library like beanutils that is based on the reflection API

This should be easier than directly using the reflection API, but it has the drawback that you need to include another dependency in your project.

C. Create dynamically at runtime the different TableModel classes.

You can do this using either the java compiler API or javassist. Based on information available at runtime, you are able to compile a new class for each different type of table model. If you follow this approach you must be aware that the creation of the class is a heavy task, so the first time you create a TableModel the application will take some time to respond.

What to chose?

Of course this is your decision. For the specific use case, the overhead added by reflection or beanutils is insignificant, so probably it is better to chose between A or B. In another use case where performance is more critical, then you could examine the C approach, without forgetting the class creation response time problem.

EDIT: I just realized that in this specific use case there is another important functionality required. Convert from String to the appropriate data type of each property and vice cersa. Beanutils has perfect support for that, so it gets a plus here.