Java 降低此方法的布尔表达式复杂性？

此isValid（）方法最多可以设置6个属性以进行验证。如果未设置特定属性，则不需要对其进行验证。逻辑似乎正按照我希望的方式运作。如何降低此方法的布尔表达式复杂性

import java.util.ArrayList;
import java.util.List;

public class Valid {

private int foo;
private int bar;
private int foobar;
private String foofoo;
private String barbar;
private String foobarfoobar;

private int myfoo;
private int mybar;
private int myfoobar;
private String myfoofoo;
private List<String> mybarbarlist = new ArrayList<String>();
private String myfoobarfoobar;

private boolean validate;

public boolean isValid() {

    validate = false;

    if ((((foo > 0) && (foo == myfoo)) || (foo == 0))
            && (((bar > 0) && (bar == mybar)) || (bar == 0))
            && (((foobar > 0) && (foobar == myfoobar)) || (foobar == 0))
            && (((foofoo != null) && (foofoo.equals(myfoofoo))) || (foofoo == null))
            && (((barbar != null) && (mybarbarlist.contains(barbar))) || (barbar == null))
            && (((foobarfoobar != null) && (foobarfoobar
                    .equals(myfoobarfoobar))) || (foobarfoobar == null)))
        validate = true;
    return validate;
}

public static void main(String[] args) {

    Valid valid = new Valid();

    // valid.foo = 1;
    // valid.bar = 1;
    // valid.foobar = 1;
    // valid.foofoo = "1";
    // valid.barbar = "1";
    // valid.foobarfoobar = "1";

    // valid.myfoo = 1;
    // valid.mybar = 1;
    // valid.myfoobar = 1;
    // valid.myfoofoo = "1";
    // valid.mybarbarlist.add("1");
    // valid.myfoobarfoobar = "1";

    System.out.println(valid.isValid());
}
}

import java.util.ArrayList；
导入java.util.List；
公共类有效{
私人英孚；
私人酒吧；
私人国际足球俱乐部；
私人字符串foofoo；
私人字符串芭芭拉；
私有字符串foobarfoobar；
私人英特美孚；
私家密室；
私人int myfoobar；
私有字符串myfooo；
私有列表mybarbarlist=新的ArrayList（）；
私有字符串myfoobarfoobar；
私有布尔验证；
公共布尔值isValid（）{
验证=假；
如果（（（foo>0）和&（foo==myfoo））| |（foo==0））
&&（（bar>0）和&（bar==mybar））| |（bar==0））
&&（（foobar>0）和&（foobar==myfoobar））| |（foobar==0））
&&（（（foooo！=null）和&（foooo.equals（myfooo）））| |（foooo==null））
&&（（（barbar！=null）&&（mybarbarlist.contains（barbar）））| |（barbar==null））
&&（（（foobarfoobar！=null）和&（foobarfoobar）
.equals（myfoobarfoobar））| |（foobarfoobar==null）））
验证=真；
返回验证；
}
公共静态void main（字符串[]args）{
Valid=new Valid（）；
//valid.foo=1；
//valid.bar=1；
//valid.foobar=1；
//valid.foooo=“1”；
//valid.barbar=“1”；
//valid.foobarfoobar=“1”；
//valid.myfoo=1；
//valid.mybar=1；
//valid.myfoobar=1；
//valid.myfooo=“1”；
//有效。请在列表中添加（“1”）；
//valid.myfoobarfoobar=“1”；
System.out.println（valid.isValid（））；
}
}

我建议阅读布尔代数和简化布尔表达式。有多种方法可以做到这一点，无论是卡诺图还是简单地使用代数定律

你可以检查一下，这会让你对它的内容有一个基本的了解。关于您的代码，我建议您记下一个真值表，并在方法返回真值时计算出真值。从那里抓取你的当前方程，并尽可能地简化它

---

还要给您一个简化工作原理的示例：

异或B=A&！B或！A&B酒店

如果是右侧的简化表达式，则为左侧

---

---

要获得一个肯定会对您有所帮助的定律列表，请查看

我将首先为每个子表达式指定有意义的名称，并将结果分配给变量，然后在变量之间执行&&检查。这将大大提高可读性

而且你的情况似乎都有这种形式

（X！=null&&X==value）| | X==null

可以使用短路评估来简化，以

X==null|X==value

由于如果

X==null

计算结果为true，则不需要检查右侧，或者如果

X==null

计算结果为false，则需要检查右侧，您已经知道它不是null，因此不需要检查右侧表达式中的null

将两者结合起来，您将得到如下结果：

public boolean isValid() {

    validate = false;

    boolean fooCond = (foo == 0) || (foo == myfoo);
    boolean barCond = (bar == 0) || (bar == mybar);
    boolean foobarCond = (foobar == 0) || (foobar == myfoobar);
    boolean foofooCond = (foofoo == null) || foofoo.equals(myfoofoo);
    boolean barbarCond = (barbar == null) || mybarbarlist.contains(barbar);
    boolean foobarfoobarCond = (foobarfoobar == null) || foobarfoobar.equals(myfoobarfoobar);

    if (fooCond
          && barCond
          && foobarCond
          && foofooCond;
          && barbarCond
          && foobarfoobarCond) {
        validate = true;
    }

    return validate;
}

编辑

这对正在检查的表达式不太适用

((foo > 0) && (foo == myfoo)) || (foo == 0)

因为if

foo<0

返回false。如果你真的想

((foo > 0) && (foo == myfoo)) || (foo <= 0)

---

（（foo>0）和&（foo==myfoo））| |（foo您可能希望关注可读性并返回
false
，如果这些子表达式中的任何一个单独失败，只在最底部返回
true
。对于我正在验证的数据，所有值都始终大于零，因此不会产生任何影响。不过，感谢您的编辑。