Question

I have a problem when implementing aggregate (or alike) methods on a hierarchy of tree node data. As can be seen Generics is little bit overused here which is not satisfactory to me, so my question is:
is there a better way to implement it (possibly avoiding casts from Object in aggregate methods down the hierarchy) ?

Current situation (stripped of unrelated details):

public interface AggregableTreeData<T extends AggregableTreeData> {
  void aggregate(T from);   
}

public abstract class FruitTreeData<T extends FruitTreeData<?>> 
      implements AggregableTreeData<T> {

  private BigDecimal size = BigDecimal.ZERO;

  @Override
  public void aggregate(T from) {
    this.size = this.size.add(from.size);
  }
}

public class OrangeTreeData<T extends OrangeTreeData<?>> 
    extends  FruitTreeData<T> {

  private boolean ripened = false;

  @Override
  public void aggregate(T from) {
    this.ripened = this.ripened || from.ripened;
  }
}

Additionally I have a method, performing tree data aggregation, which looks like:

//child.getData() and node.getData() is of type <T extends AggregableTreeData<T>>
void aggregateNode(TreeNode node) {
  for (TreeNode child : node.getChildren()) {
    aggregateNode(child);
    node.getData().aggregate(child.getData());
  }
}

Answer 1

Looks pretty much like a job for the composite pattern.