Java 工厂模式和依赖关系_Java_Oop_Design Patterns_Factory Pattern

Java 工厂模式和依赖关系

java oop design-patterns

Java 工厂模式和依赖关系,java,oop,design-patterns,factory-pattern,Java,Oop,Design Patterns,Factory Pattern,工厂方法用于避免违反开闭原则。而不是通过继承创建对象： Product myProd = new ConcreteProduct1; // concreteProduct extends abstract product myProd.doSomething(); 我们将工厂“接口”用于具体工厂（实现工厂并超越其方法的类）：我读了很多关于工厂方法的书；我明白，使用工厂方法，可以排除开闭原则的恶意。但我还是不明白：使用这种设计模式，我们仍然依赖于类产品（myProd）（1）而且。。我们对

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

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

我们将工厂“接口”用于具体工厂（实现工厂并超越其方法的类）：

我读了很多关于工厂方法的书；我明白，使用工厂方法，可以排除开闭原则的恶意。但我还是不明白：

使用这种设计模式，我们仍然依赖于类产品（myProd）（1）

而且。。我们对具体工厂有依赖关系（客户需要实例化一个特定的想要的具体工厂，客户必须知道一个）（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;
    }
}

class批量生产{
产品工厂；
公共MyClass（ProductFactory事实）{
工厂=fac；
}
公共列表产品（整数金额）{
ArrayList结果=新ArrayList（金额）；
对于（int i=0；i


我们决不依赖于ConcreteProduct
或ConcreteFactory

我们确实依赖于产品
，但关键是要消除对具体产品
的依赖
不，我们不依赖于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;
    }
}

class批量生产{
产品工厂；
公共MyClass（ProductFactory事实）{
工厂=fac；
}
公共列表产品（整数金额）{
ArrayList结果=新ArrayList（金额）；
对于（int i=0；i

在任何情况下，我们都不依赖于ConcreteProduct
或ConcreteFactory
您可能不需要使用整个概念
下面是一个用例：
// 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();
    }
}

//定义接口
公共接口产品{}
公共接口产品工厂{
公共产品创造产品（）；
}
//创建一些实现者
公营运动衫产品{
静态最终产品工厂=新产品工厂（）{
公共产品{
退回新运动衫（）；
}
}
}
公共类产品{
静态最终产品工厂=新产品工厂（）{
公共产品{
退回新裤子（）；
}
}
}
实现产品的公共类{
静态最终产品工厂=新产品工厂（）{
公共产品{
归还新帽子（）；
}
}
}
//创建一个客户端类
类别股票{
private List您可能并不完全处于需要使用整个概念的位置
下面是一个用例：
// 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();
    }
}

//定义接口
公共接口产品{}
公共接口产品工厂{
公共产品创造产品（）；
}
//创建一些实现者
公营运动衫产品{
静态最终产品工厂=新产品工厂（）{
公共产品{
退回新运动衫（）；
}
}
}
公共类产品{
静态最终产品工厂=新产品工厂（）{
公共产品{
退回新裤子（）；
}
}
}
实现产品的公共类{
静态最终产品工厂=新产品工厂（）{
公共产品{
归还新帽子（）；
}
}
}
//创建一个客户端类
类别股票{
私有列表你使用工厂的方式是错误的。工厂通常有提供“产品”的静态方法。但是在你（2）的代码中，你甚至没有使用myFact。我犯了一个错误，代码更新了。你使用工厂的方式是错误的。工厂通常有提供“产品”的静态方法。但是在（2）的代码中您使用myFact时甚至没有使用它。我犯了一个错误，更新了代码。对于这个奇妙的示例，我请您最后澄清：调用MassProduction的客户机。MyClass（fact）必须了解ConcreteFactorys（witch fact）.有办法避免这种情况吗？坦克you@Marco是的，有人最终当然必须通过一门具体的课程，但只是在最后。关键是，客户将能够使用批量生产
设施，而不必批量生产
了解客户的产品。在我有工厂myFa之前ct=new ConcreteFact1现在我有了：Factory myfactory=new MassProduct；myfactory.myClass（new ConcreteFactory1（））；这对我来说是一个很大的迷雾。关于这个奇妙的例子，我请你最后澄清：调用MassProduction的客户。myClass（事实）必须了解ConcreteFactory（巫婆事实）.有办法避免这种情况吗？坦克you@Marco是的，有人最终当然必须通过一门具体的课程，但只是在最后。关键是，客户将能够使用批量生产
设施，而不必批量生产
了解客户的产品。在我有工厂myFa之前ct=new ConcreteFact1现在我有：Factory myfactory=new MassProduct；myfactory.myClass（new ConcreteFactory1（））；这对我来说是一个很大的迷雾..向你寻求帮助，但我仍然不明白：现在情况是回来了..在静态main中，我们又一次直接依赖于concreteProducts。（我们需要导入相关类）静态主程序是您的主程序