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

定义

抽象工厂模式，由一个抽象工厂提供一个接口，用于创建相关或依赖对象，而不需要明确指定具体类。

使用场景

需要创建一个对象家族或者想要使创建的产品集合起来时，可以使用抽象工厂模式。

UML类图

抽象工厂模式和工厂方法模式相比，二者的共同点是都可以将对象的创建进行封装，使得程序解耦，降低对特定实现的依赖。同时，他们也有各自的特点，对于工厂方法来说，它一般通过继承实现，且常用于在具体化的类中进行解耦。而对于抽象工厂来说，它通过组合实现(将工厂对象作为构造函数的参数)，除了可以对类进行解耦之外，还可用于创建产品相关类或产品家族。

示例

还是以电脑专卖店为例，来看看如何通过抽象工厂模式实现，其中电脑工厂负责生产电脑，电脑商店负责销售电脑，在出售电脑时，用户可选择联想和DELL。
首先，创建一个抽象工厂，并指定统一的生产步骤：

package com.jyq.absfactory;

public interface IComputerFactory {

	void installCpu();
	void installRom();
	void installDisk();
	void installGraphic();
}

针对于不同的电脑品牌，分别由不同的电脑工厂负责生产：

package com.jyq.absfactory;

/**
* 生产DELL品牌的工厂
*/
public class DellComputerFactory implements IComputerFactory {

	@Override
	public void installCpu() {
		// TODO Auto-generated method stub
		System.out.println("安装Intel i5 cpu...");
	}

	@Override
	public void installRom() {
		// TODO Auto-generated method stub
		System.out.println("安装8G内存...");
	}

	@Override
	public void installDisk() {
		// TODO Auto-generated method stub
		System.out.println("安装1T显卡...");
	}

	@Override
	public void installGraphic() {
		// TODO Auto-generated method stub
		System.out.println("安装Colorful显卡...");
	}

}


package com.jyq.absfactory;

/**
 * 生产联想品牌的工厂
 */
public class LenovoComputerFactory implements IComputerFactory {

	@Override
	public void installCpu() {
		// TODO Auto-generated method stub
		System.out.println("安装Intel i7 cpu...");
	}

	@Override
	public void installRom() {
		// TODO Auto-generated method stub
		System.out.println("安装16G rom...");
	}

	@Override
	public void installDisk() {
		// TODO Auto-generated method stub
		System.out.println("安装500G硬盘...");
	}

	@Override
	public void installGraphic() {
		// TODO Auto-generated method stub
		System.out.println("安装 NVIDIA 显卡");
	}

}

当收到订单时，电脑专卖店负责从工厂拿货并寄送，具体如何组装电脑，交给电脑工厂去完成：

package com.jyq.absfactory;

public class ComputerShop {

	private IComputerFactory factory;
	//将工厂对象和电脑商店进行组合
	ComputerShop(IComputerFactory factory) {
		this.factory = factory;
	}
	public void sellComputer() {
		makeUpComputer();
		transport();
		delivery();
		signed();
	}
	private void makeUpComputer() {
		factory.installCpu();
		factory.installGraphic();
		factory.installRom();
		factory.installDisk();
	}
	
	private void transport() {
		System.out.println("运输中...");
	}
	
	private void delivery() {
		System.out.println("派件中...");
	}
	
	private void signed() {
		System.out.println("已签收...");
	}
}

当收到订单时，客户端的处理如下：

package com.jyq.absfactory;

public class DemoAbsFactory {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LenovoComputerFactory factory = new LenovoComputerFactory();
		//组合关系
		ComputerShop shop = new ComputerShop(factory);
		shop.sellComputer();
	}

}

通过抽象工厂模式，可以实现具体类间的解耦，减少依赖，更易于扩展，如果之后用户需要其他品牌电脑，则通过定义的接口创建对应的工厂类即可进行组装。

总结

• 1.工厂模式式(包括工厂方法模式和抽象工厂模式)都是用来封装对象的创建(虽然在上例中的工厂中仅仅输出了内容);
• 2.通过工厂模可以非常轻易地针对接口和抽象编程，而不需要针对于具体类;
• 3.工厂方法使用继承，把对象的创建委托给子类，子类实现了工厂方法来创建对象；
• 4.抽象工厂使用组合，对象的创建被实现在工厂接口所暴露出来的方法中；
• 5.工厂模式通过减少应用程序和具体类之间的依赖从而促进松耦合。

工厂方法模式实现步骤如下：

• 1.创建一个父工厂类：

public abstract class Factory {

};

• 2.声明一个抽象的工厂方法:

public abstract void createProduct(){

}

• 3.创建子工厂类，继承于父工厂类，并重写工厂方法：

public class FactoryA extends Factory {

    @Override
    public void createProduct(){
         //创建对象
    }
};

抽象工厂模式实现步骤如下：

• 1.创建一个工厂类，并定义接口：

public interface IFactory {
  A createA();
  B createB();
  C createC();
}

• 2.创建子类工厂，实现抽象工厂，并重写接口方法：

public class FactoryA implements IFactory {

  A createA() {

  }
  B createB() {

  }
  C createC() {
 
  }
}

public class FactoryB implements IFactory {

  A createA() {

  }
  B createB() {

  }
  C createC() {
 
  }
}

• 3.创建一个类和工厂类进行组合,：

public class Combine {
    public Combine(IFactory factory) {
        this.factory = factory;
    } 

    public void method1() {
        A a = factory.createA();
        B b = factory.createB();
        C c = factory.createC();
    }
}

参考资料

《Head First设计模式》