大话设计模式之工厂模式

工厂模式可以分为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