How to deal with interchangable base classes in Java

Question

I have an issue with some inheritance I'm doing. Basically, I have an abstract class called LineCalculator, which, as it suggests, calculates lines of an equation. From there, I inherit this base class in a LinearLineCalculator, which calculates lines on a Cartesian coordinate system, and a PolarLineCalculator, which calculated lines on the polar coordinate system.

public abstract class LineCalculator {

    // Begins calculating a line based on the parameters
    protected final Path2D.Double calculateLine(...) {
    }

    // Takes in an X value, does something with it, 
    // and returns the resulting X and Y values
    protected abstract double[] handlePoint(double x);
}

So LinearLineCalculator just calculates the corresponding Y value with an equation, while PolarLineCalculator would calculate the radius from the equation and the X value, and convert that to polar coordinates (in this case, X acts as θ, in degrees or radians).

LineCalculator then calculates the line in a sort of "free for all" manner, where the threads calculating the line take and calculate X and Y values as fast as they can and reports them to the base class. The base class then deals with constructing the line from the data calculated by the threads.

My problem is that I've implemented a modified version, where it is calculated in a sequential manner, where the base class blocks on each thread until it gets the first value. Then it waits for the second ordered value, and so on, allowing it to construct the line on the fly.

This inheritance model works perfectly, because I was able to modify the base class without modifying any of the inheritors and have it still work. But I want to be able to switch out the implementations interchangeably, for example for some lines, calculate it "free for all" style, and for some lines, calculate it sequentially.

My question is is there a pattern or design that allows me to change out the base class implementation, but keep the super class implementation without violating the DRY principle?

Answer 1

Sounds to me like you really want composition, not necessarily inheritance.

I'd have a Calculator interface, with Rectangular and Polar implementations. Give the class that does the calculation a Calculator reference that you initialize in its constructor. That lets you swap out the implementation easily. You'll need a CalculatorFactory as well.