04-抽象工厂模式

抽象工厂模式

抽象工厂（AbstractFactory）模式是一种为访问类提供一个创建一组相关或互相依赖对象的接口，且访问者无需指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式一个工厂只能生产一个产品，而抽象工厂模式一个工厂可以生成多个产品。

模式的结构与实现

简单工厂模式的主要角色：

• 抽象工厂(Abstract Factory):提供了创建产品的接口，包含多个newProduct()方法，可以创建多个不同等级的产品。
• 具体工厂(Factory)：主要实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品(AbstractProduct)：定义了产品的规范，描述了产品的主要特征和功能。抽象工厂模式有多个抽象产品。
• 具体产品(Product)：实现抽象产品角色所定义的接口，由具体工厂来创建，同具体工厂是多对一的关系。

UML类图

实例

需求：家具生产商，可以生产出一系列产品，如椅子Chair、沙发Sofa，产品由不同的风格，如现代Modern、维多利亚Victorian。顾客前来购买需要按整套风格来选择，所以需要设法单独生成每一件家具才可以确保风格一致。
实现代码步骤如下：

1. 创建产品顶层抽象类,这里需要抽象出两接口AbstractProductChair,AbstractProductSofa

   //抽象产品椅子接口
    public interface AbstractProductChair {
        void newProduct();
    }

   //抽象产品沙发接口
    public interface AbstractProductSofa {
        void newProduct();
    }

2. 创建具体的产品类

   //现代风格的椅子产品
    public class ProductChairModern implements AbstractProductChair {
   
        public void newProduct() {
            System.out.println("生产现代风格的椅子");
        }
    }
   //维多利亚风格的椅子产品
    public class ProductChairVictorian implements AbstractProductChair {
   
        public void newProduct() {
            System.out.println("生产维多利亚风格的椅子");
        }
    }
    //现代风格的沙发产品
    public class ProductSofaModern implements AbstractProductSofa {
   
        public void newProduct() {
            System.out.println("生产现代风格的沙发");
        }
    }
    //维多利亚风格的沙发产品
    public class ProductSofaVictorian implements AbstractProductSofa {
   
        public void newProduct() {
            System.out.println("生产维多利亚风格的沙发");
        }
    }

3. 创建抽象工厂类

   public interface AbstractFactory {
       AbstractProductChair getProductChair();
       AbstractProductSofa getProductSofa();
   }

4. 创建工厂实现类

   //生产现代风格产品工厂
    public class AbstractFactoryModern implements AbstractFactory{
   
        public AbstractProductChair getProductChair() {
            return new ProductChairModern();
        }
   
        public AbstractProductSofa getProductSofa() {
            return new ProductSofaModern();
        }
    }
    //生产维多利亚风格产品工厂
    public class AbstractFactoryVictorian implements AbstractFactory{
   
        public AbstractProductChair getProductChair() {
            return new ProductChairVictorian();
        }
   
        public AbstractProductSofa getProductSofa() {
            return new ProductSofaVictorian();
        }
    }

5. client根据调用工厂类静态方法，通过不通参数创建不同的产品实例

   public class Client {
   
       public static void main(String[] args) {
           AbstractFactoryModern abstractFactoryModern = new AbstractFactoryModern();
           AbstractProductChair productChair = abstractFactoryModern.getProductChair();
           productChair.newProduct();
           AbstractProductSofa productSofa = abstractFactoryModern.getProductSofa();
           productSofa.newProduct();
           AbstractFactoryVictorian abstractFactoryVictorian = new AbstractFactoryVictorian();
           AbstractProductChair productChair1 = abstractFactoryVictorian.getProductChair();
           productChair1.newProduct();
           AbstractProductSofa productSofa1 = abstractFactoryVictorian.getProductSofa();
           productSofa1.newProduct();
       }
   }

6. 结果输出

生产现代风格的椅子
生产现代风格的沙发
生产维多利亚风格的椅子
生产维多利亚风格的沙发

总结

优点

• 可以确保同一工厂生产的产品互相匹配。
• 避免了客户端代码和具体产品代码相互耦合。
• 单一职责原则。可以将产品生成代码抽取到同一位置，使得代码易于维护。
• 开闭原则。 向应用程序中引入新产品变体时，你无需修改客户端代码。

缺点

• 由于采用该模式需要向应用中引入众多接口和类，代码可能会比之前更加复杂。

应用场景

1. 需要创建的对象是一系列互相关联的的产品族。
2. 系统中有多个产品族，但每次只使用其中某一个产品族的产品。