抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）

定义：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。）

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

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

使用抽象工厂模式一般要满足以下条件。

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当增加一个新的产品族时不需要修改原代码，满足开闭原则。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

1. 模式的结构

抽象工厂模式的主要角色如下。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。

抽象工厂类代码：

​

（1）创建相关接口：

public class Product1 implements Product1lmpl {
    @Override
    public void show() {
        System.out.println("产品1");
    }
}

public class Product2 implements Product2lmpl {
    @Override
    public void ProductNumber() {
        System.out.println("产品数据量：20");
    }
}

（2）创建接口对应实现类：

public class Product1 implements Product1lmpl {
    @Override
    public void show() {
        System.out.println("产品1");
    }
}

public class Product2 implements Product2lmpl {
    @Override
    public void ProductNumber() {
        System.out.println("产品数据量：20");
    }
}

（3）创建工厂接口

public interface IFactory {


    public Product1 CreatesProduct1();

    public Product2 CreatesProduct2();

}

（4）创建具体工厂

public  class Factory implements IFactory {


    @Override
    public Product1 CreatesProduct1() {
        return new Product1();
    }

    @Override
    public Product2 CreatesProduct2() {
        return new Product2();
    }
}

（5）测试

public class factoryAbstract {

 public static void main(String[] arg) {
     IFactory ifactory = new Factory();
     ifactory.CreatesProduct1().show();
     ifactory.CreatesProduct2().ProductNumber();
 }
}

结果：

产品1
产品数据量：20

列2

步骤 1

为形状创建一个接口。

package Factory.factoryAbstract2;

public interface Show {
    void dram();
}

步骤 2

创建实现接口的实体类（Red 实体类,Green 实体类,White 实体类）。

package Factory.factoryAbstract2;

public class Red implements Show {
    @Override
    public void dram() {
        System.out.println("Red");
    }
}

package Factory.factoryAbstract2;

public class Green implements Show {
    @Override
    public void dram() {
        System.out.println("Show");
    }
}

package Factory.factoryAbstract2;

public class White implements Show {
    @Override
    public void dram() {
        System.out.println("White");
    }
}

步骤 5

为 Show  对象创建抽象类来获取工厂。

package Factory.factoryAbstract2;

public abstract class AbstractFactory {
    public abstract Show getShow(String show);
}

步骤 6

创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

public  class ShowFactory extends AbstractFactory {
    @Override
    public Show getShow(String show) {
        if(show==null)
        {

            return null;
        }
        if(show.equalsIgnoreCase("Red"))
        {

            return new Red();
        }
        if(show.equalsIgnoreCase("Green"))
        {
            return new Green();

        }
        if(show.equalsIgnoreCase("White"))
        {
            return new White();

        }
        return null;
    }
}

步骤 7

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

public class FactoryProducer {

    public static AbstractFactory getFactory(String choise)
    {

        if(choise.equalsIgnoreCase("Show"))
        {
            return new ShowFactory();
        }
        return null;
    }
}

步骤 8

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

public static void main(String[] args)
{

    AbstractFactory showFactory=FactoryProducer.getFactory("Show");

    Show show1=showFactory.getShow("Red");
    show1.dram();

    Show show2=showFactory.getShow("Green");
    show2.dram();
}

结果：

Red
Show

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

使用场景：

一个对象族（或是一组没有任何关系的对象）都有相同的约束。

涉及不同操作系统的时候，都可以考虑使用抽象工厂模式