Ветвления и циклы

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

Цикл — это разновидность управляющей конструкции, предназначенная для организации многократного исполнения набора инструкций.

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

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

Большинство операторов сравнения применимы к числовым значениям. Всё это бинарные операторы, имеющие два числовых аргумента, но возвращающие логическое значение.

  • > оператор «больше»
  • >= оператор «больше или равно»
  • < оператор «меньше»
  • <= оператор «меньше или равно»
  • != оператор «не равно»
  • == оператор эквивалентности (равенства)

Последние два оператора сравнения применяются не только для числовых значений, но для логических. Сравнение двух текстовых операторов выполняется с использованием методов equals(String object), equalsIgnoreCase(String object).

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

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

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

ОператорНазначение
!символ отрицания, унарный оператор, меняет значение на противоположное (инвертирует: ложь превращает в истину, а истину — в ложь)
&&символ логического «и» («конъюнкция»), бинарная операция, возвращает истинное значение тогда и только тогда, когда оба операнда истины
||символ логического «или» («дизъюнкция»), бинарная операция, возвращает истинное значение, когда хотя бы один из операндов истинный

У логических операторов следующий приоритет: отрицание, конъюнкция, дизъюнкция.

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

Примеры использования логических операторов

boolean a = true;
boolean b;
boolean c;

b = a || true;  // b истинно
b = !b;         // b ложно

System.out.println(b); // вывод в консоль значения false

a = a || b;     // a истинно

c = a && (a || b); // с истинно

System.out.println(c); // вывод в консоль значения true


boolean m;
boolean w;

m = 5 >= 4;          // истина
m = 5 != 5 || false; // ложь
w = m == false;      // истина

System.out.println(w);// вывод в консоль значения true

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

Синтаксис оператора ветвления if else

if (условие){
    ... // составной оператор №1
} else { 
    ... // составной оператор №2 
}

Если составной оператор в основной или альтернативной ветви оператора управления содержит только один простой оператор, то фигурные скобки можно опустить. В таком случае синтаксис оператора ветвления примет вид :

if (условие) 
    ... // простой оператор №1; 
else 
    ... простой оператор №2; 

Основное предназначение оператора ветвления – это реализация разветвляющихся алгоритмов. Например, фрагмент программы, для вычисления функции: Y(x) = x*x, при x < 0 и Y(x) = 2*x, при x >= 0

int x, y; 
// Чтение значений x, y из консоли
Scanner in = new Scanner(System.in);
System.out.println("Enter x :");
x = in.nextLine();
System.out.println("Enter y :");
y = in.nextLine();

if (x < 0) 
    y = x*x; 
else 
    y = 2*x;
System.out.printf ("Результат: %i\n", y); 

При построении программ с несколькими подряд идущими операторами ветвления необходимо учитывать следующее правило: оператор else относится к последнему оператору if. Например, рассмотрим фрагмент программы:

if (x > 10.0)
    y = 2*x + 5; 
if (y < z)
    y = fabs(x);
else 
    y = 2.5*x; 

Если необходимо нарушить этот порядок (т.е. ветвь else отнести к первому оператору if), то необходимо второй оператор if включить в составной оператор прямой ветви первого оператора if:

if (x > 10.0) {
    y = 2*x + 5; 
    if(y < z) 
        y = fabs(x);
} else 
    y = 2.5*x; 

В программировании часто встречается необходимость создания каскадных операторов ветвления. Синтаксис такой структуры имеет вид :

if (условие № 1) {
    составной оператор № 1 
} else if (условие № 2) {
    составной оператор № 2 
} ... {
} else if (условие № N) {
    составной оператор № N 
} else { 
    составной оператор № N+1 
}

Многовариантное ветвление, оператор switch

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

switch ( choice ) { 
    case значение1:
         break;
    case значение2:
         break;
    case значением:
         break;
    default:
}

Выполнение кода начинается с метки case, соответствующей значению выражения choice, и продолжается до следующего оператора break или конца оператора switch. Если ни одна метка не совпадает со значением переменной, выполняется раздел default, если он предусмотрен.

Заметим, что метка case должна быть целочисленной. Нельзя проверять строки. Все значения case должны быть уникальными литералами. Если в двух операторах case будут одинаковые значения, то транслятор выдаст сообщение об ошибке.

Отметим, что оператор default необязателен. В случае, когда ни один из операторов case не соответствует значению выражения и в switch отсутствует оператор default выполнение программы продолжается с оператора, следующего за оператором switch.

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

Циклы java

В java существует два типа циклов:

  • цикл типа «пока» - while и do…while
  • типа «n-раз» - for (инициализация; условие; итерация)

Первый тип «пока» предназначен для повторения какого-то действия до тех пор, пока выполняется некоторое условие. Пример: увеличивать значение переменной на 3 до тех пор, пока оно не станет трёхзначным.

Второй тип «n-раз» предназначен для повторения каких-то действий заранее известное количество раз. Пример: найти факториал числа 6.

Циклы while и do…while

Оператор while повторяет указанные действия до тех пор, пока его выражение имеет истинное значение.

Синтаксис цикла while

while (логическое выражение) {
  ... // тело цикла
}

Пример вывода в консоль значений массива :

String[]  lst = {"Зима", "Лето", "Осень", "Весна"};
int i = 0;
while(i++ < lst.length){
    System.out.print(lst[i] + " ");
}

Условие необходимости повторения цикла проверяется перед каждым шагом цикла, в том числе перед самым первым.

Java предлагает также возможность использования цикла с постпроверкой условия. Для его записи используется конструкция из операторов do…while.

do {
  ... // тело цикла
} while (логическое выражение)

Следующий цикл будет выполнен 4 раза, и в консоль будет выведено «1 2 3 4 »:

int i = 0;
do {
    i++;
    System.out.print(Integer.valueOf(i) + " ");
} while(5 > i);

Тело цикла do…while выполняется по крайней мере один раз. Этот оператор удобно использовать, когда некоторое действие в программе нужно выполнить по крайней мере единожды, но при некоторых условиях придётся повторять его многократно.

Цикл for

Оператор for содержит три параметра : параметр инициализации, параметр повторения, параметр итерации.

Синтаксис цикла for

for (инициализация; условие; итерация) {

    // тело цикла, т. е. повторяемые циклично действия 
}

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

Представленная программа выводит в консоль значения массива :

String[]  lst = {"Зима", "Лето", "Осень", "Весна"};
// в прямом порядке
for (int i = 0; i < lst.length; i++) {
     System.out.print(lsti] + " ");
}

// в обратном порядке
for (int i = (lst.length - 1); i >= 0; i--) {
     System.out.print(lsti] + " ");
}

В одном цикле можно задавать сразу несколько счётчиков. Для этого необходимо несколько выражений в итерации и в инициализации разделять запятыми. Условие повторения можно задавать только одно, но оно может быть выражением, содержащим сразу несколько счётчиков.

Представленный код выведет в консоль такую последовательность «0 -1 -4 -9 -16 -25»

for(int a = 0, b = 0; a - b <= 10; a++, b--){
    System.out.print(" " + a*b);
}

Прерывание цикла, break

Для досрочного прерывания цикла необходимо использовать оператор break. При этом происходит моментальный выход из цикла; текущий шаг не будет завершен. Т.е. если после break присутствовали какие-то ещё операторы, то они не выполнятся.

Примеры прерывания циклов :

// Прерывание цикла for
for (int a = 1; a <= 10; a++){
    if (a == 5)
        break;
    System.out.println("a = " + a);
}
// Прерывание цикла while
int s = 100;
while(true) {
    System.out.print(s +" ");
    s = s / 2;
    if (s == 0)
        break;
    System.out.println("s = " + s);
}

Прерывание цикла, continue

Для прерывания цикла можно использовать оператор continue. В отличие от оператора break, который прерывает цикл, оператор continue прерывает только текущий шаг цикла и передает управление в начало цикла.

// Прерывание цикла while
int s = 100;
while(true) {
    System.out.print(s +" ");
    s = s / 2;
    if (s == 25)
        coninue;
    else if (s == 0) {
        break;
    } else
        System.out.println("s = " + s);
}

В примере при значении s равном 25 очередной итерация цикла будет прервана и управление будет передано в начало цикла.

Если оператор continue используется в цикле for, то он передаст управление оператору увеличения счетчика цикла.

Наверх
  Рейтинг@Mail.ru