设计模式（3）：抽象工厂模式

抽象工厂模式：

定义：

为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方法。

通过女娲造人的例子来简单了解一下这个模式。

上篇文章中的女娲只是造出了不同肤色的人种，没有定义性别，这篇文章我们就来实现定义性别这个需求。

一个接口，多个抽象类，然后是实现类，每个人种都是一个抽象类，性别是在实现类中实现的。

类图：

人种接口：

interface Human {
	public void getColor();

	public void talk();

	public void getSex();

}

各种肤色的人种：

abstract class YellowHuman implements Human {
	public void getColor() {
		System.out.println("黄种人的颜色是黄色的");
	}

	public void talk() {
		System.out.println("黄色人种会说话，一般说的都是双字节");
	}
}

abstract class BlackHuman implements Human {

	public void getColor() {
		System.out.println("黑种人的颜色是黑的");
	}

	public void talk() {
		System.out.println("黑人会说话，但是听不懂");
	}
}

abstract class WhiteHuman implements Human {

	public void getColor() {
		System.out.println("白种人的颜色是白色的");
	}

	public void talk() {
		System.out.println("白种人会说话，但一般是单字节");
	}

}

每个肤色的人种有两个实现类，分别产生男性和女性。

class FemalYellowHuman extends YellowHuman {

	public void getSex() {
		System.out.println("黄人女性");
	}
}

class MaleYellowHuman extends YellowHuman {

	public void getSex() {
		System.out.println("黄人男性");
	}

}

class FemalBlackHuman extends BlackHuman {

	public void getSex() {
		System.out.println("黑色女人");
	}

}

class MaleBlackHuman extends BlackHuman {

	public void getSex() {
		System.out.println("黑色男人");
	}

}

class FemalWhiteHuman extends WhiteHuman {

	public void getSex() {
		System.out.println("白人女性");
	}
}

class MaleWhiteHuman extends WhiteHuman {

	public void getSex() {
		System.out.println("白人男性");
	}

}

工厂接口：

interface HumanFactory {
	public Human createWhiteHuman();

	public Human createBlackHuman();

	public Human createYellowHuman();
}

两个工厂实现类，分别产生男性和女性。

class FemalHumanFactory implements HumanFactory {

	public Human createWhiteHuman() {
		return new FemalWhiteHuman();
	}

	public Human createBlackHuman() {
		return new FemalBlackHuman();
	}

	public Human createYellowHuman() {
		return new FemalYellowHuman();
	}

}

class MaleHumanFactory implements HumanFactory {

	public Human createWhiteHuman() {
		return new MaleWhiteHuman();
	}

	public Human createBlackHuman() {
		return new MaleBlackHuman();
	}

	public Human createYellowHuman() {
		return new MaleYellowHuman();
	}

}

场景类：

public class Client {
	public static void main(String[] args) {
		HumanFactory femalHumanFactory = new FemalHumanFactory();
		HumanFactory maleHumanFactory = new MaleHumanFactory();

		Human maleYellowHuman = maleHumanFactory.createYellowHuman();
		Human femalYellowHuman = femalHumanFactory.createYellowHuman();
		System.out.println("-----------------生产一个黄色男人--------------");
		maleYellowHuman.getSex();
		maleYellowHuman.talk();
		maleYellowHuman.getColor();
		System.out.println("-----------------生产一个黄色女人---------------");
		femalYellowHuman.getSex();
		femalYellowHuman.talk();
		femalYellowHuman.getColor();

	}
}

让抽象类去实现接口，在抽象类中实现的方法，其子类中不必再实现，而抽象类中没有实现（接口中）的方法，在子类继承的时候好要去实现。

这个设计模式看了几遍了，感觉理解不是很深刻。

版权声明：本文为博主原创文章，未经博主允许不得转载。