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

Question

这个问题已经在这里有了答案：

• 工厂模式。 什么时候使用工厂方法？ 15个答案

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

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. 此外..我们对混凝土工厂具有依赖性（客户需要实例化特定的所需混凝土工厂，客户必须了解巫婆）（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引用，但是它使用给定的Factory来创建Product 。 连接这两者的是驱动程序类（客户端类Stock和具体产品）。