设计模式 - 工厂模式

简单工厂模式

一、 介绍

简单工程模式就是通过不同的参数返回不同的实例，被创建的实例往往都有相同的父类

二、特点

1. 主要用于创建对象实例

2. 创建的对象实例往往都应该有相同的父类

3. 根据传入的参数判断创建什么样的实例

三、例子

/**
 *  简单工程  运行
 */
public class OperationFactory {

   companion object{
       // 这里的全是静态的方法和变量
       public fun  createOperate(operate:String):Operation{
           var operation:Operation? = null;
           when(operate){
               "+"->operation= OperationAdd()
               "-"->operation= OperationSub()
               "*"->operation= OperationMul()
               "/"->operation= OperationDiv()
           }
           return operation!!
       }
   }
}

使用：

Operation operation = OperationFactory.Companion.createOperate("+");
operation.setNumberA(44);
operation.setNumberB(44);
System.out.println("结果为：" + operation.operationResults());

 

工厂方法模式

前言：

不管是简单工厂模式还是工厂模式，都是为实例化对象存在。当我们写的功能使用时，需要多个实例化对象时，可以考虑使用工厂模式

简单工厂模式通过传入的type实现创建不同的对象。但是，以后每次新增加了一个对象，都需要在修改工厂类，这不符合代码的开放-封闭原则，而且每次添加一个新的对象都需要if else 判断。

为了解决上述问题，我们可以对每一个对象都实现一个工厂子类，工厂子类继承工厂类。这样每次实例化一个工厂子类就好。这个就是工厂方法模式

范例：

/**
 *  工厂接口，所有的工厂都需要实现该接口
 */
public interface Factory {
    // 实例化类
    Operation create();
}

/**
 *  加法工厂
 */
public class FactoryAdd implements Factory{
    @Override
    public Operation create() {
        return new OperationAdd();
    }
}

/**
 *  减法工厂
 */
public class FactorySub implements Factory{
    @Override
    public Operation create() {
        return new OperationSub();
    }
}

使用：

public static void main(String[] args) {
    // 加法运算
    Operation add = new FactoryAdd().create();
    add.setNumberA(2);
    add.setNumberB(2);
    add.operationResults();

    // 减法运算
    Operation sub = new FactorySub().create();
    sub.setNumberA(2);
    sub.setNumberB(2);
    sub.operationResults();
}

抽象工厂模式

上述例子为工厂方法模式。相当于把简单工厂方法里的判断逻辑，放到客户端去自己处理了。这样之后有新的运算方式，都可以通过添加的方式。

但是上面你就会发现，如果我每次添加一个运算，就得写一个工厂类，这也太麻烦了吧，这时，就可以使用抽象工厂模式

抽象工厂模式针对的是一个一个产品一个工厂类，工厂类里有很多实现的方法。举例来说：

现有卡西欧和得力两种计算器的品牌，属于两种产品，但都是计算器产品

现在弄一个父类的接口，计算器工厂接口，父类工厂里定义多个功能方法，如加，减运算及创建对了方法等。

/**
 *  父类为计算器工厂接口
 */
public interface CalculatorFactory {

    /**
     *  加法
     * @return
     */
    Operation add();

    /**
     *  减法
     * @return
     */
    Operation sub();

}

/**
 *  得力计算器的工厂类
 */
public class DeliCalculatorFactory implements CalculatorFactory{
    @Override
    public Operation add() {
        return new OperationAdd();
    }

    @Override
    public Operation sub() {
        return new OperationSub();
    }
}

/**
 *  卡西欧计算器的工厂类
 */
public class CasioCalculatorFactory implements CalculatorFactory{
    @Override
    public Operation add() {
        return new OperationAdd();
    }

    @Override
    public Operation sub() {
        return new OperationSub();
    }
}

使用：

public static void main(String[] args) {
    CalculatorFactory casioCalculatorFactory = new CasioCalculatorFactory();
    CalculatorFactory deliCalculatorFactory = new DeliCalculatorFactory();

    casioCalculatorFactory.add().operationResults();
    casioCalculatorFactory.sub().operationResults();

    deliCalculatorFactory.add().operationResults();
    deliCalculatorFactory.sub().operationResults();
}

综上，就是所有的工厂模式。工厂模式本质还是对new实例化的操作。因为发展过程中的一系列问题，慢慢演化。对于工厂模式，可能我现在在项目中很少去使用它们。但它们的思路还是值得去学习的。

设计模式，只是我们写代码时的工具，需要它们就用，不需要，就不用

 

此文章只做自己学习时的记录，看看就好