Question

I’ve got a question regarding the best-practices of Java inheritance & composition:

Say you’ve got a Fruit which gets extended by Apple and Lemon.

Next to these you also got a Basket that gets extended by AppleBasket
and LemonBasket.

Fruits have a bidirectional one-to-many relationship with their
respective baskets, so Fruits have a basket, and baskets have a list
of fruits.

Now the thing I’d like to do is enforce the AppleBasket to only have Apples at compile time, and likewise for LemonBaskets. Similarly the Apple should only have an AppleBasket as property, and likewise for Lemons.

I’ve tried using generics, abstract methods and protected variables, yet I always find reasons not to go for a certain approach. It’s important we don’t break the SOLID principles, so for example the superclasses should contain the has-a and has-many properties to avoid code duplication and so on.

It’s key to get compiler errors when someone tries to put a Lemon inside an AppleBasket and vice versa.

Cheers,
Andreas

Answer 1

You might find some useful information about more complex typing by googling for covariance and contravariance.

If you don’t mind using Scala, which compiles to bytecode you can use with Java programs, Scala’s gives you some nice syntax for doing this sort of thing (Java later):

class Fruit
class Basket[T <: Fruit ] {
    def addToBasket(fruit:T) =  {}
}

class Apple extends Fruit
class Lemon extends Fruit

class AppleBasket extends Basket[Apple]

val applebasket = new AppleBasket

applebasket.addToBasket(new Apple)

applebasket.addToBasket(new Lemon)

The last line of this code snippet gives the compile time error:

 $ scala Test.scala
C:\cygwin\home\user\Test.scala:18: error: type mismatch;
 found   : this.Lemon
 required: this.Apple
applebasket.addToBasket(new Lemon)
                        ^
one error found

I’ve been playing with Scala so much lately I’m having trouble thinking about this in Java, but in Java I’d probably do something more like this:

class Fruit{}
class Apple extends Fruit{}
class Lemon extends Fruit{}
class Basket<T extends Fruit>{
    public void addToBasket(T foo) {}
}
class Blah {
    void doIt() {
        Apple a = new Apple();
        Basket b = new Basket<Apple>();
        b.addToBasket(a);
        Lemon l = new Lemon();
        b.addToBasket(l);
    }
}

The b.addToBasket(l) line gives the following compile time type error:

The method addToBasket(Apple) in the type Basket<Apple> is not applicable for the arguments (Lemon)

Another option that gives the same compile error (copying from comments to make it clearer):

//same definition of Fruit, Apple, and Basket, but with:
class AppleBasket extends Basket<Apple> {}
class Blah {
    void doIt() {
        Apple a = new Apple();
        Basket<Apple> b = new AppleBasket();
        b.addToBasket(a);
        Lemon l = new Lemon();
        b.addToBasket(l);
    }
}