Когда целесообразно использовать побитовый оператор в условном выражении?

Во-первых, немного предыстории: я учитель-информатик, и я пытаюсь представить булевы операторы Java в своем классе 10-го класса. Мой учитель-наставник просмотрел рабочий лист, который я подготовил, и прокомментировал, что я могу позволить им использовать только один & или | обозначать операторов, потому что они «делают то же самое».

Я осознаю разницу между & и &&.
& является побитовым оператором, предназначенным для использования между целыми числами, для выполнения "сдвоенного бита".
&& - это условный оператор, предназначенный для использования между логическими значениями.

Чтобы доказать, что эти операторы не всегда «делают одно и то же», я решил найти пример, где использование побитового значения между логическими значениями приведет к ошибке. Я нашел этот пример

boolean bitwise;
boolean conditional;
int i=10, j=12;
bitwise = (i<j) | ((i=3) > 5); // value of i after oper: 3
System.out.println(bitwise+ " "+ i);
i=10; 
conditional = (i<j) || (i=3) > 5 ;  // value of i after oper: 10
System.out.println(conditional+ " "+ i);
i=10; 
bitwise = (i>j) & (i=3) > 5;   // value of i after oper: 3
System.out.println(bitwise+ " "+ i);
i=10; 
conditional = (i>j) && (i=3) > 5;  // value of i after oper: 10
System.out.println(conditional+ " "+ i);

Этот пример показывает, что, если значение должно быть изменено второй половиной выражения, это приведет к разнице между результатами, поскольку побитовый оператор является нетерпеливым, а условное поведение ведет себя как короткое замыкание (не оценивает вторую половина, если первая половина ложна в случае && и истина в случае ||).

У меня есть проблема с этим примером. Почему вы хотите изменить значение в то же время, когда вы сравниваете его? Это не похоже на надежный способ кодирования. Я всегда был против выполнения нескольких операций в одной строке моего производственного кода. Похоже, что «ковбой-программист», не имеющий совести в отношении возможности сопровождения своего кода, подойдет. Я знаю, что в некоторых областях код должен быть максимально компактным, но, конечно, это плохая практика в целом?

Я могу объяснить свой выбор поощрения использования && и || над & и | потому что это общепринятая кодировка в программной инженерии .

Но может ли кто-нибудь дать мне лучший, даже реальный, пример использования побитового оператора в условном выражении?

это уместно, когда вы выполняете операцию маскировки

if ((a & b)> 0) {...}

где а и b - целые числа

|| и | и && и & не являются взаимозаменяемыми

| и & amost никогда не появятся в условном выражении сами по себе (смысл ссылки, которую вы включили, состоит в том, что такие вещи чаще всего являются ошибками)

РЕДАКТИРОВАТЬ: не спорьте с вашим наставником; даже если вы выиграете, вы проиграете. Вместо этого объясните, что вы не хотите путать студентов, смешивая логические операторы и побитовые операторы в одном и том же уроке. Вы можете объяснить, что если i = 3 и j = 2, то i & j = 2, а i && j - ошибка. Однако более простое объяснение состоит в том, что вы учите логические (логические) операторы, поэтому добавление побитовых эквивалентов в особом случае является отвлечением от основной темы урока. Нет необходимости делать наставника «неправильным» и не нужно приводить контрпримеры. Основное внимание в уроке уделяется логическим операторам, а не побитовым операторам.

Как следствие, когда вы начинаете обучать побитовые операторы, нет необходимости показывать особые случаи, когда + и - дают те же результаты, что и & и |

Небитовые операторы &&и ||являются операторами короткого замыкания. Другими словами, &&если LHS ложно, RHS никогда не будет оцениваться; с, ||если LHS истинно, тогда RHS никогда не будет оцениваться. С другой стороны, побитовые операторы &и не |являются короткозамкнутыми, и всегда будут оценивать как LHS, так и RHS. В противном случае они эквивалентны в ifутверждении.

Единственный раз, когда я вижу ценность в использовании операторов без короткого замыкания, это если RHS имеет какой-то желательный побочный эффект, который вы хотите, чтобы он происходил во всех случаях. Я не могу вспомнить конкретный пример, где вы хотели бы этого, и я не верю, что это хорошая практика, но это разница.

Общий философский ответ заключается в том, что использование побитовых операторов для логических операторов нетипично и затрудняет чтение кода. На практике (для кода, который находится в производстве), более читаемый код легче поддерживать и, следовательно, более желателен.

Для реального использования потребности в операторах короткого замыкания, смотрите случаи, такие как:

if (args.length > 0 && args[0] == 'test') ....

if (b != NULL && b.some_function()) ...

if (b == NULL || b.some_function()) ...

Эти типы операций часто появляются в реальном коде.

Вы будете использовать побитовые операторы, если сравниваете перечисления битовой маски. Например, у вас есть перечисление состояний и объект, который может находиться в нескольких состояниях. В этом случае вы будете делать побитовые или назначать более одного состояния для вашего объекта.

например, state = CONNECTED | IN_PROGRESSгде CONNECTED could be 0x00000001иIN_PROGRESS 0x00000010

Для получения дополнительной информации посмотрите документацию перечисления флагов.

более простой пример неправильности:

int condA=1, condB=2;

if (condA!=0 && condB!=0) {
    // correct!
}
if ((condA & condB)!=0) {
    // never executed
}

здесь у вас есть два условия, оба ненулевые; но побитовое &приводит к нулю.