Java23种设计模式案例：抽象工厂模式（abstractFactory）

        抽象工厂模式是全部形态的工厂模式中最为抽象和最具通常性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式能够向客户端提供一个接口，使客户端在没必要指定产品的具体的状况下，建立多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当可以接受子类型。所以，实际上系统所须要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责建立抽象产品的具体子类的实例。

        一、工厂方法模式和抽象工厂模式区别

工厂方法模式：
一个抽象产品类，能够派生出多个具体产品类。   
一个抽象工厂类，能够派生出多个具体工厂类。   
每一个具体工厂类只能建立一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每一个抽象产品类能够派生出多个具体产品类。   
一个抽象工厂类，能够派生出多个具体工厂类。   
每一个具体工厂类能够建立多个具体产品类的实例，也就是建立的是一个产品线下的多个产品。   
    
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能建立一个具体产品类的实例，而抽象工厂模式能够建立多个。
工厂方法建立 "一种" 产品，他的着重点在于"怎么建立"，也就是说若是你开发，你的大量代码极可能围绕着这种产品的构造，初始化这些细节上面。也由于如此，相似的产品之间有不少能够复用的特征，因此会和模版方法相随。 

抽象工厂须要建立一些列产品，着重点在于"建立哪些"产品上，也就是说，若是你开发，你的主要任务是划分不一样差别的产品线，而且尽可能保持每条产品线接口一致，从而能够从同一个抽象工厂继承。
对于java来讲，你能见到的大部分抽象工厂模式都是这样的：
---它的里面是一堆工厂方法，每一个工厂方法返回某种类型的对象。

好比说工厂能够生产鼠标和键盘。那么抽象工厂的实现类（它的某个具体子类）的对象均可以生产鼠标和键盘，但可能工厂A生产的是罗技的键盘和鼠标，工厂B是微软的。

这样A和B就是工厂，对应于抽象工厂；
每一个工厂生产的鼠标和键盘就是产品，对应于工厂方法；

用了工厂方法模式，你替换生成键盘的工厂方法，就能够把键盘从罗技换到微软。可是用了抽象工厂模式，你只要换家工厂，就能够同时替换鼠标和键盘一套。若是你要的产品有几十个，固然用抽象工厂模式一次替换所有最方便（这个工厂会替你用相应的工厂方法）

因此说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线。

        二、适用场景

        1）系统不依赖于产品类实例如何被建立，组合和表达的细节。

        2）系统的产品有多于一个的产品族，而系统只消费其中某一族的产品（抽象工厂模式的原始用意Unix&Windows）

        3）同属于同一个产品族是在一块儿使用的。这一约束必须在系统的设计中体现出来。

        4）系统提供一个产品类的库，全部产品以一样的接口出现，从而使客户端不依赖于实现。

        三、优势

1）它分离了具体的类
2）它使得易于交换产品系列
3）它有利于产品的一致性

        四、缺点

1）难以支持新种类的产品，不符合开闭原则

        五、代码示例

            1）关系图

                

            2）代码实现

//定义不一样的产品之间的必定具有的标准，用interface实现 
//其中的method()方法可看做提取出不一样产品的共性，如手机都有相似的功能 
interface IProductA{ 
  public void method(); 
} 

interface IProductB{ 
  public void method(); 
} 

//实现了产品标准实现的一系列具体产品 
//因为已经设计好A1由厂商1生产，故如下输出代码有“厂商x” 
class ProductA1 implements IProductA{ 
  public void method() { 
    System.out.println("厂商1    生产ProductA1 ..."); 
  } 
} 

class ProductA2 implements IProductA{ 
  public void method() { 
    System.out.println("厂商2    生产ProductA2 ..."); 
  } 
} 

class ProductB1 implements IProductB{ 
  public void method() { 
    System.out.println("厂商1    生产ProductB1 ..."); 
  } 
} 

class ProductB2 implements IProductB{ 
  public void method() { 
    System.out.println("厂商2    生产ProductB2 ..."); 
  } 
} 

//每一种牌子的产品生产工厂，即不一样的厂商负责本身牌子产品的生产 
abstract class Factory1{ 
  abstract IProductA getProductA1(); 
  abstract IProductB getProductB1(); 
} 

abstract class Factory2{ 
  abstract IProductA getProductA2(); 
  abstract IProductB getProductB2(); 
} 

//具体的工厂用来生产相关的产品 
class ConcreteFactory1 extends Factory1{ 
  public IProductA getProductA1() { 
    return new ProductA1(); 
  } 
  public IProductB getProductB1() { 
    return new ProductB1(); 
  } 
} 

class ConcreteFactory2 extends Factory2{ 
  public IProductA getProductA2() { 
    return new ProductA2(); 
  } 
  public IProductB getProductB2() { 
    return new ProductB2(); 
  } 
} 

//测试类 
public class Client { 
  public static void main(String[] args) { 
    //厂商1负责生产产品A一、B1 
    Factory1 factory1 = new ConcreteFactory1(); 
    IProductA productA1 = factory1.getProductA1(); 
    IProductB productB1 = factory1.getProductB1(); 
     
    productA1.method(); 
    productB1.method(); 
     
    //厂商2负责生产产品A二、B2 
    Factory2 factory2 = new ConcreteFactoryB(); 
    IProductA productA2 = factory2.getProductA2(); 
    IProductB productB2 = factory2.getProductB2(); 
     
    productA2.method(); 
    productB2.method(); 
  } 
}

执行结果：
厂商1  生产ProductA1 ...
厂商1  生产ProductB1 ...
厂商2  生产ProductA2 ...
厂商2  生产ProductB2 ...