链接的Java泛化

我有一个实现fluent接口模式的类，如下所示：

Class Rules {

  private List<Map<String, String>> listOfMap;

public Rules getListAddresses(List<Map<String, String>> listAddresses) {
    listOfMap = new ArrayList<>(listAddresses);
    return this;
}

  public List<Map<String, String>> fOut() {
    return listOfMap;
  }

  public Rules f1() {
      listOfMap = ....;
      return this;
  }

  public Rules f2() {
      listOfMap = ....;
      return this;
  }

...
...

}

类规则{
私有列表地图；
公共规则getListAddresses（列表listAddresses）{
listOfMap=新的ArrayList（listAddresses）；
归还这个；
}
公众名单fOut（）{
返回地图列表；
}
公共规则f1（）{
listOfMap=。。。。；
归还这个；
}
公共规则f2（）{
listOfMap=。。。。；
归还这个；
}
...
...
}

我有几个类以下面的方式使用链接

Class A extends Rules{

        List<Map<String, String>> listOfMap = dropActiveStatus(listOfMapInout);

        //TODO make some king of CONSTANT to function name mapping
        List<Map<String, String>> listOfMapOut = this.getListAddresses(listOfMap)
            .f1()
            .f2()
            .f3()
            .f4()
            .fOut();

....
}

Class B extends Rules{

        List<Map<String, String>> listOfMap = dropActiveStatus(listOfMapInout);

        //TODO make some king of CONSTANT to function name mapping
        List<Map<String, String>> listOfMapOut = this.getListAddresses(listOfMap)
            .f5()
            .f6()
            .fOut();

....
}

A类扩展了规则{
List listOfMap=dropActiveStatus（listOfMapInout）；
//TODO做一些常量到函数名的映射
List listOfMapOut=this.getListAddresses（listOfMap）
.f1（）
.f2（）
.f3（）
.f4（）
.fOut（）；
....
}
B类扩展了规则{
List listOfMap=dropActiveStatus（listOfMapInout）；
//TODO做一些常量到函数名的映射
List listOfMapOut=this.getListAddresses（listOfMap）
.f5（）
.f6（）
.fOut（）；
....
}

我想定义一个泛型类，而不是多个类a、B、C

我怎样才能强制执行呢

---

如果我可以为每个方法调用定义一些常量，并在每个类的构造函数中按顺序定义这些常量，那么我就可以根据类的指定使用这些常量来调用方法。

带有与规则函数相匹配的函数接口

f1

，

f2

，

f3

：

interface RuleFunction extends Function<Rules, Rules> { }

接口规则函数扩展函数{}

您可以编写一个类来应用您传递的任何规则组合：

public class RuleApplier {
    private RuleFunction[] steps;

    public RuleApplier(RuleFunction... steps) {
        Objects.requireNonNull(steps);
        this.steps = steps;
    }

    public List<Map<String, String>> apply(List<Map<String, String>> listOfMap) {
        Rules rules = new Rules().getListAddresses(listOfMap);
        for (RuleFunction step : steps) {
            rules = step.apply(rules);
        }
        return rules.fOut();
    }
}

公共类规则应用程序{
私有规则函数[]步骤；
公共规则应用程序（规则函数…步骤）{
对象。requirennull（步骤）；
这个步骤=步骤；
}
公共列表应用（地图列表）{
规则规则=新规则（）.getListAddresses（listOfMap）；
for（规则功能步骤：步骤）{
规则=步骤。应用（规则）；
}
返回规则。fOut（）；
}
}

构造类方法时，引用提供了一种方便的速记，可用于引用要应用的规则：

List<Map<String, String>> listOfMap = dropActiveStatus(listOfMapInout);

RuleApplier applierA = new RuleApplier(Rules::f1, Rules::f2, Rules::f3, Rules::f4);
List<Map<String, String>> listOfMapOutA = applierA.apply(listOfMap);

RuleApplier applierB = new RuleApplier(Rules::f5, Rules::f6);
List<Map<String, String>> listOfMapOutB = applierB.apply(listOfMap);

List listOfMap=dropActiveStatus（listOfMapInout）；
RuleApplier applierA=新的RuleApplier（规则：：f1，规则：：f2，规则：：f3，规则：：f4）；
listOfMapOutA=applierA.apply（listOfMap）；
RuleApplier applierB=新的RuleApplier（规则：：f5，规则：：f6）；
List listOfMapOutB=applierB.apply（listOfMap）；

在我看来，解决方案可以简化：

public class RuleApplier {
    private UnaryOperator<Rules> operator;

    public RuleApplier(UnaryOperator<Rules> operator) {
        Objects.requireNonNull(operator);
        this.operator = operator;
    }

    public List<Map<String, String>> apply(List<Map<String, String>> listOfMap) {
        Rules rules = new Rules().getListAddresses(listOfMap);
        return operator.apply(rules).fOut();
    }
}

公共类规则应用程序{
私人一元操作员；
公共规则应用程序（非规则运算符）{
对象。requirennull（运算符）；
this.operator=操作员；
}
公共列表应用（地图列表）{
规则规则=新规则（）.getListAddresses（listOfMap）；
返回运算符.apply（rules）.fOut（）；
}
}

然后是用法：

RuleApplier applierA = new RuleApplier(rules -> rules.f1().f2().f3().f4());
List<Map<String, String>> listOfMapOutA = applierA.apply(listOfMap);

RuleApplier applierA=新规则应用程序（规则->规则.f1（）.f2（）.f3（）.f4（））；
listOfMapOutA=applierA.apply（listOfMap）；