Coding on Point interfaces/superclasses instead of implementations

Inheritance is not to be taken lightly. Have you considered composition instead?

The MedianPoint class seems to represent a point that happens to be median in some collection of points. But this depends on the context. There is nothing in this class that could prevent creating points that are not in fact at the median. You can certainly call the constructor or a factory method with parameters that don't correspond to a median point. As such, it would make more sense to use regular point objects, and distinguish them from non-median points by naming.

The methods in this class can be static methods in a PointUtils good old fashioned utility class.

The same goes for Point2DAdvanced as well. So the answer to all your questions: use Point2D.Double everywhere. The custom point classes don't really add value, and do nothing to help reducing complexity.

OK, then no need for a Point2DAdvanced:

import java.awt.geom.Point2D;

/**
 * ...
 */
public class MedianPoint extends Point2D.Double {

  /**
   * ...
   */
  public static MedianPoint from( String twoDoubles, String limit ) {
    // no need to trim since Double.parseDouble(...) below trims anyway
    String[] doubles = twoDoubles.split( limit );
    // Note from Double.valueOf(...):
    //   "To interpret localized string representations 
    //    of a floating-point value, use subclasses of NumberFormat." 
    return new MedianPoint(
      java.lang.Double.parseDouble( doubles[0] ),
      java.lang.Double.parseDouble( doubles[1] )
      );
    }

  /**
   * ...
   */
  private static Point2D.Double greaterByXOf( Point2D.Double p1, Point2D.Double p2 ) {
    return p1.getX() > p2.getX() ? p1 : p2;
    }

  /**
   * ...
   */
  private static Point2D.Double greaterByYOf( Point2D.Double p1, Point2D.Double p2 ) {
    return p1.getY() > p2.getY() ? p1 : p2;
    }

  /**
   * ...
   */
  public MedianPoint( double x, double y ) {
    super( x, y );
    }

  /**
   * ...
   */
  public MedianPoint(JavaRDD<Point2D.Double> points) {
    super(
      points.reduce((a, b) -> greaterByXOf(a, b)).getX() / 2.0,
      points.reduce((a, b) -> greaterByYOf(a, b)).getY() / 2.0;
      );
    }

  /**
   * ...
   */
  public boolean dominates( Point2D.Double point ) {
    return x <= point.getX() && y < point.getY() ||
           y <= point.getY() && x < point.getX();
    }

  @Override
  public String toString() {
    return String.format( "(%f,%f)", x, y );
    }

  } // MedianPoint

Does this fit your needs?

If you're not happy with the class' name MedianPoint (because it is not such) rename it to something that suits you better.

Some questions come in mind:

• Q: What behavior adds MedianPoint to Point2D.Double.

• A: None. The static methods do not, and there's nothing else.

• Q: How can I tell a MedianPoint from an ordinary Point2D.Double.

• A: Nothing but instanceof check. There's nothing special about it.

• Q: So why MedianPoint extends Point2D.Double?

• A: It's wrong. It should be a factory (method or class).

double xDimensionMedian = biggestPointByXDimension.getX() / 2.0;

"Half of the maximum" is surely not the definition of median I've been taught.

private final Point2D.Double medianPoint;

This seems to confirm the above. A medianPoint is just a Point2D.Double.

int xBit = x < medianX ? 0 : 1;
int yBit = y < medianY ? 0 : 1;
return new PointFlag(xBit, yBit);

Why not boolean?

Point2DAdvanced:

It's nice to add some functionality to a class, but it's not possible to do it for an object. So in order to be able to use dominates, you need to forget about the existing Point2D.Double and create a new object. IMHO too impractical.

This gets worsened by the fact that Point2D.Double is mutable. You may call dominates at a point when the original has changed. This may be what you want or not, but usually it's confusing at best. IMHO it was a mistake to make Point2D.Double mutable and I'd avoid it completely.

If you really want to use Point2DAdvanced as is, then you should probably provide a constructor or a factory taking a Point2D.Double. If you're only reusing part the Point2D.Double's functionality, then it's probably not worth it.