(a && b) has the same value as (a & b), but with && the expression b is not executed if a is false. In Java there is also an operator &=.
a &= b is the same as a = a & b.
Question: Why isn't there an operator &&=, at least in Java. Is there some reason why I would not make sense to have it, or is it simply that no one cares or needs it?
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.
&& is a logical operator, & is a bitwise operator. They do two different things. Assigning the results of the former to the left side of the operation makes sense less often than for bitwise operations.
It is allowed in Ruby.
If I were to guess, I would say that it is not frequently used so it wasn't implemented. Another explanation could be that the parser only looks at the character before the =
a&b and a && b are not the same thing.
a && b is a boolean expression that returns a boolean, and a & b is a bitwise expression that returns an int (if a and b are ints).
whare do you think they are the same?
I cannot think of any better reason then 'It looks incredible ugly!'
If I understand the logic of
a = a && b
b only gets evaluated if a is true. So...
a &&= b
If a were already false nothing would happen? b would never be evaluated right?
Maybe it's just clearer to write
if (a)
a = b;
'&' and '&&' are not the same as '&&' is a short cut operation which will not do if the first operand is false while '&' will do it anyway (works with both number and boolean).
I do agree that it make more sense to exist but it is not that bad if it is not there. I guess it was not there because C does not have it.
Really can't think of why.
One of Java's original aims was to be "Simple, Object Oriented, and Familiar." As applied to this case, &= is familiar (C, C++ have it and familiar in this context meant familiar to someone who knows those two).
&&= would not be familiar, and it would not be simple, in the sense that the language designers were not looking to think of every operator they could add to the language, so less extra operators are simpler.