学习设计模式系列之——工厂方法模式（Java）

是初学者，请各位前辈指点。谢谢。

 

工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

现有如下例子说明：Apple类和Banana类分别实现了Fruit接口，FruitFactory类负责创建Apple实例和Banana实例，MainClass是程序的入口，负责测试，代码如下：

/** 
 * 苹果类
 * 2010-6-26 下午09:45:41
 */
public class Apple implements Fruit{
	
	/**
	 * 采集苹果
	 * 2010-6-26 下午09:46:20
	 */
	public void get(){
		System.out.println("采集苹果");
	}
}

/** 
 * 香蕉类
 * 2010-6-26 下午09:46:59
 */
public class Banana implements Fruit{

	/**
	 * 采集
	 * 2010-6-26 下午09:47:16
	 */
	public void get(){
		System.out.println("采集香蕉");
	}
}

/** 
 * 水果工厂类
 * 2010-6-26 下午09:53:48
 */
public class FruitFactory {	
	/**
	 * get方法，获得所有产品对象
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 * @throws ClassNotFoundException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException{
		if(type.equalsIgnoreCase("apple")){
			return Apple.class.newInstance();
		}else if(type.equalsIgnoreCase("banana")){
			return Banana.class.newInstance();
		}else{
			System.out.println("can not find class");
			return null;
		}
	}
}

/** 
 * 主类
 * 2010-6-26 下午09:45:29
 */
public class MainClass {
	/**
	 * 2010-6-26 下午09:45:29
	 * @param args
	 */
	public static void main(String[] args) {

		try {
			Fruit banana=FruitFactory.getFruit("Banana");
			Fruit apple = FruitFactory.getFruit("Apple");
			apple.get();
			banana.get();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		
	}

}

 现要增加一个犁子类：Pear，同样实现Fruit接口，代码如下：

/** 
 * 犁子类
 * 2010-6-27 下午08:28:53
 */
public class Pear implements Fruit {

	/* (non-Javadoc)
	 * @see Fruit#get()
	 */
	@Override
	public void get() {
		System.out.println("采集梨子");
	}

}

 那么这时就要将FruitFactory类进行修改，增加一个else if 的判断语句，修改后的代码如下：

/** 
 * 水果工厂类
 * 2010-6-26 下午09:53:48
 */
public class FruitFactory {
	/**
	 * get方法，获得所有产品对象
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 * @throws ClassNotFoundException 
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	public static Fruit getFruit(String type) throws InstantiationException, IllegalAccessException{
		if(type.equalsIgnoreCase("apple")){
			return Apple.class.newInstance();
		}else if(type.equalsIgnoreCase("banana")){
			return Banana.class.newInstance();
		}else if(type.equalsIgnoreCase("pear")){
			return Pear.class.newInstance();
		}else{
			System.out.println("can not find class");
			return null;
		}
	}
}

 

这样修改虽然说可以，但是违反了“开闭原则”，对扩展开放，对修改关闭。

第二步，我们做以下修改，Apple类和Banana类保持不变，将原来的水果工厂类(FruitFactory),改成接口，代码如下：

/** 
 * 水果工厂接口
 * 2010-6-26 下午09:53:48
 */
public interface FruitFactory {
	public Fruit getFruit();
}

 同时我们增加两个工厂类：AppleFactory,BananaFactory,这两个类分别实现FruitFactory这个接口，代码如下：

/** 
 * 苹果工厂类
 * 2010-6-27 下午08:52:52
 */
public class AppleFacotry implements FruitFactory {

	/* (non-Javadoc)
	 * @see FruitFactory#getFruit()
	 */
	@Override
	public Fruit getFruit() {
		return new Apple();
	}

}

/** 
 * 香蕉工厂类
 * 2010-6-27 下午08:55:08
 */
public class BananaFactory implements FruitFactory {

	/* (non-Javadoc)
	 * @see FruitFactory#getFruit()
	 */
	@Override
	public Fruit getFruit() {
		return new Banana();
	}

}

 

这时，我们来修改MainClaa，代码如下：

/** 
 * 主类
 * 2010-6-26 下午09:45:29
 */
public class MainClass {
	/**
	 * 2010-6-26 下午09:45:29
	 * @param args
	 */
	public static void main(String[] args) {

		//获得AppleFactory
		FruitFactory appleFactory=new AppleFacotry();
		//通过AppleFactory获得Apple
		Fruit apple=appleFactory.getFruit();
		apple.get();
		
		//获得BananaFactory
		FruitFactory bananaFactory=new BananaFactory();
		Fruit banana=bananaFactory.getFruit();
		banana.get();
	}
}

 这时，当我们增加一个新的水果“犁子”时，我们就不需要修改原来的代码，只需要增加一个Pear类，代码和上面的代码一样，和增加一个PearFactory类即可，代码如下：

/** 
 * 犁子工厂类
 * 2010-6-27 下午09:09:01
 */
public class PearFactory implements FruitFactory {

	/* (non-Javadoc)
	 * @see FruitFactory#getFruit()
	 */
	@Override
	public Fruit getFruit() {

		return new Pear();
	}

}

//主程序如下：

/** 
 * 主类
 * 2010-6-26 下午09:45:29
 */
public class MainClass {
	/**
	 * 2010-6-26 下午09:45:29
	 * @param args
	 */
	public static void main(String[] args) {

		//获得AppleFactory
		FruitFactory appleFactory=new AppleFacotry();
		//通过AppleFactory获得Apple
		Fruit apple=appleFactory.getFruit();
		apple.get();
		
		//获得BananaFactory
		FruitFactory bananaFactory=new BananaFactory();
		Fruit banana=bananaFactory.getFruit();
		banana.get();
		
		//获得PearFactory
		FruitFactory pearFactory=new PearFactory();
		Fruit pear=pearFactory.getFruit();
		pear.get();
	}
}

各个角色和职责 

1.抽象工厂（Creator）角色：工厂方法模式的核心，任何工厂类都必须实现这个接口，如FruitFactory。

2.具体工厂（ Concrete  Creator）角色：具体工厂类是抽象工厂的一个实现，负责实例化产品对象，如AppleFactory。

3.抽象（Product）角色：工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口，如Fruit。

4.具体产品（Concrete Product）角色：工厂方法模式所创建的具体实例对象，如Apple

评论

1 楼 mercyblitz 2010-06-28  

楼主还有一个做法，我觉得更好。


FruitFactory -> FruitBuilder ->Fruit

这样FruitFactory是抽象工厂，FruitBuilder是工厂。