给定场景的类/接口设计方法

Question

我有 10-15 种不同类型的结果来计算 AResult、BResult 等。所有结果计算都返回单一类型的值（考虑一个 integer 值）。 为了计算这些，我需要输入参数，这些参数大多是常见的，但有一些需要不同的参数，如下所示：

Input parameters example:
    AResult needs  int x, int y, int a[], int b[]
    BResult needs  int x, int y, int a[], boolean c
    CResult needs  int x, int y, int a[], boolean c, boolean d
    DResult needs  int x, int y, int p[], boolean e
    .....

注意，在某些情况下，一个计算的结果也会用于其他结果计算，但这只是少数情况，而不是全部。

我的做法是通过Approach1如下：

方法一：

我正在定义一个接口，该接口具有单一方法来计算采用InputParameter obj 的结果。在实现类中，我将从InputParameter obj 中提取适用于该特定类型结果的值。这是我的示例代码的 sn-p：

public interface Result {
    int calculate(InputParameter obj);
}

public class AResult implements Result {
    public int calculate(InputParameter obj){
      // code
     }

}

public class BResult implements Result {
    public int calculate(InputParameter obj)){
      // code
     }


}

public class InputParameter {
    int x;
    int y;
    int z;
    int a[];
    int b[];
    int p[];
    boolean c;
    boolean d;
    boolean e;
    ....
    // Getters and Setters
}

例如，假设我创建了一个InputParameter 对象并设置其中所有字段的值。我将此对象传递给 aResultObject.calculate(InputParameter obj) 、 dResultObject.calculate(InputParameter obj) 等等。

AResult 需要我从InputParameter obj 提取的int x, int y, int a[], int b[] 进行计算并返回结果。

DResult 需要int x, int y, int p[], boolean e，我从同一个InputParameter obj 中提取它来进行计算并返回结果。

注意，我可能需要做其他组的结果计算，所以可能会创建InputParameter、AResult、BResult 等多个对象。只是想表达InputParameter 不必是单例的。

---

方法2：

拥有不带任何参数的 calculate() 方法并在各个 Result 类构造函数中设置这些值。

正如@Duncan 指出的Approach1 的一个缺点是，在这里我可能会错过在InputParameter 对象中为给定结果计算设置必填字段。而当我实际尝试在calculation(InputParameter obj) 方法中从InputParameter 对象中提取值时，我发现它没有设置。

public interface Result {
   int calculate();
}

public class AResult implements Result {
   public AResult(int x, int y, int a[], int b[]) {
      //set input params
   }
   public int calculate() {
      //calculate and return AResult
   }
}

---

方法3：

为 Result 创建单个类（或可能只是 2-3 个类），然后使用单独的方法来计算不同的结果。

我也在考虑这种方法，因为在某些情况下，一个计算的结果也会用于其他结果计算（但这只是在少数情况下，而不是全部）。

public class Result {
   // various fields...

   int calculateResultA(){...}
   int calculateResultB(){...}
   int calculateResultC(){...}
}

上面提到的Approach1是否适合给定的情况？还是其他替代品更好？

Answer 1

我建议使用工厂方法 2。 模式是（可能）command。

工厂方法

package blammy.result;

public interface Result
{
    int calculate();
}

package blammy.result.impl;

public class AResult
implements Result;
{
    /*
     * Protected constructor to hinder naughty construction.
    */
    protected AResult(
        int x,
        int y,
        int a[],
        int b[])
    {
        ... blah;
    }

    public int calculate()
    {
        int returnValue;
        returnValue = ... blah.
        return returnValue;
    }
}
public class BResult
implements Result;
{
    /*
     * Protected constructor to hinder naughty construction.
    */
    protected BResult(
        int x,
        int y,
        boolean c)
    {
        ... blah;
    }

    public int calculate()
    {
        int returnValue;
        returnValue = ... blah.
        return returnValue;
    }
}

public static class ResultFactory
{
    public static Result createResult(
        int x,
        int y,
        int a[],
        int b[])
    {
        return new AResult(x, y, a, b);
    }

    public static Result createResult(
        int x,
        int y,
        boolean c)
    {
        return new BResult(x, y, c);
    )
}

编辑 1

如果不同的计算需要相同的参数，那么你应该在工厂和类名中使用描述性名称。例如：

public static class ResultFactory

    public static Result createBlammy(
        int x,
        int y,
        int a[],
        int b[])
    {
        return new ResultBlammy(x, y, a, b);
    }

    public static Result createHooty(
        int x,
        int y,
        int a[],
        int b[])
    {
        return new ResultHooty(x, y, a, b);
    }

Answer 2

在我看来，使用构造函数并定义接口Result 有一个不带参数的方法public int calculate()。

免责声明从这里开始，是个人解释几个好的原则。评估它们，如果你不同意就批评它们，不要把它们当作既定的事实（原则真的很好，你的案例的解释可能不是那么好）。

我会尽量避免使用内聚力低的对象，其中内聚力在书Growing object oriented software guided by tests 中定义为

一个元素的凝聚力是衡量其职责是否形成一个有意义的单元的指标。例如，一个同时解析日期和 URL 的类是不连贯的，因为它们是不相关的概念。想想一台既洗衣服又洗盘子的机器——它不太可能同时做好。2 在另一个极端，一个只解析 URL 中的标点符号的类不太可能是连贯的，因为它不能代表一个完整的概念。为了完成任何事情，程序员必须为协议、主机、资源等寻找其他解析器。具有“高”一致性的特征更容易维护。

在你的情况下，我相信InputParameter 有责任为不同的类保存参数，所以在我看来它的责任不是一个有意义的单元（即使它基本上是一个值对象，在某种程度上它违反了Single Responsibility Principle)