减少表达式中使用的条件运算符（4）的数量（允许的最大值3）

Question

How can i reduce the complexitiy of my operators? i have a conditional issue.

Object someObject = getSomeObject();
boolean isNotInstanceOfA = !(someObject instanceof A);
boolean isNotInstanceOfB = !(someObject instanceof B);
boolean isNotInstanceOfC = !(someObject instanceof C);
boolean isNotInstanceOfABC = isNotInstanceOfA && isNotInstanceOfB && isNotInstanceOfC;
if (isNotInstanceOfABC && (container.getChildren(itemId) == null || container.getChildren(itemId).isEmpty())) {
    return "something";
 }

Answer 1

You can actually compute the conditions prior to the if block so that the code will be more readable as shown below:

boolean isChildNull = (container.getChildren(itemId) == null);
boolean isChildEmpty = (isChildNull || container.getChildren(itemId).isEmpty());

if (isNotInstanceOfABC && isChildEmpty) {
    return "something";
}

But, I infer from your code that you are doing something wrong because you are doing lots of instanceof checks which is NOT at all a good practice , you might need to consider refactoring your code as explained here ( Replace conditionals with polymorphism ).

Answer 2

itemId is primitive type or not ? i am guessing that it is not primitive and to reduce code you can move this null or empty checking to a separate method and return a boolean value.. and you can also reduce some code like this: `

    boolean isNotInstanceOfABC = !(someObject instanceof A) && !(someObject instanceof B) && !(someObject instanceof C);

    if (isNotInstanceOfABC && isEmptyOrNull(container.getChildren(itemId))) {
        return "something";
    }`

Answer 3

Not sure if it is an option for you, but i would try to refactor code in this way:

Object someObject = getSomeObject();

if (isInstanceOfABC(someObject)) {
    log.debug("Instance of A, B or C");
    return;
}

if (childrenIsEmptyOrNull( container.getChildren(itemId) ) {
    log.debug("Children is null or empty");
    return;
}

return "something";

---

private boolean isInstanceOfABC(Object someObject) {
    return someObject instanceof A
            || someObject instanceof B
            || someObject instanceof C;
}

---

private boolean childrenIsEmptyOrNull(Children children) {
    return children == null || children.isEmpty();
}

---

However,

using instance of is a code smell . Whenever I see a construction like that, I'm sure that something went awry. You'd better stop now and get rid of all this checks with the help of polymorphysm.

Answer 4

Normalise your logical expression then utilise the method below

public boolean AND_Operator(boolean ...values) {

        for (boolean b : values) {
            if(!b)
                return false;
        }

        return true;
    }

    public static boolean OR_Operator(boolean ...values) {

        for (boolean b : values) {
            if(b)
                return true;
        }

        return false;
    }