Question

We’ve got a set of classes which derive from a common set of interfaces such that

IFoo-> BasicFoo, ReverseFoo, ForwardFoo
IBar -> UpBar, DownBar, SidewaysBar
IYelp -> Yip, Yap, Yup

wherein the constructor for the Foo’s looks like Foo(IBar, IYelp) These items are used throughout the project.

There exists another class which has a method whose signature is public double CalcSomething(IFoo, IAnotherClass) that is applied at some point to each and every Foo. We’ve had a request come down from above that one particular object composition, let’s say a BasicFoo(UpBar,Yip), use a different algorithm other than the one found in CalcSomething.

My first instinct was to say let’s change the IFoo interface so we can move the logic down to the Foo class level, change the constructor to be Foo(IBar, IYelp, IStrategy) and then have the Foo objects encapsulate this logic. Unfortunately we’ve also been told the design of the architecture stipulates that there be no dependencies between IFoo, it’s implementations and IAnotherClass. They’re adamant about this.

Ok, sure, then I thought I might use a visitor pattern but… how? The whole point of making the composition was so that no other class could see the implementation details. Reflection to look inside the objects, totally breaking encapsulation? Oh hell no.

So I’ve come here because I’m at a loss. Does anyone have any suggestions how we could treat a special case of one of the compositions without modifying the composition or breaking encapsulation? There has got to be a simple solution I’m over-looking.

Edit:

Removed offending beginning.
Changed “handled specially” into a more descriptive meaning.

Answer 1

A CalculationFactory that chooses an appropriate algorithm based on the type of IFoo you provide would solve the problem (at the cost of a conditional):

interface ICalcSomethingStrategy {
    public double CalcSomething(IFoo, IAnotherClass);
}

CalcSomethingStrategyFactory {
    ICalcSomethingStrategy CreateCalcSomethingStrategy(IFoo foo) {
        // I'm not sure whether this is the idiomatic java way to check types D:
        if (foo.Bar instanceof UpBar && foo instanceof Yip) {
            return new UnusualCalcSomethingStrategy();
        } else {
            return new StandardCalcSomethingStrategy();
        }
    }
}