可以使用抽象工厂模式的类型协方差

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.