I find I tend to design class structures where several subclasses have nearly identical functionality, but one piece of it is different. So I write nearly all the code in the abstract class, and then create several subclasses to do the one different thing. Does this pattern have a name? Is this the best way for this sort of scenario?
Option 1:
public interface TaxCalc {
String calcTaxes();
}
public abstract class AbstractTaxCalc implements TaxCalc {
// most constructors and fields are here
public double calcTaxes(UserFinancials data) {
// code
double diffNumber = getNumber(data);
// more code
}
abstract protected double getNumber(UserFinancials data);
protected double initialTaxes(double grossIncome) {
// code
return initialNumber;
}
}
public class SimpleTaxCalc extends AbstractCalc {
protected double getNumber(UserFinancials data) {
double temp = intialCalc(data.getGrossIncome());
// do other stuff
return temp;
}
}
public class FancyTaxCalc extends AbstractTaxCalc {
protected double getNumber(UserFinancials data) {
int temp = initialCalc(data.getGrossIncome());
// Do fancier math
return temp;
}
}
Option 2:
This version is more like the Strategy pattern, and should be able to do essentially the same sorts of tasks.
public class TaxCalcImpl implements TaxCalc {
private final TaxMath worker;
public DummyImpl(TaxMath worker) {
this.worker = worker;
}
public double calcTaxes(UserFinancials data) {
// code
double analyzedDouble = initialNumber;
int diffNumber = worker.getNumber(data, initialNumber);
// more code
}
protected int initialTaxes(double grossIncome) {
// code
return initialNumber;
}
}
public interface TaxMath {
double getNumber(UserFinancials data, double initial);
}
Then I could do:
TaxCalc dum = new TaxCalcImpl(new TaxMath() {
@Override
public double getNumber(UserFinancials data, double initial) {
double temp = data.getGrossIncome();
// do math
return temp;
});
And I could make specific implementations of TaxMath for things I use a lot, or I could make a stateless singleton for certain kinds of workers I use a lot.
So the question I'm asking is: Which of these patterns is superior, when, and why? Or, alternately, is there an even better third option?
