工厂模式和依赖项[重复]

Question

工厂方法用于避免违反开闭原则。 而不是通过继承创建对象：

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

我们使用工厂“接口”与相关的具体工厂（实现工厂并覆盖其方法的类）：

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

我读过很多关于工厂方法的文章；我明白，使用工厂方法，可以排除开闭原则的缺陷。但我还是不明白：

1. 使用这种设计模式，我们仍然依赖于类 Product (myProd) (1)
2. 此外.. 我们与 Concrete-Factories 有依赖关系（客户需要实例化一个特定的想要的具体工厂，并且客户必须知道女巫之一）(2)

感谢您的澄清。

Answer 1

1. 我们确实对Product有依赖，但关键是要消除对ConcreteProduct的依赖。

2. 不，我们不依赖ConcreteFactory，因为我们将工厂作为参数传递。

   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;
       }
   }
   

我们绝不会依赖ConcreteProduct 或ConcreteFactory。

Answer 2

您可能并不完全需要使用整个概念。

这是一个用例：

// 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();
    }
}

如您所见，客户端类 (Stock) 没有对任何具体的Product 或Factory 的任何引用，但它使用给定的Factorys 来创建Products。它是连接两者的驱动程序类（客户端类Stock 和具体产品）。