Populate Tableview with super class fields

Question

I have several classes that all inherit from one super class that need to populate several TableViews related to their class.

The super class is abstract and some of the getters and setters are final but still contains data needed to populate the cells.

Writing a new Callback class for each and every column is doable, but I'm looking for a way to implements this.

sample code

class SuperClass
{
  protected String name;
  protected double value;
  public final void setName(String name)
  {
    this.name = name;
  }
  public final void getName()
  {
    return this.name;
  }
  public final void setValue(double value)
  {
    this.value = value;
  }
  public double getValue()
  {
    return this.value;
  }
}

class SubClass1 extends SuperClass
{
  private int id;
  public void setId(int id)
  {
    this.id = id;
  }
  public int getId()
  {
    return this.id;
  }
}

class SubClass2 extends SuperClass
{
  private String location;
  public void setLocation(String location)
  {
    this.location = location;
  }
}

class SubClass3 extends SuperClass
{
  private ObservableMap<SuperClass> map;
  public ObservableMap<SuperClass> map()
  {
    return this.map;
  }
}

TableView

TableColumn<SubClass1, Integer> tc1_id;
TableColumn<SubClass1, String> tc1_name;
TableColumn<SubClass1, Double> tc1_value;
TableColumn<SubClass2, String> tc2_loc;
TableColumn<SubClass2, String> tc2_name;
TableColumn<SubClass2, Double> tc2_value;
TableColumn<SubClass3, String> tc3_name;
TableColumn<SubClass3, Double> tc3_value;

Here's a reference of what I was going to do... Accessing Subclass properties in a JavaFX TableView ObservableArrayList

But just with the sample code, I'm basically rewriting 2 methods, 3 times each... and there's a bit more than that in the actual program. (Just a smidge more)

Answer 1

I think you are just asking how to reduce the amount of code you have to write. The solution is just the same as any such question: write a method that performs the repetitive part, and parametrize it with the parts that vary. So in this case, you just need to write a generic utility method to generate your table columns, taking the title of the column and the function that produces the property the cell value factory needs.

E.g. you could do something like

private <S,T> TableColumn<S,T> createColumn(String title, Function<S, Property<T>> prop) {
    TableColumn<S,T> column = new TableColumn<>(title);
    column.setCellValueFactory(cellData -> prop.apply(cellData.getValue()));
    return column ;
}

and then if your model classes use JavaFX properties, all you need is

TableColumn<SubClass1, Number> tc1Id = createColumn("Id", SubClass1::idProperty);

etc.

If you are not using JavaFX properties (which is the recommended approach), you can still do

TableColumn<SubClass2, String> tc2Loc = 
    createColumn("Location", item -> new SimpleStringProperty(item.getLocation()));

or just create a method that accepts a Function<S,T> instead of a Function<S,Property<T>>.