Design: Java and returning self-reference in setter methods
This is called a Fluent Interface, for reference.
Personally, I think it's a pretty neat idea, but a matter of taste really. I think jQuery works this way.
I find this to be in poor style when used in setters. Immutable classes are usually a better fit for chaining, such as:
aWithB = myObject.withA(someA).withB(someB);
where myObject
is of this class:
class MyClass {
withA(TypeA a) {
this.a.equals(a) ? this : new MyClass(this, a);
}
private MyClass(MyClass copy, TypeA a) {
this(copy);
this.a = a;
}
}
The builder pattern is also useful, since it allows the final object to be immutable while preventing the intermediate instances you would normally have to create when using this technique.
@pek
Chained invocation is one of proposals for Java 7. It says that if a method return type is void, it should implicitly return this. If you're interested in this topic, there is a bunch of links and a simple example on Alex Miller's Java 7 page.
I wouldn't do it myself, because to me it muddies what a particular method does, and the method-chaining is of limited use to me over doing it longhand. It isn't going to send me into a quivering ball of rage and psychosis, though, which is always a good thing. :')
I wouldn't be concerned about performance; just ask Knuth.