Java: Overriding an abstract method in subclass

Question

I really should know this, but for some reason I don't understand the following.

My abstract class contains the following abstract method:

protected abstract RuleDTO createRowToBeCloned(RuleDTO ruleDTO);

I also have another class as follows:

EvaluationRuleDTO extends from RuleDTO

Then in a subclass of my abstract class I have the following implementation which is not allowed due to "must override or implement a supertype method":

protected EvaluationRuleDTO createRowToBeCloned(EvaluationRuleDTO ruleDTO) {

However, the following is allowed:

protected EvaluationRuleDTO createRowToBeCloned(RuleDTO ruleDTO) {

I realize this is probably a basic question but I am a little bemused. How come I can I can return a subclass of RuleDTO in the overridden method, but I can't pass in a subclass?

Thanks

Answer 1

You're breaking the Liskov principle: everything a superclass can do, a subclass must be able to do. The superclass declares a method accepting any kind of RuleDTO. But in your subclass, you only accept instances of EvaluationRuleDTO. What would happen if you did the following?

RuleDTO rule = new EvaluationRuleDTO();
rule.createRowToBeCloned(new RuleDTO());

An EvaluationRuleDTO is a RuleDTO, so it must fulfill the contract defined by RuleDTO.

The method in the subclass may return an instance of EvaluationRuleDTO instead of a RuleDTO, though, because the contract is to return a RuleDTO, and EvaluationRuleDTO is a RuleDTO.

Answer 2

Java allows return type covariance for overrides, so you can specify the return type of an override as a more-derived type. However, Java does not allow parameter type covariance for overrides.

The reason the former is safe is that the object you return will have, at minimum, the functionality of the less-derived type, so a client relying on that fact will still be able to utilize the returned object correctly.

That's not the case for the arguments, though. If it were legal, a user could call the abstract method and pass in a less-derived type (since that's the type declared on the abstract class,) but then your derived override might try to access the argument as a more-derived type (which it isn't) resulting in an error.

In theory, Java could have allowed parameter-type contra-variance, since that is type-safe: if the overriden method only expects a less-derived argument, you can't accidentally utilize a method or field that's not there. Unfortunately, that is not currently available.