Операторы if, else, swich, case

Ключевое слово if выполняет условную проверку, оценивая логическое значение  выражения. Оператор, следующий за этим выражением, будет выполняться, только если данное значение равно true (истина). В противном случае программа переходит на последующие строки кода, выполняя альтернативное ветвление.
Синтаксис оператора  if выглядит следующим образом:

 if ( проверочное-выражение ) код-для-исполнения-если-результат-истина ;

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

Логический оператор И (&&) будет возвращать true, только если оба проверяемых выражения имеют значение true:

if ( ( условие-1 ) && ( условие-2 ) ) исполнить-этот-код ; 

Логический оператор ИЛИ (||) будет возвращать значение true, если хотя бы одно из проверочных выражений имеет значение true:

if ( (условие-1 ) || ( условие-2) ) исполнить-этот-код ;

Комбинации вышеуказанных выражений могут составлять более сложные и длинные проверочные выражения. 
В дополнение к ключевому слову if можно использовать ключевое слово else, которое вместе с if образует оператор if else, обеспечивающий альтернативные ветви для продолжения программы в соответствии с результатом оценки проверочного выражения. В простейшем случае он просто предлагает альтернативный оператор для исполнения, а когда проверка не успешна — выдает значение false:

if (проверочное-выражение) 
     код-для-исполнения-если-результат-истина; 
else 
     код-для-исполнения-если-результат-ложь ; 

Каждая альтернативная ветвь может являться либо отдельным оператором, либо блоком операторов, заключенным внутри фигурных скобок . При помощи оператора if else можно строить более сложные конструкции для осуществления дополнительных проверок внутри каждой из ветвей if и else. При этом получаются вложенные операторы if. Когда программа обнаруживает выражение, оцененное как true, она исполняет операторы, связанные с этой ветвью, а затем выходит из оператора if else.

if(a<b)
  a=a+1;
else if(a==b)
      a=a+1;
    else{
      a=a+1;
      b=b+1;
    }

Неприятной проблемой, унаследованной в Java от языка C, является возможность использования оператора присваивания "=" вместо оператора сравнения "==". 

Например, если мы используем булевские переменные b1 и b2, и вместо



if(b1==b2)
  i=1;
else
  i=2;




напишем



if(b1=b2)
  i=1;
else
  i=2;




никакой диагностики ошибки выдано не будет. 

Дело в том, что по правилам C Java любое присваивание рассматривается как функция, возвращающая в качестве результата присваиваемое значение. Поэтому присваивание b1=b2 возвратит значение, хранящееся в переменной b2. В результате оператор будет работать, но совсем не так, как ожидалось. Более того, будет испорчено значение, хранящееся в переменной b1.



Оператор выбора switch

Является аналогом if для нескольких условий выбора. Синтаксис оператора следующий:



switch(выражение){
  case значение1: операторы1;
  ……………………………
  case значениеN: операторы N;
  default: операторы;
}




Правда, крайне неудобно, что нельзя ни указывать диапазон значений, ни перечислять через запятую значения, которым соответствуют одинаковые операторы.



Тип выражения должен быть каким-нибудь из целых типов. В частности, недопустимы вещественные типы.



Работает оператор следующим образом: сначала вычисляется выражение. Затем вычисленное значение сравнивается со значениями вариантов, которые должны быть определены еще на этапе компиляции программы. Если найден вариант, которому удовлетворяет значение выражения, выполняется соответствующий этому варианту последовательность операторов, после чего НЕ ПРОИСХОДИТ выхода из оператора case, что было бы естественно. - Для такого выхода надо поставить оператор break.Эта неприятная особенность Java унаследована от языка C.



Часть с default является необязательной и выполняется, если ни один вариант не найден.



Пример:



switch(i/j){
    case 1:
        i=0;
        break;
    case 2:
        i=2;
        break;
    case 10:
        i=3;
        j=j/10;
        break;
    default:
        i=4;
};




У оператора switch имеется две особенности:



Можно писать произвольное число операторов для каждого варианта case, что весьма удобно, но полностью выпадает из логики операторов языка Java.
Выход из выполнения последовательности операторов осуществляется с помощью оператора break. Если он отсутствует, происходит "проваливание" в блок операторов, соответствующих следующему варианту за тем, с которым совпало значение выражения. При этом никакой проверки соответствия очередному значению не производится. И так продолжается до тех пор, пока не встретится оператор break или не кончатся все операторы в вариантах выбора. Такие правила проверки порождают типичную ошибку, называемую "забытый break ".



Условное выражение …?... : …

Эта не очень удачная по синтаксису функция унаследована из языка C. Ее синтаксис таков:



условие?значение1:значение2




В случае, когда условие имеет значение true, функция возвращает значение1, в противном случае возвращается значение2.



Например, мы хотим присвоить переменной j значение, равное i+1 при i<5, и i+2 в других случаях. Это можно сделать таким образом:



j=i<5?i+1:i+2



Иногда при вычислении громоздких выражений этот оператор приходится использовать: без него программа оказывается еще менее прозрачной, чем с ним. Приоритет разделителей "?" и ":" очень низкий – ниже только приоритет оператора присваивания (в любых его формах). Поэтому можно писать выражения без использования скобок. Но лучше все-таки использовать скобки:



j=(i<5)?(i+1):(i+2)

Операторы Java

Арифметические операции

Используются для создания в Java-программах выражений, которые возвращают одно результирующее значение.

Операторы присваивания

Используются, чтобы занести результат выражения в переменную. Все из них, за исключением оператора =, являются сокращенной формой от более длинного эквивалентного выражения.

Операторы сравнения

Используются для оценки двух значений в выражении и возвращают логическое значение  true или false, описывающее результат этого сравнения.

Оператор равенства == оценивает два операнда и возвращает true, если значения операндов равны. Если операнды являются одними и теми же числами, то они равны; если они являются строками, содержащими одни и те же символы  в одном и том же порядке, то они тоже равны.

Операнды логического типа равны, если оба содержат true или оба содержат false.

Оператор неравенства != наоборот, возвращает true, если значения операндов не равны, используя те же правила, что и оператор равенства. Операторы равенства и неравенства часто применяются для выполнения так называемого условного ветвления  в программе, когда в зависимости от условия выбирается дальнейшее направление работы программы.

Оператор «больше» (>) сравнивает два операнда и возвращает true, если значение первого больше, чем значение второго.

Оператор «меньше» (<) делает то же самое сравнение, но возвращает true в случае, если значение первого операнда меньше.

Операторы «больше либо равно» и «меньше либо равно» возвращают также значение true, если значения обоих операндов равны.

Логические операторы

Используются чтобы объединить несколько выражений, каждое из которых возвращает логическое значение, в одно сложное выражение, которое будет возвращать единственное логическое значение.

Логические операторы работают с операндами, имеющими значение логического (булевого)  типа, то есть true или false, либо со значениями, которые преобразуются в true или false. Оператор «логическое И» (&&) оценивает два операнда и возвращает значение true, только если оба операнда сами имеют значение true, в противном случае оператор возвращает значение false. Этот оператор обычно используется при условном ветвлении, когда направление работы программы определяется проверкой двух условий: если оба они верны, программа идет в определенном направлении, в противном случае — в другом. В отличие от оператора and, которому необходимо, чтобы оба операнда имели значение true, оператор «логическое ИЛИ» (||) оценивает два операнда и возвращает true, если хотя бы один из них сам возвращает значение true. В противном случае оператор || возвратит значение false. Это полезно использовать при программировании определенных действий в случае выполнения одного из двух проверяемых условий. Оператор «логическое НЕ» (!) является унарным  и используется с одним операндом. Он возвращает противоположное значение от того, какое имел операнд. Так, если переменная a имела значение true, то !a возвратит значение false. Он может использоваться, например, для переключения значения переменной в последовательных итерациях цикла при помощи выражения a=!a. Это значит, что на каждой итерации цикла логическое значение меняется на противоположное, подобно выключению и включению лампочки.

Условный оператор

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

Условный оператор вначале оценивает выражение на предмет значений true или false, а затем возвращает один из двух своих операндов в зависимости от результатов оценки. 

Его синтаксис выглядит следующим образом:

( логическое-выражение ) ? если-истина-возвращаем-это : если-ложь-возвращаем-это; 

Каждый из указанных операндов является альтернативной веткой исполнения программы в зависимости от логической величины, возвращаемой проверочным выражением. Например, в качестве вариантов могут возвращаться строковые значения:

status = ( quit == true ) ? "Готово!" : "В процессе..." ;

В данном случае, когда переменная quit содержит значение true, условный оператор присваивает значение своего первого операнда (Готово!) переменной status, а в противном случае оператор присваивает ей значение второго операнда (В процессе...). Когда проверяется простая логическая величина, то доступна краткая запись проверочного выражения, в этом случае можно опустить символы == true. Таким образом, вышеприведенный пример может быть записан в виде:

 status = ( quit ) ? " Готово!" : " В процессе..." ;

Условный оператор может возвращать значение любого типа данных и использовать любое действительное проверочное выражение. Например, для оценки двух числовых значений может использоваться оператор сравнения > и возвращаться логическое значение в зависимости от результата:

 busted = ( speed > speedLimit ) ? true : false ;

 Аналогично в проверочном выражении может использоваться оператор неравенства != для оценки строковой величины и возвращать, например, числовое значение в зависимости от результата:

bodyTemperature = ( scale != "Celsius" ) ? 98.6 : 37.0 ;

Приоритет операций

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

Операторы, имеющие одинаковый приоритет, обрабатываются в порядке их появления в выражении — слева направо.

Управляющие литералы 

Литералы обычно отделяются от ключевых слов Java-языка, но там, где требуются двойные или одинарные кавычки внутри строковой переменной, необходимо указать, что символ кавычек должен как-то отделяться, чтобы избежать аварийного завершения строки. Это достигается путем добавления перед каждым символом кавычек управляющей последовательности (или управляющего оператора) \.
Например, чтобы включить кавычки в строковую переменную, пишем следующее:

String quote = " \"Удача благоволит храбрым.\" сказал Вергилий ";

Для форматирования простейшего вывода можно использовать различные управляющие последовательности:

Управляющая последовательность для новой строки (\n) часто применяется для вывода нескольких строк. Аналогично, управляющая последовательность табуляции (\t) используется для вывода содержимого в столбцах. Использование комбинаций новой строки и табуляции позволяет форматировать вывод как в строках, так и в столбцах — в виде некоторой таблицы.

Операторы для работы с бинарными значениями 

Используются, в отличие от обычных операторов, гораздо реже. «Побитовые» операторы в языке Java можно использовать с данными целочисленного типа для того, чтобы манипулировать битами  двоичного значения. Для этого нужно понимать, как десятичные числа от 0 до 255 представляются в виде 8 бит. 

Например, десятичное число 53 представляется двоичным 

00110101 ( 0×128,0×64,1×32,1×16,0×8,1×4,0×2,1×1 ). 

Операции двоичного сложения выполняются подобно арифметическим операциям над десятичными числами.   

   53 = 00110101  

+  7 = 00000111   

   60 = 00111100

 Кроме того, побитовые операторы предлагают специальные операции над двоичными числами.

Заключение 

• Арифметические операторы можно использовать для формирования выражений с двумя операндами для сложения (+), вычитания (-), умножения (*), деления (/) и деления по модулю (%).
• Операторы инкремента (++) и декремента (--) изменяют единственный операнд на единицу.
• Оператор присваивания (=) можно комбинировать с арифметическими операторами, чтобы выполнять арифметические вычисления, а затем присваивать результат.
• Операторы сравнения можно использовать для формирования выражений, оценивающих два операнда на равенство (==), неравенство (!=), больше (>) или меньше (<).
• Оператор присваивания может быть скомбинирован с операторами > и <, и он будет возвращать значение true при равенстве операндов.
• Логические операторы И (&&) и ИЛИ (||) формируют выражения, оценивающие два операнда и возвращающие логические значения true или false.
• Логический оператор ! возвращает обратную логическую величину от значения единственного операнда.
• Условный оператор ? : оценивает заданное логическое выражение и возвращает один из двух операндов в зависимости от результата.
• При оценке логических выражений на предмет истинности можно опускать знак == true.
• В сложных арифметических выражениях важно явно указывать порядок операторов с помощью добавления скобок.
• Во избежание синтаксических ошибок кавычки в строковых переменных нужно предварять управляющим оператором \.
• Управляющие последовательности \n (новая строка) и \t (табуляция) организуют простое форматирование вывода.
• В особых ситуациях для выполнения двоичных арифметических операций полезно использовать побитовые операторы.