锈才学设计模式之 —— 工厂模式(Factory Pattern)(一)

锈才学设计模式之  —— 工厂模式(一) 

 

工厂方法模式：工厂模式能封装具体类型的实例化，工厂方法模式定义了一个创建对象的接口，但是由子类通过继承抽象方法来决定实例化那一个类，将类的实例化放在子类中.

 

说明：在实例化具体类时，都是采用JAVA中的new关键字，这样就将具体类固定了,当需要利用其它产品时,必须修改代码实例化其它产品类,这样就失去了灵活性,丢失了OO的多态、封装、抽象等重要特性，下面是实例化例子：

   == 实例化类 ==  

Product product = new concreteProduct ();

 

 大部人都会采用灵活一点的方式来实例化类，比如用一个方法来根据条件实例化类：

   == 根据判断实例化类 ==  

package com.jody.pattern.factory;

public class ProductOperation {
	public void operation(String type){
		if("concrete".equals(type)){
			Product product = new ConcreteProduct(); //实例具体产品
		}else if("other".equals(type)){
			//实例其它产品
		}
	}
}

 如果再遵守OO思想，把不变化的抽象出来，就可以将实例化类单独拿出来定义一个类，这个类专门负责生产产品，我们叫它工厂。比如：

   == 静态实例化工厂类 ==  

package com.jody.pattern.factory;

public static class ProductFactory {
	public Product instance(String type){
		Product product = null;
		if("concrete".equals(type)){
			product = new ConcreteProduct(); 
		}else if("other".equals(type)){
			//实例其它产品
			product = .;
		}
		return product;
	}
}

   == 产品工厂类 ==  

package com.jody.pattern.factory;

public class ProductOperation {
	Product product;
	public void operation(String type){
		product = ProductFactory.instance(type);//用静态工厂生成产品
	}
}

 

 这种方式，只是将实例化单独定义一个类，当新增加一个产品(Product)时，就需要修改工厂内生成产品的定义(public Product instance(String type))，这样需要修改工厂的代码，以增加对新增产品的支持，显然这是不够弹性，根据OO思想：面向扩展开放,面向修改关闭，我们就需要采用工厂方法模式,将工厂抽象出来,面向接口(抽象)而不是面向实现进行设计编程。 

 

工厂方法模式的结构

 

 下面针对工厂方法模型进行代码描述

 

    == 工厂接口(抽象)类 ==   

package com.jody.pattern.factory;
//工厂方法接口（抽象）
public abstract class Creator {	
	
	public void operation(String type){
		Product product;
		//子类实现了些方法会调用子类factoryMethod()
		product = factoryMethod(type);
		//完成产品的操作
		product.begin();
		product.add();
		product.end();
	}
	
	//生产(实例化)具体产品类
	public abstract Product factoryMethod(String type);
}

 

  == 工厂方法实现类 == 

package com.jody.pattern.factory;
//继承了抽象工厂类的抽象工厂子类
public class ConcreteCreator extends Creator {

	//在这个方法中实现工厂的功能
	@Override
	public Product factoryMethod(String type) {
		Product product = null;
		//实例化具体产品类
		if("concrete".equals(type)){
			//product 是父类(Creator)中的商品接口引用
			product = new ConcreteProduct(); 
		}else if("other".equals(type)){
			//实例其它产品
			product = new ConcreteProduct(); 
		}
		return product;
	}

}

   

  == 产品接口(抽象)类 == 

package com.jody.pattern.factory;
//具体产品接口（抽象）类
public abstract class Product {
	public abstract void begin();
	public abstract void add();
	public abstract void end();
}

  == 产品实现类 == 

package com.jody.pattern.factory;
//产品实现类
public class ConcreteProduct extends Product {

	@Override
	public void add() {
		// 增加		
	}
	@Override
	public void begin() {
		// 开始	
	}
	@Override
	public void end() {
		// 结束
	}
}

 

  == 测试调用类 == 

package com.jody.pattern.factory;
//测试
public class Test {
	public static void main(String[] args){
		//实例化一个工厂，调用方法
		//new实例化类是必须实现的，如果不实例化对象，就无法编程了，
		//所以总是需要实例化类
		//工厂方法也不例外，但是工厂方法模式，让我们把实例化类封装起来
		//更方便类实例化的管理和维护
		Creator c = new ConcreteCreator();		
		c.operation("concrete");
	}
}

 

类是程序的基础,实例化类是编程中用得最多的地方,每一个对象都需要实例化后才能发挥作用,工厂方法模式让我们将类的实例化封装起来,更好的管理.这正是符合OO的思想.