抽象工厂模式

简介

抽象工厂模式（Abstract Factory Pattern）指提供一个创建一系列干系或相互依赖对象的接口，无须指定它们详细的类。意思是客户端不必指定产物的详细范例，创建多个产物族中的产物对象。
与工厂方法模式相比，抽象工厂模式可以创建一组干系的对象，而不是单一的对象。
通用模板

• 创建抽象产物接口：为一类产物对象声明一个接口。
  1. // 抽象产品接口A
  2. public interface IProductA {
  3.     void doA();
  4. }

  复制代码
  2. // 抽象产品接口B
  3. public interface IProductB {
  4.     void doB();
  5. }

  复制代码
• 创建详细产物类：界说一个将被相应的详细工厂创建的产物对象，实现AbstractProduct接口。
  2. // 产品族A的具体产品A
  3. public class ProductAWithFamilyA implements IProductA {
  4.     public void doA() {
  5.         System.out.println("产品族A生产的的具体产品A...");
  6.     }
  7. }

  复制代码
  2. // 产品族A的具体产品B
  3. public class ProductBWithFamilyA implements IProductB {
  4.     public void doB() {
  5.         System.out.println("产品族A生产的的具体产品B...");
  6.     }
  7. }

  复制代码
  1. // 产品族B的具体产品A
  2. public class ProductAWithFamilyB implements IProductA {
  3.     public void doA() {
  4.         System.out.println("产品族B生产的的具体产品A...");
  5.     }
  6. }

  复制代码
  1. // 产品族B的具体产品A
  2. public class ProductBWithFamilyB implements IProductB {
  3.     public void doB() {
  4.         System.out.println("产品族B生产的的具体产品B...");
  5.     }
  6. }

  复制代码
• 创建抽象工厂接口：声明创建抽象产物对象的一个利用接口。
  2. // 抽象工厂接口
  3. public interface IFactory {
  4.     IProductA makeProductA();
  5.     IProductB makeProductB();
  6. }

  复制代码
• 创建详细工厂类：实现创建详细产物对象的利用。
  2. // 具体工厂A
  3. public class FactoryA implements IFactory{
  4.     public IProductA makeProductA() {
  5.         return new ProductAWithFamilyA();
  6.     }
  8.     public IProductB makeProductB() {
  9.         return new ProductBWithFamilyA();
  10.     }
  11. }

  复制代码
  2. // 具体工厂B
  3. public class FactoryB implements IFactory {
  4.     public IProductA makeProductA() {
  5.         return new ProductAWithFamilyB();
  6.     }
  8.     public IProductB makeProductB() {
  9.         return new ProductBWithFamilyB();
  10.     }
  11. }

  复制代码

模板测试

• 代码
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         IFactory factory = new FactoryA();
  5.         factory.makeProductA().doA();
  6.         factory.makeProductB().doB();
  8.         factory = new FactoryB();
  9.         factory.makeProductA().doA();
  10.         factory.makeProductB().doB();
  11.     }
  12. }

  复制代码
• 结果
  2. 产品族A生产的的具体产品A...
  3. 产品族A生产的的具体产品B...
  4. 产品族B生产的的具体产品A...
  5. 产品族B生产的的具体产品B...

  复制代码

应用场景

• 产物族：当一个体系必要一组干系的产物对象，即必要一个产物族时，可以利用抽象工厂模式。
  
• 产物系列独立：当产物系列中的产物是完全独立的时间，即一个系列的产物中的某个产物变更不会影响到其他系列产物时，可以思量利用抽象工厂模式。
  
• 细节潜伏：当体系必要屏蔽详细的实现细节，只向客户端袒露接口时，可以利用抽象工厂模式。
  

长处

• 封装变体：抽象工厂模式将创建干系对象的过程封装在一个工厂类中，如允许以制止客户端代码直接依赖于详细的实现类。
  
• 高内聚，低耦合：抽象工厂模式可以进步体系的内聚性，低沉各个模块之间的耦合度，使体系更轻易扩展和维护。
  
• 易于交换产物系列：在抽象工厂模式中，可以通过改变详细工厂类来改变整个产物系列，而不必要修改客户端代码。
  

“生搬硬套”实战

场景形貌

假设我们正在操持一个游戏，游戏中有多个种族（Race），每个种族都有其独特的武器（Weapon）和防具（Armor）。我们必要在游戏中根据玩家选择的种族来创建相应的武器和防具对象。我们可以利用抽象工厂模式来实现这一功能。
代码开辟

根据模板我们知道抽象工厂和工厂方法模式一样也是拢共就是4步：
我们直观比力一下两种模式区别：
（1）抽象工厂模式中产物接口变多了，每个产物都有单独的接口
（2）抽象工厂模式中工厂接口中方法变多了，创建一组干系的对象，而不是单一的对象

• 创建抽象产物（这里包罗武器和防具）接口
  2. // 武器接口
  3. public interface IWeapon {
  4.     void attack();
  5. }

  复制代码
  1. // 防具接口
  2. public interface IArmor {
  3.     void defend();
  4. }

  复制代码
• 创建详细产物（这里指为每个种族实现详细的武器和防具类）类
  1. // 人类具体武器类
  2. public class HumanWeapon implements IWeapon{
  3.     public void attack() {
  4.         System.out.println("人类武器攻击！");
  5.     }
  6. }

  复制代码
  2. // 人类具体防御类
  3. public class HumanArmor implements IArmor {
  4.     public void defend() {
  5.         System.out.println("人类防具防御！");
  6.     }
  7. }

  复制代码
  1. // 精灵具体武器类
  2. public class ElfWeapon implements IWeapon{
  3.     public void attack() {
  4.         System.out.println("精灵武器攻击！");
  5.     }
  6. }

  复制代码
  1. // 精灵具体防御类
  2. public class ElfArmor implements IArmor{
  3.     public void defend() {
  4.         System.out.println("精灵防具防御！");
  5.     }
  6. }

  复制代码
• 创建抽象工厂（这里指生产武器和防具的工厂）接口
  2. // 生产设备的工厂接口
  3. public interface IEquipmentFactory {
  4.     IWeapon createWeapon();
  6.     IArmor createArmor();
  7. }

  复制代码
• 创建详细工厂（这里指为每个种族实现详细的工厂类）类
  1. // 人类工厂
  2. public class HumanFactory implements IEquipmentFactory{
  3.     public IWeapon createWeapon() {
  4.         return new HumanWeapon();
  5.     }
  7.     public IArmor createArmor() {
  8.         return new HumanArmor();
  9.     }
  10. }

  复制代码
  2. // 精灵工厂
  3. public class ElfFactory implements IEquipmentFactory{
  4.     public IWeapon createWeapon() {
  5.         return new ElfWeapon();
  6.     }
  8.     public IArmor createArmor() {
  9.         return new ElfArmor();
  10.     }
  11. }

  复制代码

至此，我们就通过“生搬硬套”抽象工厂模式的模板操持出一套武器和防具生产工厂，接下来我们举行测试：

• 测试代码
  2. public class Client {
  3.     public static void main(String[] args) {
  4.         // 创建人类工厂
  5.         IEquipmentFactory humanFactory = new HumanFactory();
  6.         IWeapon humanWeapon = humanFactory.createWeapon();
  7.         IArmor humanArmor = humanFactory.createArmor();
  8.         humanWeapon.attack(); // 输出：人类武器攻击！
  9.         humanArmor.defend();  // 输出：人类防具防御！
  11.         // 创建精灵工厂
  12.         IEquipmentFactory elfFactory = new ElfFactory();
  13.         IWeapon elfWeapon = elfFactory.createWeapon();
  14.         IArmor elfArmor = elfFactory.createArmor();
  15.         elfWeapon.attack(); // 输出：精灵武器攻击！
  16.         elfArmor.defend();  // 输出：精灵防具防御！
  17.     }
  19. }

  复制代码
• 结果
  1. 人类武器攻击！
  2. 人类防具防御！
  3. 精灵武器攻击！
  4. 精灵防具防御！

  复制代码

总结

在抽象工厂模式中，客户端（应用层）不依赖产物类实比方何被创建、实现等细节，夸大一系列干系的产物对象（属于同一产物族）一起创建对象，必要大量重复的代码。 必要提供一个产物类的库，全部产物以同样的接口出现，从而使客户端不依赖详细实现。