Why doesn't Java have compound assignment versions of the conditional-and and conditional-or operators? (&&=, ||=)

Reason

The operators &&= and ||= are not available on Java because for most of the developers these operators are:

• error-prone
• useless

Example for &&=

If Java allowed &&= operator, then that code:

bool isOk = true; //becomes false when at least a function returns falseisOK &&= f1();isOK &&= f2(); //we may expect f2() is called whatever the f1() returned value

would be equivalent to:

bool isOk = true;if (isOK) isOk = f1();if (isOK) isOk = f2(); //f2() is called only when f1() returns true

This first code is error-prone because many developers would think f2() is always called whatever the f1() returned value. It is like bool isOk = f1() && f2(); where f2() is called only when f1() returns true.

If the developer wants f2() to be called only when f1() returns true, therefore the second code above is less error-prone.

Else &= is sufficient because the developer wants f2() to be always called:

Same example but for &=

bool isOk = true;isOK &= f1();isOK &= f2(); //f2() always called whatever the f1() returned value

Moreover, the JVM should run this above code as the following one:

bool isOk = true;if (!f1())  isOk = false;if (!f2())  isOk = false;  //f2() always called

Compare && and & results

Are the results of operators && and & the same when applied on boolean values?

Let's check using the following Java code:

public class qalcdo {    public static void main (String[] args) {        test (true,  true);        test (true,  false);        test (false, false);        test (false, true);    }    private static void test (boolean a, boolean b) {        System.out.println (counter++ +  ") a=" + a + " and b=" + b);        System.out.println ("a && b = " + (a && b));        System.out.println ("a & b = "  + (a & b));        System.out.println ("======================");    }    private static int counter = 1;}

Output:

1) a=true and b=truea && b = truea & b = true======================2) a=true and b=falsea && b = falsea & b = false======================3) a=false and b=falsea && b = falsea & b = false======================4) a=false and b=truea && b = falsea & b = false======================

Therefore YES we can replace && by & for boolean values ;-)

So better use &= instead of &&=.

Same for ||=

Same reasons as for &&=:
operator |= is less error-prone than ||=.

If a developer wants f2() not to be called when f1() returns true, then I advice the following alternatives:

// here a comment is required to explain that // f2() is not called when f1() returns false, and so on...bool isOk = f1() || f2() || f3() || f4();

or:

// here the following comments are not required // (the code is enough understandable)bool isOk = false;if (!isOK) isOk = f1();if (!isOK) isOk = f2(); //f2() is not called when f1() returns falseif (!isOK) isOk = f3(); //f3() is not called when f1() or f2() return falseif (!isOK) isOk = f4(); //f4() is not called when ...

Probably because something like

x = false;x &&= someComplexExpression();

looks like it ought to be assigning to x and evaluating someComplexExpression(), but the fact that the evaluation hinges on the value of x isn't apparent from the syntax.

Also because Java's syntax is based on C, and no one saw a pressing need to add those operators. You'd probably be better off with an if statement, anyway.

It is this way in Java, because it is this way in C.

Now the question why it is so in C is because when & and && became different operators (sometime preceding C's descent from B), the &= variety of operators was simply overlooked.

But the second part of my answer does not have any sources to back it up.