Java设计模式——抽象工厂模式

  • 2019-10-27
  • 289
  • 0

定义

是一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂可生产多个等级的产品。使用抽象工厂模式一般要满足以下条件:

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

优缺点

优点:

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

缺点:

  • 当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改

模式的结构与实现

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

代码实例:

package com.taobao.gpf.metis;

public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            AbstractFactory abstractFactory = new ConcreteFactory1();
            abstractFactory.createProductA().use();
            abstractFactory.createProductB().eat();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

//抽象产品:提供了产品A系列的接口
interface InterfaceProductA {
    void use();
}

//抽象产品:提供产品B系列的接口
interface InterfaceProductB{
    void eat();
}

//具体产品1:实现抽象产品中的抽象方法
class ProductA1 implements InterfaceProductA {
    public void use() {
        System.out.println("具体产品A1显示...");
    }
}

//具体产品1:实现抽象产品中的抽象方法
class ProductA2 implements InterfaceProductA {
    public void use() {
        System.out.println("具体产品A2显示...");
    }
}



//具体产品1:实现抽象产品中的抽象方法
class ProductB1 implements InterfaceProductB {
    public void eat() {
        System.out.println("具体产品B1显示...");
    }
}

//具体产品1:实现抽象产品中的抽象方法
class ProductB2 implements InterfaceProductB {
    public void eat() {
        System.out.println("具体产品B2显示...");
    }
}

//抽象工厂:提供了厂品的生成方法
interface AbstractFactory
{
    public InterfaceProductA createProductA();
    public InterfaceProductB createProductB();
}

//具体工厂1:实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory
{

    @Override
    public InterfaceProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public InterfaceProductB createProductB() {
        return new ProductB1();
    }
}

//具体工厂2:实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory
{

    @Override
    public InterfaceProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public InterfaceProductB createProductB() {
        return new ProductB2();
    }
}

适用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时,便可以使用抽象工厂模式。说的更明白一点,就是一个继承体系中,如果存在着多个等级结构(即存在着多个抽象类),并且分属各个等级结构中的实现类之间存在着一定的关联或者约束,就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束,则使用多个独立的工厂来对产品进行创建,则更合适一点。

感谢打赏!
微信

评论

还没有任何评论,你来说两句吧