3.设计模式之工厂模式

1. 简单工厂模式

简单工厂其实不是一个设计模式，反而比较像是一种编程习惯。

 

我的理解：简单工厂模式只是把类实例化的方法【new()】放在了工厂类中

 

example:定义一个简单汽车工厂，根据客户的不同需要，生产不同的汽车。

 

来吧

 

1.定义一个汽车的接口，有一个基本的行为方法：即车是可以开的居然

public interface ICar {
	
	//car 的行为
	 void driver();

}

2. 定义一个简单工厂，注意哟，这是重点。根据客户的不同需要，生产不同的汽车

public class SimpleFactory {
	//创建汽车的方法
	public ICar createVehicle(String type){
		ICar car = null;
		if("BMW".equals(type)){
			car = new BMWCar();
		}else if("QQ".equals(type)){
			car = new QQCar();
		}
		return car;
	}
}

3. 定义一个宝马车

/**
 *  宝马车 
 *
 */
public class BMWCar implements ICar {

	public void driver() {
		System.out.println("宝马车在开啊。。。。");
	}
}

4. 定义一个奇瑞QQ专门为屌丝服务

/**
 *    奇瑞QQ 
 *
 */
public class QQCar implements ICar{

	public void driver() {
		System.out.println("QQ车在开啊。。。。");
	}
}

5. 都准备好了，再来一个专卖店吧，专门倾听客户声音为客户服务

/**
 *  售车店
 *
 */
public class CarStore {
	private SimpleFactory factory;//这也是重点啊。
	public CarStore(SimpleFactory factory) {
		this.factory = factory;
	}
	//我需要一辆车
	public ICar orderVehicle(String type){
		return factory.createVehicle(type);
	}
}

6.运行看看

	public class Main {
	
		public static void main(String[] args) {
			//定义一个工厂方法
			SimpleFactory factory = new SimpleFactory();
			//定义一个商店
			CarStore carStore = new CarStore(factory);
			//来一辆宝马吧
			ICar bmw = carStore.orderVehicle("BMW");
			bmw.driver();
			//我没钱来一辆QQ吧
			ICar qq = carStore.orderVehicle("QQ");
			qq.driver();
		}
		
	}

 以上是我理解的最简单工厂模式。

所有工厂模式都是用来封装对象的创建。

2. 抽象工厂模式

    抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

 

看例子吧

1. 抽象工厂方法

/**
 *	抽象工厂的方法 
 */
public abstract class AbstractFactory {
	//生产Vehicle的方法
	abstract ICar createVehicle(String type);
	//生产airplane的方法
	abstract IAirplane createAirplane(String type);
}

 2. 定义一个车的接口

/**
 *  汽车接口 
 */
public interface ICar {
	public void driver();
}

 3.定义一辆宝马车

public class BMWCar implements ICar{
	@Override
	public void driver() {
		System.out.println("宝马车在开啊。。。。");
	}
}

 4.定义一个QQ

/**
 * 奇瑞QQ 
 */
public class QQCar implements ICar{
	@Override
	public void driver() {
		System.out.println("QQ在开。");
	}
}

 5.定义一个飞机的接口

/**
 * 飞机接口
 */
public interface IAirplane{
	public void fly();
}

 6. 定义一架空军一号

/**
 * 空军一号 
 */
public class AirForceOne implements IAirplane{
	@Override
	public void fly() {
		System.out.println("灰太狼的空军一号。。。");
	}
}

 7. 定义一个747

/**
 *	747 
 */
public class Airbus747 implements IAirplane{
	@Override
	public void fly() {
		System.out.println("747在飞啊。");
	}
}

 8.定义一个低级工厂，继承自抽象工厂，可以生产QQ和747

/**
 *  低级工厂 
 */
public class LowLevelFactory extends AbstractFactory{
	//只能生产QQ
	ICar createVehicle() {
		return new QQCar();
	}
	//只能生产747
	IAirplane createAirplane() {
		return new Airbus747();
	}
}

 9.定义一个高级工厂，继承自抽象工厂，可以生产bm和空车一号

/**
 *	高级工厂 
 */
public class HighLevelFactory extends AbstractFactory{

	//可以生产bm
	ICar createVehicle() {
		return new BMWCar();
	}
	//可以生产空军一号
	IAirplane createAirplane() {
		return new AirForceOne();
	}
}

 10.运行一下

public class Main {

	public static void main(String[] args) {
		//高级工厂
		AbstractFactory hignFactory = new HighLevelFactory();
		ICar bmw  = hignFactory.createVehicle();
		bmw.driver();
		IAirplane airplane747 = hignFactory.createAirplane();
		airplane747.fly();
		//低级工厂
		AbstractFactory lowFactory = new LowLevelFactory();
		ICar qq  = lowFactory.createVehicle();
		qq.driver();
		IAirplane airone = lowFactory.createAirplane();
		airone.fly();
	}
}

 我的理解：抽象工厂模式应该是有一个抽象工厂类，并且有许多继承的子工厂类。每一个类产品比方说，车，飞机，都有一个公共的接口。不同的子工厂可以组合生产不同的产品。

返回导航

 

   

 

评论

2 楼 yt_lemon 2015-04-24  

1 楼 ijlkdwg 2014-01-08  

都是书上抄来的。实际上是一点源码都不看的。
jdk里面，有好几个抽象工厂模式，那边的说法应该是provider。jdbc、jce、xml都是这样的。
jce估计接触的不多，但是jdbc怎么会没人知道？xml的由于它设计上的一些缺陷，有时候会导致一些web容器下的xml解释器出错，这个应该不少人遇到过吧。
这个模式的特征是，规定一套行为（spec），让别人来实现。
1、spec里面可能会有一个多个接口（也可以是抽象类），每个接口里面有若干个行为。参考jdbc里面的connection statement。
2、可能会有bean类（因为更像data structure，做成了实体类），比如jce里面的key。抽象类在这里等同接口看。
3、这些东西会有个“根启动器”，去产生其它的东西，这个东西需要register到一个地方。比如jdbc里面的Driver（接口）注册到DriverManager，产生connection，connection再产生其它的东西；jce里面是Provider（抽象类）；xml比较sb，需要用这样的方式注册（META-INF/services/javax.xml.parsers.XXXBuilderFactory），一组的XXXBuilderFactory由jdk的ServiceLoader类来加载，也可以看作是一个类，但是如果有几个provider（即使是版本不同），就可以造成混乱，这个就是前面说出问题的原因，也是给它“sb”定语的原因之一。原因之二是once factory -> one builder ->one product，脱裤子放屁的意味很深啊。jce的情况稍微有点绕，Provider注册到Security，但是消费者是jce框架自身。