初学设计模式【6】抽象工厂模式——AbstractFactory

 开始之前

　　插播一个设计原则：依赖倒置原则

　　依赖倒置原则：要依赖抽象，不要依赖具体类

定义

　　提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

 UML类图

　　分析： 可以看到Client只与抽象的工厂类，及抽象的产品类有关联。利用这此抽象类或接口书写代码，我们的代码将从具体类解耦，这也就遵守了上面提到的一个设计原则：依赖倒置原则。

 实例

　　一个买手机的例子，我们到PhoneStore买手机。然后商店根据我们选择的手机品牌，开始制作手机，手机中有两个主要部件：cpu，主板。下图是uml类图：

关键代码： 

1>Cpu,Mainboard

public abstract class Cpu {
	String name;

	public Cpu(String name) {
		this.name = name;
	}

	public String cpuInfo() {
		return " " + name+" ";
	}
}


public abstract class Mainboard {
	String name;

	public Mainboard(String name) {
		this.name = name;
	}

	public String mainboardInfo() {
		return " " + name+" ";
	}
}

2>MotoCpu,NokiaCpu

public class MotoCpu extends Cpu {

	public MotoCpu(String name) {
		super(name);
	}

}


public class NokiaCpu extends Cpu {

	public NokiaCpu(String name) {
		super(name);
	}

}

3>MotoMainboard,NokiaMainboard

public class MotoMainboard extends Mainboard{

	public MotoMainboard(String name) {
		super(name);
	}

}


public class NokiaMainboard extends Mainboard {

	public NokiaMainboard(String name) {
		super(name);
	}

}

4>PhonePartsFacotry 

public abstract class PhonePartsFacotry {
	public abstract Cpu createCpu();

	public abstract Mainboard createMainboard();
}

5>MotoPhonePartsFacotry ,NokiaPhonePartsFacotry 

public class MotoPhonePartsFacotry extends PhonePartsFacotry {

	@Override
	public Cpu createCpu() {
		return new MotoCpu("MotoCpu");
	}

	@Override
	public Mainboard createMainboard() {
		return new MotoMainboard("MotoMainboard");
	}

}


public class NokiaPhonePartsFacotry extends PhonePartsFacotry {

	@Override
	public Cpu createCpu() {
		return new NokiaCpu("NokiaCpu");
	}

	@Override
	public Mainboard createMainboard() {
		// TODO Auto-generated method stub
		return new NokiaMainboard("NokiaMainboard");
	}

}

6>PhoneStore

public class PhoneStore {
	PhonePartsFacotry facotry;

	public PhoneStore(PhonePartsFacotry facotry) {
		this.facotry = facotry;
	}

	public Phone buyPhone() {
		if (facotry instanceof MotoPhonePartsFacotry) {
			return new MotoPhone("MotoPhone", facotry);
		} else {
			return new NokiaPhone("NokiaPhone", facotry);
		}
	}
}

测试

import org.junit.Test;

public class Testtt {

	@Test
	public void test() {
		PhoneStore store = new PhoneStore(new MotoPhonePartsFacotry());
		Phone phone = store.buyPhone();
		phone.phoneInfo();
	}
}

　输出：

　　

 总结：

 前面两篇：初学设计模式【4】简单工厂模式——SimpleFactory

　　　　　 初学设计模式【5】工厂方法模式——FactoryMethod

到现在三种工厂模式都说完了，这里再对它们作一个简单的对比：

1>共性：

　　这几种工厂模式都是用来封装创建对象的代码，降低客户代码对具体产品类的依赖，提升系统扩展能力的。

2>差异

　　a.如果要增加新的产品类，简单工厂模式与抽象工厂模式都要修改工厂类代码，没有严格遵守“开闭原则”，而工厂方法模式没有这个问题，对扩展的支持更好。

　　b.简单工厂模式弊端较多，只适合在比较简单的环境中使用；工厂方法模式严格遵守“开闭原则”，适合在经常增加新产品的、对扩展要求比较高的环境中使用；抽象工厂模式适合在需要生产一系列相互关联的产品时使用。

 ...