简单工厂模式、工厂方法模式和抽象工厂模式小结

      工厂模式是最重要的模式，因为大多数模式都需要用到工厂模式。

      多数设计模式的内容讲解的都是如何设计接口。接口如何产生呢？如果在客户代码（类库的使用者称之为客户）中直接使用具体类，那么就失去了接口的意义。因为接口的使用目的，就是要降低客户对具体类的依赖程度。如果在客户代码中直接使用接口，那么就造成了客户对具体类名称的依赖。（客户最终需要以某种方式指明所需要的具体类，如配置文件或代码，但是只需要指出一次，所以说降低对具体类的依赖程度）。要使客户代码不依赖具体类，唯一的方法，就是让客户代码不依赖具体类的部分不知道具体类的名称。知道具体类名称的部分，仅仅是配置部分。（配置文件或者配置代码）。

      依赖不可能完全消除，除非二者毫无联系。但是可以将这种依赖的程度降到最低。

      既然不能直接创建具体类，那么就需要通过一个创建者类来创建接口的实现类。这样就产生了工厂类。

      抽象工厂是应对产品族概念的。比如说，每个农场可能要同时生产苹果，橘子，大米，玉米，那么每一个农场都要有创建苹果，橘子，大米，玉米的方法。

简单工厂模式：又称静态工厂方法（Static Factory Methord）模式。一个抽象产品类，可以派生多个具体产品类。
用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）

public class SimpleFactory {

	public static void main(String[] args) {
		Fruit f=FactoryTest.getInstance().newApple();
		if(f!=null)
			f.eat();
		Fruit o=FactoryTest.getInstance().newOrange();
		if(o!=null)
			o.eat();
	}

}

interface Fruit { 
	public void eat(); 
}

class Apple implements Fruit {
	public void eat() {
		System.out.println("** 吃苹果。");
	}
};

class Orange implements Fruit {
	public void eat() {
		System.out.println("** 吃橘子。");
	}
};

class FactoryTest { // 定义工厂类
	private static FactoryTest factory;
	private FactoryTest(){}
	
	public static FactoryTest getInstance() {
		if(factory==null){
			factory=new FactoryTest();
		}
		return factory;
	}
	public Apple newApple(){
		return new Apple();
	}
	public Orange newOrange(){
		return new Orange();
	}
};

工厂方法模式：又称多态性工厂（Polymorphic Factory）模式或虚拟构造子（Virtual Constructor）模式。一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

用来生产同一等级结构中的固定产品。（支持增加任意产品）   

public class FactoryMethod {
	public static void main(String[] args) {
		FruFac af=new AppleFac();
		Fru f=af.getFru();
		f.eat();
		af=new OrangeFac();
		f=af.getFru();
		f.eat();
	}

}

abstract class Fru
{
	String name;
	public abstract void eat();
}

class AppleFru extends Fru{
	public AppleFru(){
		name="apple";
	}

	@Override
	public void eat() {
		System.out.println("apple"+name);
	}
}

class OrangeFru extends Fru{

	public OrangeFru(){
		name="orange";
	}
	
	@Override
	public void eat() {
		System.out.println("orange"+name);
	}
}

abstract class FruFac{
	public FruFac(){
		System.out.println("what fruit:"+getFru());
	}
	
	public abstract Fru getFru();
}

class AppleFac extends FruFac{

	@Override
	public Fru getFru() {
		// TODO Auto-generated method stub
		return new AppleFru();
	}
	
}

class OrangeFac extends FruFac{

	@Override
	public Fru getFru() {
		// TODO Auto-generated method stub
		return new OrangeFru();
	}
	
}

抽象工厂模式：又称工具箱（Kit或Toolkit）模式。多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）  

package model;

public class AbstractFactory {

	public static void main(String[] args) {
		Fact f=new WuxiFact();
		Frui fr=f.getFru();
		fr.eat();
		Food fo=f.getFood();
		fo.cook();
	}

}

abstract class Frui
{
	String name;
	public abstract void eat();
}

abstract class Food
{
	String name;
	public abstract void cook();
}

class AppleFrui extends Frui{
	public AppleFrui(){
		name="apple";
	}

	@Override
	public void eat() {
		System.out.println("Fruit:"+name);
	}
}

class OrangeFrui extends Frui{

	public OrangeFrui(){
		name="orange";
	}
	
	@Override
	public void eat() {
		System.out.println("Fruit:"+name);
	}
}

class Rice extends Food{

	public Rice(){
		name="rice";
	}
	@Override
	public void cook() {
		System.out.println("Food:"+name);
	}
	
}

class Corn extends Food{

	public Corn(){
		name="corn";
	}
	@Override
	public void cook() {
		System.out.println("Food:"+name);
	}
	
}

abstract class Fact{
	public Fact(){
		System.out.println("what fruit:"+getFru());
		System.out.println("what food:"+getFood());
	}
	
	public abstract Frui getFru();
	public abstract Food getFood();
}

class WuxiFact extends Fact{

	@Override
	public Frui getFru() {
		// TODO Auto-generated method stub
		return new AppleFrui();
	}

	@Override
	public Food getFood() {
		// TODO Auto-generated method stub
		return new Rice();
	}
	
}

class NanjinFact extends Fact{

	@Override
	public Frui getFru() {
		// TODO Auto-generated method stub
		return new OrangeFrui();
	}

	@Override
	public Food getFood() {
		// TODO Auto-generated method stub
		return new Corn();
	}
	
}

区别：简单工厂模式和工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

简单工厂模式只创建一个具体工厂类，工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。