This is a wrong design pattern. Rather than using one generic method and an if ladder, you should instead use overloading. Overloading eliminates the need for the if ladder and the compiler can make sure the correct method is invoked rather than having to wait till runtime.
eg.
public class BallUserInterfaceFactory { public static BallUserInterface<Baseball> getUserInterface( Baseball ball) { return new BallUserInterface<Baseball>(ball); } public static BallUserInterface<Football> getUserInterface( Football ball) { return new BallUserInterface<Football>(ball); } }
This way you also get the added benefit of compile time errors if your code cannot create a BallUserInterface for the appropriate ball.
To avoid the if ladder you can use a technique known as double dispatch. In essence, we use the fact that the instance knows what class it belongs to and calls the appropriate factory method for us. For this to work Ball needs to have a method that returns the appropriate BallInterface.
You can either make the method abstract or provide a default implementation that throws an exception or returns null. Ball and Baseball should now look something like:
public abstract class Ball<T extends Ball<T>> { abstract BallUserInterface<T> getBallUserInterface(); }
.
public class Baseball extends Ball<Baseball> { @Override BallUserInterface<Baseball> getBallUserInterface() { return BallUserInterfaceFactory.getUserInterface(this); } }
To make things a little neater, it's better to make getBallUserInterface package private and provide a generic getter in BallUserInterfaceFactory. The factory can then manage additional checks like for null and any thrown exceptions. eg.
public class BallUserInterfaceFactory { public static BallUserInterface<Baseball> getUserInterface( Baseball ball) { return new BallUserInterface<Baseball>(ball); } public static <T extends Ball<T>> BallUserInterface<T> getUserInterface( T ball) { return ball.getBallUserInterface(); } }
The Visitor Pattern
As pointed out in the comments, one problem of the above is it requires the Ball classes to have knowledge of the UI, which is highly undesirable. You can, however, use the visitor pattern, which enables you to use double dispatch, but also decouples the various Ball classes and the UI.
First, the necessary visitor classes, and factory functions:
public interface Visitor<T> { public T visit(Baseball ball); public T visit(Football ball); } public class BallUserInterfaceVisitor implements Visitor<BallUserInterface<? extends Ball>> { @Override public BallUserInterface<Baseball> visit(Baseball ball) { // Since we now know the ball type, we can call the appropriate factory function return BallUserInterfaceFactory.getUserInterface(ball); } @Override public BallUserInterface<Football> visit(Football ball) { return BallUserInterfaceFactory.getUserInterface(ball); } } public class BallUserInterfaceFactory { public static BallUserInterface<? extends Ball> getUserInterface(Ball ball) { return ball.accept(new BallUserInterfaceVisitor()); } // other factory functions for when concrete ball type is known }
You'll note that the visitor and the factory function have to use wildcards. This is necessary for type safety. Since you don't know what type of ball has been passed, the method cannot be sure of what UI is being returned (other than it is a ball UI).
Secondly, you need to define an abstract accept method on Ball that accepts a Visitor. Each concrete implementation of Ball must also implement this method for the visitor pattern to work correctly. The implementation looks exactly the same, but the type system ensures dispatch of the appropriate methods.
public interface Ball { public <T> T accept(Visitor<T> visitor); } public class Baseball implements Ball { @Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); } }
Finally, a bit of code that can put all this together:
Ball baseball = new Baseball(); Ball football = new Football(); List<BallUserInterface<? extends Ball>> uiList = new ArrayList<>(); uiList.add(BallUserInterfaceFactory.getUserInterface(baseball)); uiList.add(BallUserInterfaceFactory.getUserInterface(football)); for (BallUserInterface<? extends Ball> ui : uiList) { System.out.println(ui); } // Outputs: // ui.BaseballUserInterface@37e247e2 // ui.FootballUserInterface@1f2f0ce9
