Factory Pattern and dependencies

Question

The factory method is used to avoid violation of Open-closed principle. Instead of creating an object by inheritage:

Product myProd = new ConcreteProduct1; // concreteProduct extends abstract product
myProd.doSomething();

we use a factory "interface" with relatives concrete factories (classes that implement factory and overrride its methods):

Factory myFact = new ConcreteFact1; // (2)
Product myProd = myFact.createProd();   // (1)
myProd.doSomething(); // (1)

I read much about factory method; I understood that, using factory method, it's possible to exclude vilations of the open-closed principle. But I still don't understand:

1. with this design pattern we have still a dependency to class Product (myProd) (1)
2. moreover.. we have a dependency with Concrete-Factories (client needs to instantiate a specific wanted concrete factory and client must know witch one) (2)

Tank you for any clarification.

Answer 1

1. We do have a dependency on Product, but the point is to eliminate the dependency on ConcreteProduct.

2. No, we don't have a dependency on ConcreteFactory because we get passed the factory as a parameter.

   class MassProduction {
       ProductFactory factory;
       public MyClass(ProductFactory fact) {
          factory = fac;
       }
       public List<Product> produce(int amount) {
           ArrayList<Product> result = new ArrayList<>(amount);
           for (int i = 0; i < amount; i++) { 
               result.add(factory.createProduct());
           }
           return result;
       }
   }
   

At no point do we have a dependency on either ConcreteProduct or ConcreteFactory.

Answer 2

You might not exactly in a position needing to use the whole concept.

Here's a use case:

// define the interfaces
public interface Product {}
public interface ProductFactory {
    public Product createProduct();
}
// create some implementors
public class Sweatshirt implements Product {
    static final ProductFactory FACTORY = new ProductFactory() {
        public Product createProduct() {
            return new Sweatshirt();
        }
    }
}
public class Pants implements Product {
    static final ProductFactory FACTORY = new ProductFactory() {
        public Product createProduct() {
            return new Pants();
        }
    }
}
public class Hat implements Product {
    static final ProductFactory FACTORY = new ProductFactory() {
        public Product createProduct() {
            return new Hat();
        }
    }
}

// create a client class
class Stock {
    private List<? extends Product> stock = new ArrayList<>();
    public void add(int amount, ProductFactory fac) {
        for (int i = 0; i < amount; i++) {
            stock.add(fac.createProduct());
        }
    }
    public void printAll() {
        stock.forEach(p -> System.out.println(p.getClass()));
    }
}

// driver class that allows the user to enter amounts and product type
// and adds them to the stock until any entry is invalid
class InventoryManagement {
    public static void main(String[] args) {
        Stock stock = new Stock();
        try (Scanner sc = new Scanner(System.in)) {
            while (true) {
                // read amount from console input
                int amount = sc.nextInt();
                // read type from console input
                String value = sc.next();
                ProductFactory factory = null;
                switch(value) {
                    case "s":
                         factory = Sweatshirt.FACTORY;
                         break;
                    case "p":
                         factory = Pants.FACTORY;
                         break;
                    case "h":
                         factory = Hat.FACTORY;
                         break;
                 }
                 if (factory != null) {
                     stock.add(amount, factory);
                 } else {
                     break;
                 }
            }
        } catch (Exception e) {} 
        stock.printAll();
    }
}

As you can see, the client class (Stock) doesn't have any references to any concrete Product or Factory, but it uses the given Factorys to create Products. It's the driver class that connects the two (the client class Stock and the concrete products).