Type-safe way to reuse defensive copy method given immutable class hierarchy

Question

I have a base class and a derived class, both designed to be immutable (ctor and getters omitted):

public class PageQuery<T> {
    private final T queryFilter;
    private PageCond pageCond; // pagination parameter

    // E withPageCond(PageCond newPageCond) { 
    //    return a brand new copy of `this` with `pageCond` replaced with `newPageCond`
    //    that can be reused across class hierarchy
    // }
}

public class PageSortQuery<T> extends PageQuery<T>{
    private final SortCond sortCond; // sorting parameter
}

How to add a method that returns defensive copy of this to the base class so that all classes in this hierarchy can benefit from it? Is there a way to accomplish it without clone() ?

Answer 1

I don't know if you mean something like this, in this case if you call the withFilter method the origin would not become changed.

@AllArgsConstructor
public class Query <T> {
  @Getter
  private final String name;
  @Getter
  private final Predicate<T> filter;

  public Query<T> withFilter(Predicate<T> filter){
    return new DelegatingQuery<T>(this){
      @Override
      public Predicate<T> getFilter() {
        return Query.this.filter;
      }
    };
  }

  static class DelegatingQuery<T> extends Query<T>{
    @Delegate
    private final Query<T> query;

    public DelegatingQuery(Query<T> query) {
      super(query.name,query.filter);
      this.query = query;
    }
  }

}