23种设计模式——Factory模式

在面向对象系统设计中经常可以遇到以下的两类问题：

　　1）为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题n多的子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如new ×××;的代码。这里带来两个问题：1.客户程序员必须知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题，为了处理可能的名字冲突，有的命名可能并不是具有很好的可读性和可记忆性，就姑且不论不同程序员千奇百怪的个人偏好了。），2.程序的扩展性和维护变得越来越困难。

2）还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为：假设我们在类A中要使用到类B，B是一个抽象父类，在A中并不知道具体要实例化那一个B的子类，但是在类A的子类D中是可以知道的。在A中我们没有办法直接使用类似于new ×××的语句，因为根本就不知道×××是什么。

 

Factory模式解决方案

　　以上两个问题也就引出了Factory模式的两个最重要的功能：

　　1. 定义创建对象的接口，封装了对象的创建；

　　2. 使得具体化类的工作延迟到了子类中。

　　■模式选择

　　我们通常使用Factory模式来解决上面给出的两个问题。在第一个问题中，我们经常就是声明一个创建对象的接口，并封装了对象的创建过程。Factory这里类似于一个真正意义上的工厂（生产对象）。在第二个问题中，我们需要提供一个对象创建对象的接口，并在子类中提供其具体实现（因为只有在子类中可以决定到底实例化哪一个类）。

 

一、Simple Factory模式：

1、在这里，我们先定义水果（Fruit）接口：

Java代码

public interface Fruit {
	void plant();	// 水果是被种植的
	void enableEat();	// 水果能吃
}

 

2、苹果（Apple）是对水果（Fruit）接口的实现：

Java代码

public class Apple implements Fruit{
	public void plant(){
		System.out.println("种苹果!");
	}

	public void enableEat(){
		System.out.println("苹果好吃!");
	}
}

 

3、葡萄（Grape）是对水果（Fruit）接口的实现：

Java代码

public class Grape implements Fruit{
	public void plant(){
		System.out.println("种葡萄!");
	}
	public void enableEat(){
		System.out.println("葡萄好吃!");
	}
}

 

4、鸭梨（Pear）是对水果（Fruit）接口的实现：

Java代码

public class Pear implements Fruit{
	public void plant(){
		System.out.println("种鸭梨!");
	}
	public void enableEat(){
		System.out.println("鸭梨好吃!");
	}
}

 

5、定义买水果（BuyFruit）这一过程类：

Java代码

public class BuyFruit {
	/**
	 * 简单工厂方法
	 * @param which
	 * @return
	 */
	public static Fruit buyFruit(String which){
		if (which.equalsIgnoreCase("apple")) {	// 如果是苹果，则返回苹果实例
			return new Apple();
		} else if (which.equalsIgnoreCase("pear")){	// 如果是鸭梨，则返回鸭梨实例
			return new Strawberry();
		} else if (which.equalsIgnoreCase("grape")) { // 如果是葡萄，则返回葡萄实例
			return new Grape();
		} else{
			return null;
		}
	}
}

 

6、 编写测试类：

Java代码

public class FruitTest {
	public static void	main(String args[]){
		BuyFruit buy = new BuyFruit();	 // 开始买水果这个过程
		buy.buyFruit("apple").enableEat(); // 调用苹果的enableEat()方法
	}
}

 

7、 说明：
A：我要购买苹果，只需向工厂角色（BuyFruit）请求即可。而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。
B：但是对于工厂角色（BuyFruit）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的产品意味着修改这个工厂。
C：因此Simple Factory模式的开放性比较差。
有什么办法可以解决这个问题吗？那就需要Factory Method模式来为我们服务了。

二、Factory Method模式：

1、同样，我们先定义水果（Fruit）接口：

Java代码

public interface Fruit {
	void plant();	// 水果是被种植的
	void enableEat();	// 水果能吃
}

 

2、苹果（Apple）是对水果（Fruit）接口的实现：

Java代码

public class Apple implements Fruit{
	public void plant(){
		System.out.println("种苹果!");
	}
	public void enableEat(){
		System.out.println("苹果好吃!");
	}
}

 

3、葡萄（Grape）是对水果（Fruit）接口的实现：

Java代码

public class Grape implements Fruit{
	public void plant(){
		System.out.println("种葡萄!");
	}
	public void enableEat(){
		System.out.println("葡萄好吃!");
	}
}

 

4、鸭梨（Pear）是对水果（Fruit）接口的实现：

Java代码

public class Pear implements Fruit{
	public void plant(){
		System.out.println("种鸭梨!");
	}
	public void enableEat(){
		System.out.println("鸭梨好吃!");
	}
}

 

5、在这里我们将买水果（BuyFruit）定义为接口类：

Java代码

public interface BuyFruit{
	/**
	 * 工厂方法
	 * @return
	 */
	public Fruit buyFruit();	 // 定义买水果这一过程
}

 

6、买苹果是（BuyApple）对买水果（BuyFruit）这个接口的实现

Java代码

public class BuyApple implements BuyFruit{
	public Fruit buyFruit(){
		return new Apple();	// 返回苹果实例
	}
}

 

7、买鸭梨是（BuyPear）对买水果（BuyFruit）这个接口的实现

Java代码

public class BuyPear implements BuyFruit{
	public Fruit BuyPear (){
		return new Pear();	// 返回鸭梨实例
	}
}

 

8、买葡萄是（BuyGrape）对买水果（BuyFruit）这个接口的实现

Java代码

public class BuyGrape implements BuyFruit{
	public Fruit BuyGrape (){
		return new Grape ();	// 返回葡萄实例
	}
}

 

9、编写测试类：

Java代码

public class FruitTest {
	public static void	main(String args[]){
		BuyApple buy = new BuyApple(); // 开始买水果这个过程
		buy.buyFruit().enableEat();			// 调用苹果的enableEat()方法
	}
}

 

10、说明：
A：工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。
B：工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么就不妨把抽象工厂类合并到具体的工厂类中去。由于反正只有一个具体工厂类，所以不妨将工厂方法改成为静态方法，这时候就得到了简单工厂模式。
C：如果需要加入一个新的水果，那么只需要加入一个新的水果类以及它所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的水果类而言，这个系统完全支持“开-闭”原则。
D：对Factory Method模式而言，它只是针对一种类别（如本例中的水果类Fruit），但如果我们还想买肉，那就不行了，这是就必须要Abstract Factory Method模式帮忙了。

 

 

 

三、Abstract Factory模式

1、同样，我们先定义水果（Fruit）接口：

Java代码

public interface Fruit {
	void plant();	// 水果是被种植的
	void enableEat();	// 水果能吃
}

 

2、苹果（Apple）是对水果（Fruit）接口的实现：

Java代码

public class Apple implements Fruit{
	public void plant(){
		System.out.println("种苹果!");
	}
	public void enableEat(){
		System.out.println("苹果好吃!");
	}
}

 

3、葡萄（Grape）是对水果（Fruit）接口的实现：

Java代码

public class Grape implements Fruit{
	public void plant(){
		System.out.println("种葡萄!");
	}
	public void enableEat(){
		System.out.println("葡萄好吃!");
	}
}

 

4、鸭梨（Pear）是对水果（Fruit）接口的实现：

Java代码

public class Pear implements Fruit{
	public void plant(){
		System.out.println("种鸭梨!");
	}
	public void enableEat(){
		System.out.println("鸭梨好吃!");
	}
}

 

5、定义肉（Meat）接口：

Java代码

public interface Meat {
	void feed();	// 肉是喂养的
	void enableEat();	// 肉能吃
}

 

6、猪肉（BigMeat）是对肉（Meat）接口的实现：

Java代码

public class BigMeat implements Meat{
	public void feed(){
		System.out.println("养猪!");
	}
	public void enableEat(){
		System.out.println("猪肉好吃!");
	}
}

 

7、牛肉（CowMeat）是对肉（Meat）接口的实现：

Java代码

public class CowMeat implements Meat {
	public void feed(){
		System.out.println("养牛!");
	}
	public void enableEat(){
		System.out.println("牛肉好吃!");
	}
}

 

8、我们可以定义买货人（Buyer）接口：

Java代码

public interface Buyer {
	/**
	 * 买水果工厂方法
	 * @param whichFruit
	 * @return
	 */
	public Fruit buyFruit(Fruit whichFruit);
	/**
	 * 买肉的工厂方法
	 * @param whichMeat
	 * @return
	 */
	public Meat buyMeat(Meat whichMeat);
}

 

9、我（MyBuyer）是对买货人（Buyer）接口的实现：

Java代码

public class MyBuyer implements Buyer{
	/**
	 * 买水果工厂方法
	 */
	public Fruit buyFruit(Fruit whichFruit){
		 return whichFruit;
	}

	/**
	 * 买肉的工厂方法
	 */
	public Meat buyMeat(Meat whichMeat){
		 return whichMeat;
	}
}

 

10、编写测试类：

Java代码

public class MyBuyerAbstractTest {
	public static void	main(String args[]){
		Fruit apple = new Apple();	 	// 苹果实例
		Meat big = new BigMeat();		// 猪肉实例
		MyBuyer my = new MyBuyer();		// 我是买者的实例
		my.buyFruit(apple).enableEat();	// 我买苹果
		my.buyMeat(big).enableEat();	// 我买猪肉
	}
} 

 

11、说明：
A：抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。
B：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。

 

转：http://ciding.iteye.com/blog/1103544

附：图片上传比较麻烦，可以自行上网查看或者自己解决