继承 - 重写mutator方法？

Question

So, let's say I have the following classes:

Foo

abstract class Foo{
    .
    .
    .
    public void setKey(FooKey key){
        this.key = key;
    }
}

Bar

final class Bar extends Foo{
    .
    .
    .
    @Override
    public void setKey(BarKey key){ // Can't do this?
        super.setKey(key);
    }
}

In the above example, BarKey is a subclass of FooKey . Here I want to ensure that the key that is set for Bar is a specific subclass of FooKey (ie BarKey ). How do I go about this? Am I making this overly complicated? Is there a better design approach?

Answer 1

This isn't correct, because you're making the subclass more restrictive than the superclass: the superclass makes it possible to set any kind of FooKey, but the subclass only accepts BarKey.

In order to do this, you need to make the superclass generic:

abstract class Foo<K extends FooKey> {
    private K key;

    public void setKey(K key){
        this.key = key;
    }
}

final class Bar extends Foo<BarKey> {
}

Answer 2

You can't enforce it that way. Consider:

Bar b = new Bar();
FooKey k = new FooKey();
b.setKey(k);  // You want to prohibit this
Foo f = b;
f.setKey(k);  // But there's no way to prohibit this

In general, a derived class can't offer a more restrictive interface than its superclass.

So I would suggest removing setKey from the abstract class.

Answer 3

You should read about difference between overriding and overloading. The thing you did is simply overloading because you change the argument type which is not allow with overriding.

Answer 4

Simply remove the @Override annotation as you're not overriding the method of the super class, (should be same arguments), you're just defining a new setKey method with a narrower type. This new setKey method will be accessible only through a Bar reference, however.