[设计模式]抽象工厂模式

简介

---

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

抽象工厂模式是一种 类建立型模式 （ 可参考 设计模式 建立型模式）。

结构

---

图-抽象工厂模式结构图

抽象工厂模式包含如下角色：

• AbstractFactory（抽象工厂）
  
• ConcreteFactory（具体工厂）
• AbstractProduct（抽象产品）
• ConcreteProduct（具体产品）
  

AbstractProduct : 声明一个接口，这个接口中包含产品对象类型。

abstract  class AbstractProductA {
     public  abstract  void show();
}

abstract  class AbstractProductB {
     public  abstract  void show();
}

ConcreteProduct : 定义一个产品对象，这个产品对象是由相关的具体工厂建立的。

class ConcreteProductA1  extends AbstractProductA {
    @Override
     public  void show() {
        System.out.println("ConcreteProductA1");
    }
}

class ConcreteProductA2  extends AbstractProductA {
    @Override
     public  void show() {
        System.out.println("ConcreteProductA2");
    }
}

class ConcreteProductB1  extends AbstractProductB {
    @Override
     public  void show() {
        System.out.println("ConcreteProductB1");
    }
}

class ConcreteProductB2  extends AbstractProductB {
    @Override
     public  void show() {
        System.out.println("ConcreteProductB2");
    }
}

AbstractFactory : 声明一个接口，这个接口中包含建立抽象产品对象的方法。

abstract  class AbstractFactory {
     public  abstract AbstractProductA createProductA();
     public  abstract AbstractProductB createProductB();
}

ConcreteFactory : 实现建立具体产品对象的方法。

class ConcreteFactory1  extends AbstractFactory {
    @Override
     public AbstractProductA createProductA() {
         return  new ConcreteProductA1();
    }

    @Override
     public AbstractProductB createProductB() {
         return  new ConcreteProductB1();
    }
}

class ConcreteFactory2  extends AbstractFactory {
    @Override
     public AbstractProductA createProductA() {
         return  new ConcreteProductA2();
    }

    @Override
     public AbstractProductB createProductB() {
         return  new ConcreteProductB2();
    }
}

Client : 只使用 AbstractFactory 和 AbstractProduct 声明的接口。

public  class AbstarctFactoryPattern {
     public  static  void main(String[] args) {
        AbstractFactory  factory1  =  new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.show();
        productB1.show();
        
        AbstractFactory  factory2  =  new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.show();
        productB2.show();
    }
}

运行结果

ConcreteProductA1
ConcreteProductB1
ConcreteProductA2
ConcreteProductB2

 

动机

---

一个系统要独立于它的产品的建立、组合和表示时。

一个系统要由多个产品系列中的一个来配置时。

当你要强调一系列相关的产品对象的设计以便进行联合使用时。

当你提供一个产品类库，而只想显示它们的接口而不是实现时。

要点

---

优势

（1）抽象工厂模式隔离了具体类的生成，用户并不须要知道什么被建立。因为这种隔离，更换一个具体工厂变得相对容易。全部的具体工厂都实现了抽象工厂中定义的那些公共接口，所以只须要改变具体工厂的实例，就能够在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式能够实现高内聚低耦合的设计目的，所以抽象工厂模式获得了普遍的应用。

（2）当一个产品族中的多个对象被设计成一块儿工做时，它可以保证客户端始终只使用同一个产品族中的对象。这对一些须要根据当前环境来决定其行为的软件系统来讲，是一种很是实用的设计模式。

（3）增长新的具体工厂和产品族很方便，无须修改已有系统，符合“开放封闭原则”。

缺点

在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是由于在抽象工厂角色中规定了全部可能被建立的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其全部子类的修改，显然会带来较大的不便。

实例

---

众所周知，苹果和三星这两家世界级的电子产品厂商都生产手机和电脑。

咱们以生产手机和电脑为例，演示一下抽象工厂模式的应用

AbstractProduct 角色

首先，定义手机和电脑两个抽象接口，他们都有各自的产品信息

interface Telephone {
     public String getProductInfo();
}

interface Computer {
     public String getProductInfo();
}

ConcreteProduct 角色

ConcreteProduct 根据 AbstractProduct 来定义具体的产品属性、方法。

在咱们的例子中，苹果、三星两家公司的手机和电脑都有各自的具体产品信息。

class AppleTelephone  implements Telephone {

    @Override
     public String getProductInfo() {
         return "苹果手机，采用ios系统";
    }
}

class SamsungTelephone  implements Telephone {

    @Override
     public String getProductInfo() {
         return "三星手机，采用android系统";
    }
}

class AppleComputer  implements Computer {

    @Override
     public String getProductInfo() {
         return "苹果电脑，采用mac系统";
    }
}

class SamsungComputer  implements Computer {

    @Override
     public String getProductInfo() {
         return "三星电脑，采用windows系统";
    }
}

AbstractFactory 角色

苹果，三星这两个厂商都生产手机和电脑。因此它们能够有一个抽象父类或父接口，提供生产手机和生产电脑的方法。

interface ElectronicFactory {
    
     public Telephone produceTelephone();

     public Computer produceComputer();
}

ConcreteFactory 角色

苹果、三星工厂分别实现父接口，生产不一样类型的产品。

class AppleFactory  implements ElectronicFactory {

    @Override
     public Telephone produceTelephone() {
         return  new AppleTelephone();
    }

    @Override
     public Computer produceComputer() {
         return  new AppleComputer();
    }
}

class SamsungFactory  implements ElectronicFactory {

    @Override
     public Telephone produceTelephone() {
         return  new SamsungTelephone();
    }

    @Override
     public Computer produceComputer() {
         return  new SamsungComputer();
    }
}

测试代码

public  class PhoneFactoryDemo {
     public  static  void main(String[] args) {
        ElectronicFactory appleFactory =  new AppleFactory();
        Telephone phone = appleFactory.produceTelephone();
        System.out.println(phone.getProductInfo());
        Computer computer = appleFactory.produceComputer();
        System.out.println(computer.getProductInfo());
    }
}

运行结果

苹果手机，采用ios系统
苹果电脑，采用mac系统

 

推荐阅读

---

本文属于 设计模式系列 。

简单工厂模式属于工厂模式家族，欢迎参考阅读 简单工厂模式 、工厂方法模式 。

参考资料

《大话设计模式》 《HeadFirst设计模式》