Say that I have an immutable
Point class with
y parameters, and an
add method defined like this:
class Point: Point add(int x, int y): return new Point(this.x + x, this.y + y);
Since it's immutable, it returns a new Point. This is all well and good until we have a class that extends Point and redefines
class ColoredPoint extends Point: ColoredPoint add(int x, int y): return new ColoredPoint(this.x + x, this.y + y, this.width, this.height)
We have to write the new definition because otherwise the
add method on
ColoredPoint would return
Point which is bad. But now this won't work in most languages because we're overriding
add but we're only disambiguating on return type. Languages don't allow you to have methods that are only disambiguated on return type, because that can be ambiguous in most cases.
So what do we do?
The only solutions I see are:<ul><li>Make them both implement some interface like
IPositionable</li> <li>Give up on immutability.</li> </ul>
If you want to enforce immutability, you cannot have subclasses. See for example
java.lang.String, which is a
final class for this reason: To prevent people from subclassing String to make it mutable.
Also, why would
Point in the first place? Isn't it a completely different thing? Geometry-wise, they don't even exist in the same dimension.
Finally, I cannot see the connection between the problem of methods on subclasses returning a more restrained type (and some languages not supporting this well), and immutability.