工厂模式可以分为3类：简单工厂模式、工厂模式、抽象工厂模式

一：简单工厂模式（又叫静态工厂模式）

是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

现在围绕书中的一个运算实例来展开探索（用面向对象的思想来实现一个简单的加减运算）

先创建一个操作基类

/** * @Author: * @Description:封装 * 对numA、numB进行加减运算 * @Date: created in 2018/7/18 * @Modified By: */public class Operation {    public double numA;    public double numB;    public double getNumA() {        return numA;    }    public void setNumA(double numA) {        this.numA = numA;    }    public double getNumB() {        return numB;    }    public void setNumB(double numB) {        this.numB = numB;    }    /**     * 操作数字返回结果     * @return     */    public double result(){        return numA+numB;    }}　

 然后再创建两个加减类继承上述基类重写result结果

/** * @Author:  * @Description: 加 * @Date: created in 2018/7/18 * @Modified By: */public class OperatorAdd extends Operation {    public double result(){        return numA+numB;    }}

/** * @Author:  * @Description: 减 * @Date: created in 2018/7/18 * @Modified By: */public class OperatorSub extends Operation {    public double result(){        return numA-numB;    }}

　接下来我们可以根据不同运算方法创建不同类（通过静态工厂创建）

/** * @Author:  * @Description: * @Date: created in 2018/7/18 * @Modified By: */public class OperationFactory {    public static Operation createOperation(String operation){        Operation oper = null;        switch (operation){            case "+":                oper = new OperatorAdd();                break;            case "-":                oper = new OperatorSub();                break;        }        return oper;    }}

　最后通过实例调用它

/** * @Author:  * @Description: * @Date: created in 2018/7/18 * @Modified By: */public class MainTest {    public static void main(String[] args){//        Operation operation = OperationFactory.createOperation("+");        Operation operation = OperationFactory.createOperation("-");        operation.setNumA(5);        operation.setNumB(5);        System.out.println(operation.result());    }}

　简单工厂将对象的创建过程进行了封装，用户不需要知道具体的创建过程，只需要调用工厂类获取对象即可。

这种简单工厂的写法是通过switch-case来判断对象创建过程的。在实际使用过程中，违背了 开放-关闭原则，当然有些情况下可以通过反射调用来弥补这种不足。

 

二：工厂方法　

 工厂方法在简单工厂的基础上再包了一层工厂，所有的工厂都是此工厂的子类。而产生对象的类型由子类工厂决定。

定义父级工厂接口

/** * @Author:  * @Description:用于创建操作对象 * @Date: created in 2018/7/18 * @Modified By: */public interface IFactory {    Operation creOperation();}

　    创建加法运算子工厂

/** * @Author:  * @Description: * @Date: created in 2018/7/18 * @Modified By: */public class OperationAddFactory implements IFactory {    @Override    public Operation creOperation() {        return new OperatorAdd();    }}

　　创建减法运算子工厂

/** * @Author:  * @Description: * @Date: created in 2018/7/18 * @Modified By: */public class OperationSubFactory implements IFactory {    @Override    public Operation creOperation() {        return new OperatorSub();    }}

　　main方法测试实例

/** * @Author:  * @Description: * @Date: created in 2018/7/18 * @Modified By: */public class MainTest {    public static void main(String[] args){//        IFactory factory = new OperationAddFactory();        IFactory factory = new OperationSubFactory();        Operation operation = factory.creOperation();        operation.setNumA(5);        operation.setNumB(5);        System.out.println(operation.result());    }}

　　工厂方法将类的实例化推迟到了其子类。所以使用工厂方法模式时，需要客户端决定实例化哪一个工厂类。

三：抽象工厂

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

实现

我们将创建 Animal 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 AnimalFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

//创建animal、color接口 /** * @Author:  * @Description:  动物 * @Date: created in 2018/7/19 * @Modified By: */public interface Animal {    void descript();}/** * @Author:  * @Description:  颜色 * @Date: created in 2018/7/19 * @Modified By: */public interface Color {    void fill();}

//animal实现类public class Dog implements Animal {    @Override    public void descript() {        System.out.println("I am dog");    }}public class Cat implements Animal {    @Override    public void descript() {        System.out.println("I am cat");    }}//color实现类public class Red implements Color {    @Override    public void fill() {        System.out.println("I am red");    }}public class Green implements Color {    @Override    public void fill() {        System.out.println("I am green");    }}//为 Color 和 Animal对象创建抽象类来获取工厂。public abstract class AbstractFactory {    public abstract Animal getAnimal(String animal);    public abstract Color getColor(String color);}//创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象public class AnimalFactory extends AbstractFactory {    @Override    public Animal getAnimal(String animal) {        switch (animal){            case "cat":                return new Cat();            case "dog":                return new Dog();        }        return null;    }    @Override    public Color getColor(String color) {        return null;    }}public class ColorFactory extends AbstractFactory {    @Override    public Animal getAnimal(String animal) {        return null;    }    @Override    public Color getColor(String color) {        switch (color){            case "red":                return new Red();            case "green":                return new Green();        }        return null;    }}//创建一个工厂生成器类，通过动物信息或颜色信息来获取工厂。public class FactoryProducer {    public static AbstractFactory getFactory(String choice){        if(choice.equalsIgnoreCase("Animal")){            return new AnimalFactory();        }else if(choice.equalsIgnoreCase("Color")){            return new ColorFactory();        }        return null;    }}//main方法测试public class MainTest {    public static void main(String[] args){        //获取动物工厂        AbstractFactory abstractFactory = FactoryProducer.getFactory("animal");        Animal animal =  abstractFactory.getAnimal("cat");        Animal animal2 =  abstractFactory.getAnimal("dog");        animal.descript();        animal2.descript();        //获取颜色工厂        AbstractFactory abstractFactory2 = FactoryProducer.getFactory("color");        Color color = abstractFactory2.getColor("red");        Color color2 = abstractFactory2.getColor("green");        color.fill();        color2.fill();    }}//输出结果　I am cat　I am dog  I am red  I am green