设计模式之---工厂模式

工厂方法模式介绍：

按照真实社会中产品的生产销售过程来管理你的“产品”，让你的工程更加结构清晰。

定义

定义一个用于创建对象的接口，让子类决定实例化哪个类。

举例

以一个农户卖水果产品为例子来介绍该模式。
农户开了一家水果店，水果的来源是来自一家生产水果的工厂，水果店老板贩卖与更换水果都是从该工厂进货，农户需要什么水果，工厂生产什么水果。

该情景中有，农户，水果，生产水果的工厂，这几个对象。用代码构建以上情景如下。

首先人们生活的社会中是有水果的，建立一个水果的抽象类，以及具体的两种水果，

/** * 抽象的水果类 * @author Administrator * */public abstract class Fruit {    public abstract String fruitName();}

简单实现两种具体的水果：苹果，橘子

苹果：

public class Apple extends Fruit{    @Override    public  String fruitName() {        return "我是具体的水果--橘子";    }}

橘子

public class Orange extends Fruit{    @Override    public String fruitName() {         return "我是具体的水果--苹果";    }}

有水果也肯定有生产加工水果的工厂：构建一个生产水果的工厂

/** * 生产水果的抽象工厂 * @author Administrator * */public abstract class Factory {    public abstract Fruit createFruit();}

具体的水果工厂A

/** * 生产水果的具体工厂A * @author Administrator * */public class FruitFactoryA extends Factory{    @Override    public Fruit createFruit() {        return new Apple();    }}

卖水果的工厂B也是类似，不在重复。

构建出一个要卖水果的农户。

/** * 卖水果的农户 * @author Administrator * */public class Farmer {}

现在这个环境中有水果，有能提供水果的工厂，也有想要水果的农户，
所以农户只要联系到一个生产水果的工厂，向工厂购买水果即可得到水果

/** * 卖水果的农户 * @author Administrator * */public class Farmer {    public static void main(String[] args) {        //农户联系了一家生产水果的工厂        Factory factory = new FruitFactoryA();        //从该工厂进货，工厂生产水果给农户        Fruit fruit = factory.createFruit();        //打印出农户得到的水果        System.out.println(fruit.fruitName());        (我是具体的水果--苹果)    }}

如果农户想要水果橘子的话，则需要让工厂A去生产橘子即可。

/** * 生产水果的具体工厂A * @author Administrator * */public class FruitFactoryA extends Factory{    @Override    public Fruit createFruit() {        //  return new Apple();        return new Orange();    }}

但是这跟生活中的情景不太类似，因为一个农户想要换水果，就去修改工厂的代码，工厂应该是一个万能的工厂，农户只需提出他需要什么水果，工厂就能为期生产什么水果。万能的工厂需要反射来实现

/** * 生产水果的抽象工厂 * @author Administrator * */public abstract class Factory {    public abstract <T extends Fruit> Fruit createFruit(Class<T> clz);}

具体的生产水果的工厂通过反射获取水果类即可

/** * 生产水果的具体工厂A * @author Administrator * */public class FruitFactoryA extends Factory{    @Override    public <T extends Fruit> Fruit createFruit(Class<T> clz) {        Fruit fruit = null;        try {            fruit = clz.newInstance();        } catch (Exception e) {            e.printStackTrace();        }        return fruit;    }}

农户只需在进货时告诉工厂需要什么水果即可

/** * 卖水果的农户 * @author Administrator * */public class Farmer {    public static void main(String[] args) {        //农户联系了一家生产水果的工厂        Factory factory = new FruitFactoryA();        //从该工厂进货，工厂生产水果给农户        Fruit fruit = factory.createFruit(Orange.class);//农户需要橘子        //打印出农户得到的水果        System.out.println(fruit.fruitName());        （我是具体的水果--橘子）    }}

以上便是工厂模式的简单应用，代码虽然多了点，但是结构清晰易懂

另外—农户在进水果的过程中可能不止联系了一个工厂，比如他在工厂A买苹果，在工厂B买橘子。代码表示如下：

/** * 卖水果的农户 * @author Administrator * */public class Farmer {    public static void main(String[] args) {        //农户联系了一家生产水果的工厂A        Factory factory = new FruitFactoryA();        //并向其订购了苹果        Fruit fruit = factory.createFruit(Apple.class);        //打印出农户得到的水果        System.out.println(fruit.fruitName());        //（结果：我是具体的水果--苹果）        //同时农户觉得工厂B的橘子更便宜，又联系了一家生产水果的工厂B        Factory factoryB = new FruitFactoryB();        //并向其订购了橘子        Fruit fruitB = factoryB.createFruit(Orange.class);        //打印出农户得到的水果        System.out.println(fruitB.fruitName());        //（结果：我是具体的水果--橘子）    }}

这种拥有多个工厂的情形，我们成为多工厂方法模式。

还有一种情况就是，当我设定的情形中只有一个工厂的时候，该工厂任务明确，这时候我们没必须再去抽象一个工厂类，比如上述情境中，卖水果的工厂只有一个，则Factory工厂我们可以这样写

public class FactoryB {    public static <T extends Fruit> Fruit createFruit(Class<T> clz) {        Fruit fruit = null;        try {            fruit = clz.newInstance();        } catch (Exception e) {            e.printStackTrace();        }        return fruit;    }}

农户购进水果时：

    Fruit fr =FactoryB.createFruit(Apple.class);    System.out.println(fr.fruitName());

上面这种情况，我们称之为简单工厂模式，或者静态工厂模式。他是工厂方法模式的一个弱化版本。