IntelliJ IDEA：布尔方法XX总是反转

Question

I am getting warning " Boolean method is always inverted " on running lint in IntelliJ. I have several similar warnings in my codebase. Which basic coding style, am I missing?

public static boolean isBlueToothEnabled(){
    final BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    if(bluetoothAdapter != null)
        return bluetoothAdapter.isEnabled();
    return  false;
}

Answer 1

try to return false if bluetoothAdapter is null otherwise return the output of isEnabled()

public static boolean isBlueToothEnabled(){
    final BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    if(bluetoothAdapter == null){
        return false;
    }
    return bluetoothAdapter.isEnabled();
}

Read more:

In Clean Code, Robert Martin writes, “Negatives are just a bit harder to understand than positives. So, when possible, conditionals should be expressed as positives.” (Martin, [G29]). IntelliJ IDEA has three inspections to help you stay positive.

https://blog.jetbrains.com/idea/2014/09/the-inspection-connection-issue-2/ (Entry #4 Avoiding negative Conditionals)

https://www.jetbrains.com/help/idea/2016.1/invert-boolean.html

Answer 2

Summary: Method always called like !method(). It's more efficient to have less number of computation. Refactor the method and return oppositely and call the method without (!)

---

Why it happens

If we have a method foo()

    boolean foo()
    {
        if(condition == true)
            return true;
        else
            return false;
    }

And is only called like !foo() ,

    class A
    {
        if(!foo())
            do something;
        ...
        if(!foo())
            do something else;
    }

Because we only call !foo() and did not call foo() .

The warning asks us to use foo() in a positive way.

Remove the warning

By inverting the return value of the method foo(),

    boolean foo()
    {
        if(condition == true)
            return **false**;
        else
            return **true**;
    }

Now call the method

    class A
    {
        if(foo())
            do the same thing;
    }

Answer 3

I must say that there are cases where I think this warning isn't even fixable in a reasonable way. Take for example code looking like this:

boolean getInfo(Info info) {
    // Retrieve some info that can fail so the function returns true or false
}

void func() {
    Info info;

    if (!getInfo(info)) {
        // Failed; handle error, early out
        return;
    }

    // Do stuff

    if (!getInfo(info)) {
        // Failed; handle error, early out
        return;
    }

    // Do stuff

    if (!getInfo(info)) {
        // Failed; handle error, early out
        return;
    }

    // Do final calculations
}

What to do in a case like this? Rename the function to notGetInfo() ? getDesinformation() ? Don't early out of the function on failure resulting in a growing tree of brackets?

Answer 4

For simplify, See the code below:

public boolean isBoy(int sex){ return sex == boy};

if(!isBoy(sex)){ // todo}

If do so, it called inverted. How to solve? see the other code below:

public boolean isGirl(int sex){ return sex == girl};

if(isGirl(sex)){ // todo}

Because you need to judge the condition whether is a girl, So that you should avoid to judge whether is a boy and put a '!'.