工厂设计模式

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

来看下它的组成：
1.抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2. 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象
3. 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4. 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的！

一：简单工厂

 //抽象产品角色
    public interface Fruit {
    	public void eat();
    }
    //具体产品角色
    public class Apple implements Fruit {
    	@Override
    	public void eat() {
    		System.out.println("eat---apple");
    	}
    }
    //具体产品角色
    public class Orange implements Fruit {
    	@Override
    	public void eat() {
    		System.out.println("eat---orange");
    	}
    }
    
    //抽象工厂
    public abstract class FruitFactory {
    	abstract Fruit creat();
    }
    //具体工厂角色
    public class AppleFactory extends FruitFactory {
    	@Override
    	Fruit creat() {
    		return new Apple();
    	}
    }
    //具体工厂角色
    public class OrangeFactory extends FruitFactory {
    	@Override
    	Fruit creat() {
    		return new Orange();
    	}
    }
    //测试
    public class Test {
    	public static void main(String[] args) {
    		FruitFactory appleFactory = new AppleFactory();
    		Fruit eatApple = appleFactory.creat();
    		eatApple.eat();
    		
    		FruitFactory orangeFactory = new OrangeFactory();
    		Fruit eatOrange = orangeFactory.creat();
    		eatOrange.eat();
    	}	
    }
    //输出
    eat---apple
	eat---orange

可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情 况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。

简单工厂和工厂方法模式的比较
工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

二：抽象工厂

 //抽象产品角色一
 public interface Fruit {
	public void eat();
 }
 //具体产品角色一
 public class Apple implements Fruit {
	@Override
	public void eat() {
		System.out.println("eat---apple");
	}
 }

 //抽象产品角色二
 public interface Car {
	void run();
 }
 //具体产品角色二
 public class Jeep implements Car {
	@Override
	public void run() {
		System.out.println("---Jeep---running---");
	}
 }

 //抽象工厂
 public abstract class AbstractFactory {
	abstract Fruit creatFruit();
	abstract Car creatCar();
 }
 //具体工厂
 public class ConcreteFactory extends AbstractFactory {
	@Override
	Fruit creatFruit() {
		return new Apple();
	}

	@Override
	Car creatCar() {
		return new Jeep();
	}
}
//测试
public class Test {	
    public static void main(String[] args) {
    	AbstractFactory absFactory=new ConcreteFactory();
    	Fruit fruit = absFactory.creatFruit();
    	fruit.eat();
    	
    	Car car = absFactory.creatCar();
    	car.run();
    }
}
//输出
eat---apple 
---Jeep---running---

在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

总结

1. 简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
2. 工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
3. 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。
   （本文展示的是处理过后的基本实现代码；水平有限，供交流分享，如有错误，还请指教，谢谢~~）