java 3种工厂模式的快速，简易理解

[b]1.简单工厂模式（Simple Factory）[/b]
就是专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类。

//定义水果 接口
public interface Fruit {
	void plantFruit();
	void eatFruit();
}

//苹果实现水果接口
public class Apple implements Fruit {

	@Override
	public void plantFruit() {
		System.out.println("种苹果。");
	}

	@Override
	public void eatFruit() {
		System.out.println("吃苹果。");
	}

}

//橘子实现水果接口
public class Orange implements Fruit {

	@Override
	public void plantFruit() {
		System.out.println("种橘子。");
	}

	@Override
	public void eatFruit() {
		System.out.println("吃橘子。");
	}

}

//水果工厂
public class FruitFactory {
	public static Fruit getFurit(String fruitName) {
		//简单工厂模式
		if (fruitName.equalsIgnoreCase("Apple")) { // 如果是苹果，则返回苹果实例
			return new Apple();
		} else if (fruitName.equalsIgnoreCase("Orange")) { // 如果是橘子，则返回橘子实例
			return new Orange();
		} else {
			return null;
		}
	}
}

//测试类
public class Test {
	public static void main(String[]args){
		//调用简单工厂模式
		FruitFactory.getFurit("Orange").plantFruit();
	}
}

输出：种橘子。

总结
A：我要购买苹果，只需向工厂角色（FruitFactory）请求即可。而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。
B：但是对于工厂角色（FruitFactory ）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的产品意味着修改这个工厂。
C：因此这种简单工厂模式的开放性比较差。


=============================================================

[b]2.工厂方法模式（Factory Method）[/b]
将对象的创建交由父类中定义的一个标准方法来完成，而不是其构造函数，究竟应该创建何种对象由具体的子类负责决定。

//定义水果 接口
public interface Fruit {
	void plantFruit();
	void eatFruit();
}

//苹果实现水果接口
public class Apple implements Fruit {

	@Override
	public void plantFruit() {
		System.out.println("种苹果。");
	}

	@Override
	public void eatFruit() {
		System.out.println("吃苹果。");
	}

}

//橘子实现水果接口
public class Orange implements Fruit {

	@Override
	public void plantFruit() {
		System.out.println("种橘子。");
	}

	@Override
	public void eatFruit() {
		System.out.println("吃橘子。");
	}

}

//水果工厂（[b]注意：此工厂声明为一个接口，具有了良好的扩展性[/b]）
public interface FactoryMethod {
	 /**
	  * 工厂方法
	  */
	  Fruit getFruit();   //定义获取水果这一过程
}

//苹果对水果工厂的实现
public class getApple implements FactoryMethod{

	@Override
	public Fruit getFruit() {
		// TODO Auto-generated method stub
		return new Apple();
	}

}

//橘子对水果工厂的实现
public class getOrange implements FactoryMethod {

	@Override
	public Fruit getFruit() {
		// TODO Auto-generated method stub
		return new Orange();
	}

}

//测试类
public class TestFactoryMethod {
	public static void main(String[] args) {
		getApple apple = new getApple();
		apple.getFruit().eatFruit();
	}
}
输出：吃苹果。

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


=============================================================

[b]3.抽象工厂模式（Abstract Factory）[/b]
抽象工厂模式可以说是简单工厂模式的扩展，它们主要的区别在于需要创建对象的复杂程度上。
在抽象工厂模式中，抽象产品可能是一个或多个，从而构成一个或多个产品族。 在只有一个产品族的情况下，抽象工厂模
式实际上退化到工厂方法模式。

//定义水果 接口
public interface Fruit {
	void plantFruit();
	void eatFruit();
}

//苹果实现水果接口
public class Apple implements Fruit {

	@Override
	public void plantFruit() {
		System.out.println("种苹果。");
	}

	@Override
	public void eatFruit() {
		System.out.println("吃苹果。");
	}

}

//橘子实现水果接口
public class Orange implements Fruit {

	@Override
	public void plantFruit() {
		System.out.println("种橘子。");
	}

	@Override
	public void eatFruit() {
		System.out.println("吃橘子。");
	}

}

//定义 肉 的接口
public interface Meat {
	void buyMeat();
	void eatMeat();
}

//猪肉实现接口
public class BigMeat implements Meat {

	@Override
	public void buyMeat() {
		System.out.println("买猪肉。");
	}

	@Override
	public void eatMeat() {
		System.out.println("吃猪肉。");
	}

}

//牛肉实现接口
public class CowMeat implements Meat{

	@Override
	public void buyMeat() {
		System.out.println("买牛肉。");
	}

	@Override
	public void eatMeat() {
		System.out.println("吃牛肉。");
	}

}

//定义消费者的接口
public interface UserFactory {
	  /**
	   * 水果工厂方法
	   */
	  public Fruit getFruit(Fruit whichFruit);
	  /**
	   * 肉的工厂方法
	   */
	  public Meat getMeat(Meat whichMeat);

}

//实现消费者的接口
public class User implements UserFactory {

	@Override
	public Fruit getFruit(Fruit whichFruit) {
		return whichFruit;
	}

	@Override
	public Meat getMeat(Meat whichMeat) {
		return whichMeat;
	}

}


//测试类
public class TestUserFactory {
	public static void main(String[]args){
		Fruit apple=new Apple();
		Meat bigMeat=new BigMeat();

		//消费者实例
		User me=new User();
		me.getFruit(apple).eatFruit();
		me.getMeat(bigMeat).buyMeat();
	}

}

输出：
吃苹果。
买猪肉。

总结：
A：抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。
B：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。
C：抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品（Fruit）等级结构；而抽象工厂模式则需要面对多个产品等级结构(Fruit、Meat)。