java设计模式--抽象工厂模式

超、凢脫俗 2021-11-22 14:20 313阅读 0赞

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

我们先回忆一下简单工厂模式的情形，有一个创建产品的接口，需要创建不同的产品时我们就需要创建多个工厂类。

//工厂接口
    public interface IFactory {
    　　 //创建产品
        Product createProduct();
    }
    
    //具体工厂
    public class CarFactory implements IFactory {
        @Override
        public Product createProduct() {
    　　　　　//创建产品实例对象
            return new Car();
        }
    }
    
    public class BicycleFactory implements IFactory {
        @Override
        public Product createProduct() {
            return new Bicycle();
        }
    }

public class Customer {
        public static void main(String[] args) {
            IFactory carFactory = new CarFactory();
            Product car = carFactory.createProduct();
            car.run();
    
            IFactory bicycleFactory = new BicycleFactory();
            Product bicycle = bicycleFactory.createProduct();
            bicycle.run();
        }
    }

但是如果是这么一种情形呢，我们要生产的产品是一个类别，并且不再是一个，而是多个时，这种product接口就不符合情况了

我们看一个例子，假设需要不同的方法创建一系列产品

产品接口A以及实现。

public interface  ProductA {
        void Show();
    }
    
    public class ProductA1 implements ProductA {
        @Override
        public void Show() {
            System.out.println("使用工厂1生产出了产品A");
        }
    }
    
    public class ProductA2 implements ProductA {
        @Override
        public void Show() {
            System.out.println("使用工厂2生产出了产品A");
        }
    }

产品接口B以及实现。

public interface ProductB {
        void Show();
    }
    
    public class ProductB1 implements ProductB {
        @Override
        public void Show() {
            System.out.println("使用工厂1生产出了产品B");
        }
    }
    
    public class ProductB2 implements ProductB {
        @Override
        public void Show() {
            System.out.println("使用工厂2生产出了产品B");
        }
    }

工厂接口以及实现，两个具体工厂分别对应两种生产该产品的方法。

public interface Factory {
        ProductA ManufactureA();
    
        ProductB ManufactureB();
    }
    
    public class ConcreateFactory1 implements Factory {
        @Override
        public ProductA ManufactureA() {
            return new ProductA1();
        }
    
        @Override
        public ProductB ManufactureB() {
            return new ProductB1();
        }
    }
    
    public class ConcreateFactory2 implements Factory {
        @Override
        public ProductA ManufactureA() {
            return new ProductA2();
        }
    
        @Override
        public ProductB ManufactureB() {
            return new ProductB2();
        }
    }

在实际应用中，我们可能只需要某一种方法去创建产品A，B，但是当我们想要切换产品的生产方法时，就只需要将new ConcreateFactory1()替换为new ConcreateFactory2()就可以了，此时无论是哪一个工厂的方法，他生产某一个产品调用的都是同一个方法，例如factory.ManufactureA();但是如果在工厂方法模式中，我们新增一个产品的制作方法，就需要新增工厂，在客户端内去调用不同工厂的createProduct()这样就增加了系统的复杂性。

public class Test {
        public static void main(String[] args){
            Factory factory = new ConcreateFactory1();
            ProductA productA = factory.ManufactureA();
            ProductB productB = factory.ManufactureB();
            productA.Show();
            productB.Show();
    
            Factory factory2 = new ConcreateFactory2();
            ProductA productA2 = factory2.ManufactureA();
            ProductB productB2 = factory2.ManufactureB();
            productA2.Show();
            productB2.Show();
        }
    }

转载于:https://www.cnblogs.com/yimengyizhen/p/11143110.html