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

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。

抽象工厂模式的优点：

• 封装性。高层模块只关心接口。
• 产品族内的约束为非公开状态。生产过程对调用工厂类的高层模块来说是透明的，它不需要知道这个约束，具体的产品族内的约束是在工厂内实现的。

抽象工厂模式的缺点：

• 产品族扩展非常困难。

抽象工厂模式的使用场景：

• 一个对象族（或是一组没有任何关系的对象）都有相同的约束。

注意事项：

• 在抽象工厂模式中，产品族扩展比较困难，而不是产品等级。在该模式下，产品等级是非常容易扩展的，增加一个产品等级，只要增加一个工厂类负责新增加出来的产品生产任务即可。

下面通过两个实例分析抽象工厂模式。

---

实例一：制造汽车的左侧门和右侧门

（1）首先定义抽象类AbstractProductA，及产品ProductA的左右门实现

public abstract class AbstractProductA {
	//每个产品共有的方法
	public void shareMethod() {
	}
	//每个产品相同方法，不同实现
	public abstract void doSomething();
}

import com.sfq.impl.AbstractProductA;
public class ProductA1 extends AbstractProductA {
	@Override
	public void doSomething() {
		System.out.println("产品A1的实现方法");
	}
}

import com.sfq.impl.AbstractProductA;
public class ProductA2 extends AbstractProductA {
	@Override
	public void doSomething() {
		System.out.println("产品A2的实现方法");
	}
}

（2）定义抽象类AbstractProductB，及产品ProductB的左右门实现

public abstract class AbstractProductB {
	//每个产品共有的方法
	public void shareMethod() {
	}
	//每个产品相同方法，不同实现
	public abstract void doSomething();
}

import com.sfq.impl.AbstractProductB;
public class ProductB1 extends AbstractProductB {
	@Override
	public void doSomething() {
		System.out.println("产品B1的实现方法");
	}
}

import com.sfq.impl.AbstractProductB;
public class ProductB2 extends AbstractProductB {
	@Override
	public void doSomething() {
		System.out.println("产品B2的实现方法");
	}
}

(3)定义抽象工厂AbstractCreator ，及生产左门和生产右门的工厂实现

public abstract class AbstractCreator {
	//创建A产品家族
	public abstract AbstractProductA createProductA();
	//创建B产品家族
	public abstract AbstractProductB createProductB();
}

import com.sfq.impl.AbstractCreator;
import com.sfq.impl.AbstractProductA;
import com.sfq.impl.AbstractProductB;
public class Creator1 extends AbstractCreator {
	@Override
	public AbstractProductA createProductA() {
		return new ProductA1();
	}
	@Override
	public AbstractProductB createProductB() {
		return new ProductB1();
	}
}

import com.sfq.impl.AbstractCreator;
import com.sfq.impl.AbstractProductA;
import com.sfq.impl.AbstractProductB;
public class Creator2 extends AbstractCreator {
	@Override
	public AbstractProductA createProductA() {
		return new ProductA2();
	}
	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB2();
	}
}

（4）定义场景类，实现工厂对产品的生产

import com.sfq.action.Creator1;
import com.sfq.action.Creator2;
import com.sfq.impl.AbstractCreator;
import com.sfq.impl.AbstractProductA;
import com.sfq.impl.AbstractProductB;
public class Client {
	public static void main(String[] args) {
		// 定义出两个工厂
		AbstractCreator creator1 = new Creator1();
		AbstractCreator creator2 = new Creator2();
		//产生A1对象
		AbstractProductA a1 = creator1.createProductA();
		AbstractProductA a2 = creator2.createProductA();
		//产生B1对象
		AbstractProductB b1 = creator1.createProductB();
		AbstractProductB b2 = creator2.createProductB();
		a1.doSomething();
		a2.doSomething();
		b1.doSomething();
		b2.doSomething();
	}
}

结果
产品A1的实现方法
产品A2的实现方法
产品B1的实现方法
产品B2的实现方法

---

实例二：女娲造人，分性别

（1）定义Human接口，包含肤色、语言和性别抽象方法

public interface Human {
	public void getCloor();		//肤色
	public void talk();			//语言
	public void getSex();		//性别
}

（2）定义一个黑人抽象类，实现了黑人的共有肤色和语言；之后根据不同性别实现黑人女性和黑人男性类，类中包含性别方法的实现。

public abstract class AbstractBlackHuman implements Human{
	@Override
	public void getCloor() {
		System.out.println("我是黑色的。。。");
	}
	@Override
	public void talk() {
		System.out.println("我说黑话。。。");
	}
}

import com.sfq.impl.AbstractBlackHuman;
public class FemaleBlackHuman extends AbstractBlackHuman {
	@Override
	public void getSex() {
		System.out.println("黑人女性");
	}
}

import com.sfq.impl.AbstractBlackHuman;
public class FmaleBlackHuman extends AbstractBlackHuman {
	@Override
	public void getSex() {
		System.out.println("黑人男性");
	}
}

（2）定义一个黄人抽象类，实现了黄人的共有肤色和语言；之后根据不同性别实现黄人女性和黄人男性类，类中包含性别方法的实现。

public abstract class AbstractYelloHuman implements Human{
	@Override
	public void getCloor() {
		System.out.println("我是黄色的。。。");
	}
	@Override
	public void talk() {
		System.out.println("我说普通话。。。");
	}
}

import com.sfq.impl.AbstractYelloHuman;
public class FemaleYelloHuman extends AbstractYelloHuman {
	@Override
	public void getSex() {
		System.out.println("黄人女性");
	}
}

import com.sfq.impl.AbstractYelloHuman;
public class FmaleYelloHuman extends AbstractYelloHuman {
	@Override
	public void getSex() {
		System.out.println("黄人男性");
	}
}

（3）定义一个白人抽象类，实现了白人的共有肤色和语言；之后根据不同性别实现白人女性和白人男性类，类中包含性别方法的实现。

public abstract class AbstractWhiteHuman implements Human{
	@Override
	public void getCloor() {
		System.out.println("我是白色的。。。");
	}
	@Override
	public void talk() {
		System.out.println("我说白话。。。");
	}
}

import com.sfq.impl.AbstractWhiteHuman;
public class FemaleWhiteHuman extends AbstractWhiteHuman {
	@Override
	public void getSex() {
		System.out.println("白人女性");
	}
}

import com.sfq.impl.AbstractWhiteHuman;
public class FmaleWhiteHuman extends AbstractWhiteHuman {
	@Override
	public void getSex() {
		System.out.println("白人男性");
	}
}

（4）定义一个人类生产工厂接口，其中包含对黑、白、黄人的生产方法。

public interface HumanFactory {
	public Human createBlackHuman();
	public Human createYellowHuman();
	public Human createWhiteHuman();
}

（5）定义两个流水线，实现工厂类，分别生成男性和女性

import com.sfq.impl.Human;
import com.sfq.impl.HumanFactory;
public class FemaleFactory implements HumanFactory {
	@Override
	public Human createBlackHuman() {
		return new FemaleBlackHuman();
	}
	@Override
	public Human createYellowHuman() {
		return new FemaleYelloHuman();
	}
	@Override
	public Human createWhiteHuman() {
		return new FemaleWhiteHuman();
	}
}

import com.sfq.impl.Human;
import com.sfq.impl.HumanFactory;
public class MaleFactory implements HumanFactory {
	@Override
	public Human createBlackHuman() {
		return new FmaleBlackHuman();
	}
	@Override
	public Human createYellowHuman() {
		return new FmaleYelloHuman();
	}
	@Override
	public Human createWhiteHuman() {
		return new FmaleWhiteHuman();
	}
}

（6）定义场景类，在场景类中实例化男性和女性两条流水线，分别进行人类生产

import com.sfq.action.FemaleFactory;
import com.sfq.action.MaleFactory;
import com.sfq.impl.AbstractHumanFactory;
import com.sfq.impl.Human;
import com.sfq.impl.HumanFactory;
public class NvWa {
	public static void main(String[] args) {
		//男性生产线
		HumanFactory maleHumanFactory = new MaleFactory();
		//女性生产线
		HumanFactory femaleHumanFactory = new FemaleFactory();
		//开始生产人
		System.out.println("--生产一个白女--");
		Human femaleWhiteHuman = femaleHumanFactory.createWhiteHuman();
		femaleWhiteHuman.getCloor();
		femaleWhiteHuman.talk();
		femaleWhiteHuman.getSex();
		System.out.println("--生产一个白汉--");
		Human maleWhiteHuman = maleHumanFactory.createWhiteHuman();
		maleWhiteHuman.getCloor();
		maleWhiteHuman.talk();
		maleWhiteHuman.getSex();
		System.out.println("--生产一个黄女--");
		Human femaleHellowHuman = femaleHumanFactory.createYellowHuman();
		femaleHellowHuman.getCloor();
		femaleHellowHuman.talk();
		femaleHellowHuman.getSex();
		System.out.println("--生产一个黄汉--");
		Human maleHellowHuman = maleHumanFactory.createYellowHuman();
		maleHellowHuman.getCloor();
		maleHellowHuman.talk();
		maleHellowHuman.getSex();
		System.out.println("--生产一个黑女--");
		Human femaleBlackHuman = femaleHumanFactory.createBlackHuman();
		femaleBlackHuman.getCloor();
		femaleBlackHuman.talk();
		femaleBlackHuman.getSex();
		System.out.println("--生产一个黑汉--");
		Human maleBlackHuman = maleHumanFactory.createBlackHuman();
		maleBlackHuman.getCloor();
		maleBlackHuman.talk();
		maleBlackHuman.getSex();
	}
}

结果
--生产一个白女--
我是白色的。。。
我说白话。。。
白人女性
--生产一个白汉--
我是白色的。。。
我说白话。。。
白人男性
--生产一个黄女--
我是黄色的。。。
我说普通话。。。
黄人女性
--生产一个黄汉--
我是黄色的。。。
我说普通话。。。
黄人男性
--生产一个黑女--
我是黑色的。。。
我说黑话。。。
黑人女性
--生产一个黑汉--
我是黑色的。。。
我说黑话。。。
黑人男性