Java模拟和或用于连接规则

我有一个如下所示的Java类

class MyClass {

public boolean rule1() {...}

public boolean rule2() {...}

public boolean rule3() {...}

}

例如，现在我想通过多种方式检查上述类的规则，例如：

MyClass myClass = new MyClass();
if (myClass.rule1() && myClass.rule2 || myClass.rule3) {}

现在我想知道，我如何实现像这样的一个线以上

if (myClass.rule1().and().rule2().or().rule3().accept()) {}

查看及其

和
或
或

MyClass instance = new MyClass();
Predicate<MyClass> predicate = MyClass::rule1;
if (predicate.and(MyClass::rule2).or(MyClass::rule3).test(instance)) {
  // todo
}

MyClass实例=新建MyClass（）；
谓词=MyClass:：rule1；
if（predicate.and（MyClass:：rule2）.或（MyClass:：rule3）.test（实例））{
//待办事项
}

它的可读性可能不如您提到的版本，将
MyClass
重命名为更有意义的版本会有所帮助。如果它对你不起作用，考虑写一个。可以在动态SQL构建器（例如）中找到很好的复杂示例。
更简洁的方法是使用函数接口：

类型参数：

T-谓词函数的输入类型
接口：这是一个功能接口，因此可以用作
lambda表达式或方法引用的赋值目标

但是
if
方法调用链看起来不像您正在寻找的，即：

 if (myClass.rule1().and().rule2().or().rule3().accept()) {}

否则，您必须实现该模式，并实现and（）、or（）和accept方法。例如：

public class BooleanEvaluator {

    List<String> rules = new ArrayList<>();

    public BooleanEvaluator and() {
        rules.add("&&");
        return this;
    }

    public BooleanEvaluator or() {
        rules.add("or");
        return this;
    }

    public boolean accept() {
        int i = 0;
        boolean result = Boolean.parseBoolean(rules.get(0));
        while (i < rules.size() - 1) {
            if(rules.get(i).equals("&&")){
                result = result && Boolean.parseBoolean(rules.get(i + 1));
                i+=2;
            }
            else if(rules.get(i).equals("||")){
                result = result || Boolean.parseBoolean(rules.get(i + 1));
                i+=2;
            }
        }
        return false;
    }

    public BooleanEvaluator rule1() {
        boolean result = // apply the rule 1
        rules.add(String.valueOf(result));
        return this;
    }

    public BooleanEvaluator rule2() {
        boolean result = // apply the rule 2
        rules.add(String.valueOf(result));
        return this;
    }

    public BooleanEvaluator rule3() {
        boolean result = // apply the rule 3
        rules.add(String.valueOf(result));
        return this;
    }

    void some_method(){
        if (this.rule1().and().rule2().or().rule3().accept()) {
            // ...
        }
    }
}

公共类布尔计算器{
列表规则=新建ArrayList（）；
公共布尔计算器和（）{
规则。添加（&&）；
归还这个；
}
公共布尔计算器或（）{
规则。添加（“或”）；
归还这个；
}
公共布尔接受（）{
int i=0；
布尔结果=boolean.parseBoolean（rules.get（0））；
而（i

当然，
accept
方法必须更加健壮，这只是为了展示设计的样子。
你没有错，我只是说，与原始代码相比，它的可读性要差得多。
public class BooleanEvaluator {

    List<String> rules = new ArrayList<>();

    public BooleanEvaluator and() {
        rules.add("&&");
        return this;
    }

    public BooleanEvaluator or() {
        rules.add("or");
        return this;
    }

    public boolean accept() {
        int i = 0;
        boolean result = Boolean.parseBoolean(rules.get(0));
        while (i < rules.size() - 1) {
            if(rules.get(i).equals("&&")){
                result = result && Boolean.parseBoolean(rules.get(i + 1));
                i+=2;
            }
            else if(rules.get(i).equals("||")){
                result = result || Boolean.parseBoolean(rules.get(i + 1));
                i+=2;
            }
        }
        return false;
    }

    public BooleanEvaluator rule1() {
        boolean result = // apply the rule 1
        rules.add(String.valueOf(result));
        return this;
    }

    public BooleanEvaluator rule2() {
        boolean result = // apply the rule 2
        rules.add(String.valueOf(result));
        return this;
    }

    public BooleanEvaluator rule3() {
        boolean result = // apply the rule 3
        rules.add(String.valueOf(result));
        return this;
    }

    void some_method(){
        if (this.rule1().and().rule2().or().rule3().accept()) {
            // ...
        }
    }
}