JAVA设计模式学习笔记4——工厂模式（Factory Pattern）
工厂模式（Factory Pattern）
比 如，你要办一张联通的电话卡，联通有A计划套餐、B计划套餐，不管什么套餐，都能打电话，你只要到营业厅买一张卡就行了。其中，电话卡是一个接口 （SimCard），它有一个方法就是用来打电话（service），A计划和B计划的卡都是其实现类（SimCardPlanA、 SimCardPlanB），营业厅就是一个工厂，用来生产电话卡（ChinaUnicomFactory），你只要告诉它你要什么套餐就行了。
电话卡接口（SimCard）：
public interface SimCard {
public void service();
}A套餐的卡（SimCardPlanA）：
public class SimCardPlanA implements SimCard {
@Override
public void service() {
System.out.println("联通A计划电话卡");
}
}B套餐的卡（SimCardPlanB）：
public class SimCardPlanB implements SimCard {
@Override
public void service() {
System.out.println("联通B计划电话卡");
}
}生产电话卡的工厂，也就是营业厅（ChinaUnicomFactory）：
public class ChinaUnicomFactory {
public static SimCard getSimCard(String kind) {
if("PlanA".equals(kind)){
return new SimCardPlanA();
}else if("PlanB".equals(kind)){
return new SimCardPlanB();
}else{
System.out.println("中国联通尚未推出该套餐");
return null;
}
}
}
测试类：
public class Test {
/**
* 又称静态工厂方法模式（Static Factory Method Pattern），很简单，
* 就是通过一个工厂类来负责对象的创建。
*
* @param args
*/
public static void main(String[] args) {
//获取一个联通A计划的电话卡
SimCard simCard1 = ChinaUnicomFactory.getSimCard("PlanA");
simCard1.service();
//获取一个联通B计划的电话卡
SimCard simCard2 = ChinaUnicomFactory.getSimCard("PlanB");
simCard2.service();
}
}
继 续上面的例子，能生产电话卡的不光是联通啊，移动、电信也行啊，只要是运营商都卖手机卡啊。于是，我们将上面的工厂改造一下，提供一个运营商工厂的接口 （ServiceOperatorFactory），联通工厂（ChinaUnicomFactory）、移动工厂 （ChinaMobileFactory）都实现了运营商接口的实现类，再增加两种卡的类型，移动的全球通卡（SimCardQQT）和神州行卡 （SimCardSZX）。这样，当用户想办联通卡时就用联通的工厂，想用移动卡时就用移动的工厂，没准哪天都不想用了，想换个电信的，没问题，不用修改 写好的代码，再加一个电信的工厂就行了，扩展性得到提高了吧。
运营商接口（ServiceOperatorFactory）：
public interface ServiceOperatorFactory {
public SimCard getSimCard(String kind);
}联通工厂（ChinaUnicomFactory）：
public class ChinaUnicomFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("PlanA".equals(kind)){
return new SimCardPlanA();
}else if("PlanB".equals(kind)){
return new SimCardPlanB();
}else{
System.out.println("中国联通尚未推出该套餐");
return null;
}
}
}移动工厂（ChinaMobileFactory）：
public class ChinaMobileFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("QQT".equals(kind)){
return new SimCardQQT();
}else if("SZX".equals(kind)){
return new SimCardSZX();
}else{
System.out.println("中国移动尚未推出该套餐");
return null;
}
}
}联通的A计划、B计划卡和上面一样，不列举了。
移动的全球通卡（SimCardQQT）：
public class SimCardQQT implements SimCard {
@Override
public void service() {
System.out.println("移动全球通电话卡");
}
}移动的神州行卡（SimCardSZX）：
public class SimCardSZX implements SimCard {
@Override
public void service() {
System.out.println("移动神州行电话卡");
}
}测试类：
public class Test {
/**
* 工厂方法模式（Factory Method Pattern）——定义了一个创建对象的接口，
* 但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
*
* @param args
*/
public static void main(String[] args) {
ServiceOperatorFactory factory;
//获取一个联通A计划的电话卡
factory = new ChinaUnicomFactory();
SimCard simCard1 = factory.getSimCard("PlanA");
simCard1.service();
//获取一个移动神州行的电话卡
factory = new ChinaMobileFactory();
SimCard simCard2 = factory.getSimCard("SZX");
simCard2.service();
}
}
抽象工厂模式（Abstract Factory Pattern）——提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
还 是继续上面的例子，现在运营商可不光是卖卡了，还卖手机。你想买个IPhone5，还得分清是买联通版还是移动版。去联通营业厅，肯定不能买到移动版的 IPhone5啊。于是，我们改造一下上面的例子，增加一个电话的接口（Phone），有一个方法打电话（call），定义两个实现类，联通版 IPhone（IPhoneUnicom）和移动版IPhone（IPhoneMobile），在运营商接口中增加一个获取电话的方法 （getPhone，假设营业厅只卖IPhone）。当使用不同的运营商工厂时，得到的电话卡和电话都是指定运营商的，你不需要指定说我要个什么版本的电 话，因为联通不卖移动版的电话。
电话接口（Phone）：
public interface Phone {
public void call();
}联通版IPhone（IPhoneUnicom）：
public class IPhoneUnicom implements Phone {
@Override
public void call() {
System.out.println("正在使用IPhone联通版");
}
}移动版IPhone（IPhoneMobile）：
public class IPhoneMobile implements Phone {
@Override
public void call() {
System.out.println("正在使用IPhone移动版");
}
}运营商接口（ServiceOperatorFactory）：
public interface ServiceOperatorFactory {
public SimCard getSimCard(String kind);
public Phone getPhone();
}联通工厂（ChinaUnicomFactory）：
public class ChinaUnicomFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("PlanA".equals(kind)){
return new SimCardPlanA();
}else if("PlanB".equals(kind)){
return new SimCardPlanB();
}else{
System.out.println("中国联通尚未推出该套餐");
return null;
}
}
@Override
public Phone getPhone() {
return new IPhoneUnicom();
}
}移动工厂（ChinaMobileFactory）：
public class ChinaMobileFactory implements ServiceOperatorFactory {
@Override
public SimCard getSimCard(String kind) {
if("QQT".equals(kind)){
return new SimCardQQT();
}else if("SZX".equals(kind)){
return new SimCardSZX();
}else{
System.out.println("中国移动尚未推出该套餐");
return null;
}
}
@Override
public Phone getPhone() {
return new IPhoneMobile();
}
}电话卡接口和实现类同上，不再列举。
测试类：
public class Test {
/**
* 抽象工厂模式（Abstract Factory Pattern）——提供一个接口，
* 用于创建相关或依赖对象的家族，而不需要明确指定具体类。
*
* @param args
*/
public static void main(String[] args) {
ServiceOperatorFactory factory;
//获取一个联通A计划的电话卡
factory = new ChinaUnicomFactory();
SimCard simCard1 = factory.getSimCard("PlanA");
Phone phone1 = factory.getPhone();
simCard1.service();
phone1.call();
//获取一个移动神州行的电话卡
factory = new ChinaMobileFactory();
SimCard simCard2 = factory.getSimCard("SZX");
Phone phone2 = factory.getPhone();
simCard2.service();
phone2.call();
}
}
区别：
简单工厂模式多用于需求明确、功能简单的开发，通过一个工厂类就可完成所有产品的生成工作。
工厂方法模式侧重点是，开发时不明确要生成哪种类型的实例，不同的工厂类生成不同类型的产品，运行时通过指定不同的工厂类来生成相应的产品类型。如有产品类型A，工厂1用于生成产品A1，工厂2用于生成产品A2，运行时通过指定不同的工厂来生成不同的产品。
抽 象工厂模式更注重于生产一个产品家族（即多种类型的产品），而这些产品类型又可横向划分为多个系列，那么，抽象工厂中定义生成所有产品类型的方法，每个工 厂的实现类用于生产一个系列所有类型的产品。如有A、B、C等产品类型，而这些类型中又可分为多个系列1、2，这样就有了产品A1、A2、B1、B2、 C1、C2，这时，工厂1用于生产A1、B1、C1，工厂2用于生产A2、B2、C2，运行时通过指定不同的工厂来生成不同系列的一组产品。
上一篇： C 语言程序计时
下一篇： Linux内核中设备树DTS