Is it OK to use covariance of types with abstract factory pattern

Question

I'm learning about design patterns from GOF book.

There is one thing about Abstract Factory pattern implementation that makes me mingle. I'll start with code:

Abstract Factory:

public interface AnimalsFactory {

    Animal getWaterAnimal();

    Animal getLandAnimal();

    Animal getFlyingAnimal();
}

Concrete Factory:

public class SafariAnimalsFactory implements AnimalsFactory {

    @Override
    public Hippo getWaterAnimal() {
        return new Hippo();
    }

    @Override
    public Giraffe getLandAnimal() {
        return new Giraffe();
    }

    @Override
    public Vulture getFlyingAnimal() {
        return new Vulture();
    }
}

I used covariance of types so factory methods return concrete products instead of abstract products (Animal).

I like it but doesn't this violate rule of thumb about products being encapsulated from the client? Or maybe I'm overthinking this.

Answer 1

Using covariance in this situation is great. This is a perfect case for demonstrating the power of covariant overrides in Java, because it lets you have the best of both worlds:

• If you deal with a factory by programming to its interface, the implementation is perfectly hidden from you
• If, on the other hand, you deal with the factory directly, you can avoid casts.