欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JAVA设计模式学习笔记4——工厂模式(Factory Pattern)

程序员文章站 2024-01-23 18:26:22
...

工厂模式(Factory Pattern)

    工厂模式,顾名思义,实际上就是定义能够生成对象的工厂,对于某种对象,其实例化过程由对象工厂来完成。
    工厂模式可细分为简单工厂模式(Simple Factory Pattern)、工厂方法模式(Factory Method Pattern)和抽象工厂模式(Abstract Factory Pattern)。
简单工厂模式(Simple Factory Pattern)——又称静态工厂方法模式(Static Factory Method 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();
	}
}

 

 

工厂方法模式(Factory Method Pattern)——定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

继 续上面的例子,能生产电话卡的不光是联通啊,移动、电信也行啊,只要是运营商都卖手机卡啊。于是,我们将上面的工厂改造一下,提供一个运营商工厂的接口 (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,运行时通过指定不同的工厂来生成不同系列的一组产品。

 

相关标签: 设计模式