Java: returning subclass in superclass method sign

问题:

I'm working on a problem where there are several implementations of Foo, accompanied by several FooBuilder's. While Foo's share several common variables that need to be set, they also have distinct variables that require their respective FooBuilder to implement some specific functionality. For succinctness, I'd like to have the FooBuilder's setters to use method chaining, like:

public abstract class FooBuilder {
  ...

  public FooBuilder setA(int A) {
    this.A = A;
    return this;
  }

  ...
}

and

public class FooImplBuilder extends FooBuilder{
  ...
  public FooImplBuilder setB(int B) {
    this.B = B;
    return this;
  }
  public FooImplBuilder setC(int C) {
    this.C = C;
    return this;
  }
  ...
}

And so on, with several different FooBuilder implementations. This technically does everything I want, however, this approach is sensitive to the order of methods calls when method chaining is performed. The following has method undefined compile errors:

someFoo.setA(a).setB(b)...

Requiring that the developer think about the order of method calls in the chain. To avoid this, I'd like to have the setters in FooBuilder somehow return the actual implementing subclass. However, I'm not sure how to do this. What is the best approach?

回答1:

This is a good question and a real problem.

The easiest way to deal with it in Java likely involves the use of generics, as mentioned in Jochen's answer.

There's a good discussion of the issue and a reasonable solution in this blog entry on Using Inheritance with Fluent Interfaces, which combines generics with the definition of a getThis() method overriden in builder subclasses to solve the problem of always returning a builder of the correct class.

回答2:

Generics might be the way to go here.

If you declare setA() something like this (pseudo-code)

<T> T setA(int a)

the compiler should be able to figure out the real types, and if it doesn't you can give hints in the code like

obj.<RealFoo>setA(42)

回答3:

Having found this excellent answer I am now sharing it around.

public class SuperClass<I extends SuperClass>
{
    @SuppressWarnings( "unchecked" ) // If you're annoyed by Lint.
    public I doStuff( Object withThings )
    {
        // Do stuff with things.
        return (I)this ; // Will always cast to the subclass. Causes the Lint warning.
    }
}

public class ImplementationOne
extends SuperClass<ImplementationOne>
{} // doStuff() will return an instance of ImplementationOne

public class ImplementationTwo
extends SuperClass<ImplementationTwo>
{} // doStuff() will return an instance of ImplementationTwo