Причина
Операторы &&= и ||= недоступны на Java , поскольку для большинства разработчиков эти операторы:
- подверженные ошибки
- 1012 * бесполезен *
Пример для &&=
Если в Java разрешен оператор &&=, то этот код:
bool isOk = true; //becomes false when at least a function returns false
isOK &&= f1();
isOK &&= f2(); //we may expect f2() is called whatever the f1() returned value
будет эквивалентно:
bool isOk = true;
if (isOK) isOk = f1();
if (isOK) isOk = f2(); //f2() is called only when f1() returns true
Этот первый код подвержен ошибкам , потому что многие разработчики подумают, что f2() всегда вызывается независимо от возвращаемого значения f1 (). Это как bool isOk = f1() && f2();, где f2() вызывается только тогда, когда f1() возвращает true.
Если разработчик хочет, чтобы f2() вызывался только тогда, когда f1() возвращает true, следовательно, второй код выше менее подвержен ошибкам.
Остальное &= достаточно, потому что разработчик хочет, чтобы f2() всегда вызывался:
Тот же пример, но для &=
bool isOk = true;
isOK &= f1();
isOK &= f2(); //f2() always called whatever the f1() returned value
Кроме того, JVM должна выполнить приведенный выше код как следующий:
bool isOk = true;
if (!f1()) isOk = false;
if (!f2()) isOk = false; //f2() always called
Сравнить && и & Результаты
Являются ли результаты операторов && и & одинаковыми при применении к логическим значениям?
Давайте проверим, используя следующий код Java:
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;
}
Выход:
1) a=true and b=true
a && b = true
a & b = true
======================
2) a=true and b=false
a && b = false
a & b = false
======================
3) a=false and b=false
a && b = false
a & b = false
======================
4) a=false and b=true
a && b = false
a & b = false
======================
Поэтому ДА мы можем заменить && на & для логических значений ;-)
Так что лучше используйте &= вместо &&=.
То же самое для ||=
Те же причины, что и для &&=:
оператор |= менее подвержен ошибкам, чем ||=.
Если разработчик хочет, чтобы f2() не вызывался, когда f1() возвращает true, тогда я советую следующие альтернативы:
// 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();
или
// 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 false
if (!isOK) isOk = f3(); //f3() is not called when f1() or f2() return false
if (!isOK) isOk = f4(); //f4() is not called when ...