为具有不同参数的方法设计接口

Question

这更像是一个设计问题而不是图形问题，但这里有一点背景知识：我正在使用 OpenGL（在 Java 中，使用 JOGL）编写一个程序，它可以从 .obj 文件加载网格并渲染它.到目前为止没有问题，但我需要能够对网格应用一系列过滤器或转换，例如

• 曲面细分
• 向顶点添加随机噪声
• 对噪声网格应用平滑算法
• 为网格着色（可能基于也可能不基于平滑网格和原始干净网格）

将按顺序应用其中几个过滤器。我还想为其他人提供某种一致的接口来编写他们自己的（可能是通用的）过滤器。我该怎么办？

主要问题是过滤器可能需要不同的参数集，例如一种平滑算法可能需要用户选择两个参数（在运行时，使用 GUI），而另一种可能不需要。类似地，一些着色算法可能只需要平滑网格和 RGB 颜色，另一种可能需要平滑网格和干净网格（从中生成颜色）。所以调用可能看起来像：

mesh = smoothingFilter1.filter(mesh, booleanParam);

但可能完全不同：

mesh = smoothingFilter2.filter(mesh, intParam1, intParam2, floatParam);

显然我的代码需要能够调用通用过滤方法。为Filter 定义一个抽象类或接口，并使用未实现的方法将其自身（及其所需的参数）注册到某种控制类是一个好主意吗？看起来很复杂，但我想不出任何其他方法来让程序使用具有任意签名的过滤器方法。我什至不确定这个想法是否可行......

有处理这种情况的设计模式吗？

Answer 1

其实你根本不需要参数。 Mesh filter(Mesh mesh); 就足够了。 将其他参数移动到过滤器的不同具体实现的构造函数中。

看起来像这样：

Filter smoothingFilter1 = new FirstFilter(booleanParam);    
mesh = smoothingFilter1.filter(mesh);

Filter smoothingFilter2 = new SecondFilter( intParam1, intParam2, floatParam);    
mesh = smoothingFilter2.filter(mesh);

对于实例化，您可以使用以下内容：

public interface AbstractFilterFactory {
  Params getRequiredParams();
  Filter createFilter(Params params);
}

public interface Params {
 // some interface that describes specific parameters that are required
 // probably a collection of Parameter classes which has name, type and value information. 
}

public class FirstFilterFactory implements AbstractFilterFactory {
  // return a concrete params object use that to instantiate a concrete filter.
}

Answer 2

另一种方法（我不太喜欢）是将参数捆绑在一个对象中，并使用多态性为不同的对象传递不同的参数。

首先，一个快速而肮脏的版本，使用地图：

interface Filter {
    Mesh filter(Mesh input, Map<String, Object> params);
}

多态对象：

abstract class Parameters {
}

interface Filter {
    Mesh filter(Mesh input, Parameters params);
}

class FirstFilterParameters extends Parameters {
    private boolean booleanParam;
    // constructor, getter, possibly setter
}

class FirstFilter implements Filter {
    Mesh filter(Mesh input, Parameters params) {
        FirstFilterParameters ffParams = (FirstFilterParameters)params;
        boolean booleanParam = ffParams.getBooleanParam();
        // etc
    }
}

通过泛型实现类型安全的多态对象：

abstract class Parameters {
}

interface Filter<P extends Parameters> {
    Mesh filter(Mesh input, P params);
}

class FirstFilterParameters extends Parameters {
    private boolean booleanParam;
    // constructor, getter, possibly setter
}

class FirstFilter implements Filter<FirstFilterParameters> {
    Mesh filter(Mesh input, FirstFilterParameters params) {
        boolean booleanParam = params.getBooleanParam();
        // etc
    }
}

不过，带有泛型的版本使过滤器的多态处理变得更加困难。如果您想要一个过滤器列表和一个参数列表，并使用相应的参数应用每个过滤器，您会怎么做？没有办法安全地做到这一点。您必须做一些操作，例如将每一对打包成一个具有自己类型参数的对象，例如FilterWithParams<P extends Parameters>，并拥有一个List<FilterWithParams<?>>。至此，您基本上重新发明了 M. Platvoet 的解决方案！

Answer 3

另一个类似的解决方案，没有泛型，是声明一个抽象参数类：

abstract class FilterParameters { }

你的界面看起来像：

interface Filter {
  Mesh filter(Mesh input, FilterParameters params);
}

对于需要的每组新参数，您声明一个新的 FilterParameters 子类，它可以携带所有必需的参数。

// Foo parameter only.
class FooFilterParameters extends FilterParameters { 
  public Foo getFoo() { }
  // Other stuff.
}

// Foo, Bar and int parameters.
class BarFilterParameters extends FilterParameters { 
  public Foo getFoo() { }
  public Bar getBar() { }
  public int getMagnification() { }
  // Other stuff.
}

每个过滤方法都需要检查其参数的类型：

// Foo filter
public Mesh filter(Mesh inMesh, FilterParameters fp) {
  if (!(fp instanceof FooFilterParameters)) {
    throw new IllegalParameterException("Not FooFilterParameters.");
  }
  // Foo filter code here.
}

玫瑰