Основные операторы Java

      Комментарии к записи Основные операторы Java отключены

Главная Форумы Программирование Учебник по Java Основные операторы Java

Помечено: , ,

В этой теме 0 ответов, 1 участник, последнее обновление  Васильев Владимир Сергеевич 1 месяц, 4 нед. назад.

  • Автор
    Сообщения
  • #3515

    В этой заметке мы рассмотрим основные конструкции языка Java — ветвления, циклы, исключения и т.п.

    Условная операция

    Java включает специальную троичную условную операцию:

    expression1 ? expression2 : expression3

    expression1 может быть любым выражением, которое производит boolean-значение. Если оно true, то вычисляется expression2, иначе вычисляется expression3.

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

    Java поддерживает два оператора выбора: if и switch.
    Оператор if имеет следующую общую форму:

    if (condition) statement1;
    else statement2;

    где statementN – одиночный или составной (включенный в фигурные скобки, т.е. в блок) оператор маршрута N (N – номер маршрута, для if он равен 1 или 2); condition – любое выражение, которое возвращает значение типа boolean. Предложение else – необязательное.
    Оператор if работает так: если condition имеет значение true, то выполняется statement1, иначе – выполняется statement2 (если он присутствует). Оба оператора вместе не будут выполняться ни в коем случае.
    Пример:

            int x, s ;        
            x = 5 ;
            if  (x > 10)  s  =  x + 10 ; 
            else s = 0 ;

    Результат: Значение s = 0

    Общую программную конструкцию, которая основана на последовательно­сти вложенных if, называют многозвенным (ladder) if-else-if. Эта конструкция выглядит так:

    if  (condition1)
    statement1; 
    else  if  (condition2)
    statement2; 
    else if  (condition3)
    statement3;
    // ...
    // ...
    // ...
    else
    statementN;

    Операторы if выполняются сверху вниз. Как только одно из условий, управляющих оператором if, становится true, оператор, связанный с этим if, выполняется, а остальная часть многозвенной схемы пропускается. Если ни одно из условий не true, то будет выполнен последний оператор else. Заключительный else действует как условие по умолчанию: если все другие условные проверки не успешны, то выполняется последний оператор else. Если последний else отсутствует и все другие условия – false, то никакого действия выполняться не будет.

    Оператор switch

    Оператор switch – это Java-оператор множественного ветвления. Он переключает выполнение на различные части кода программы, основываясь на значении выражения, и часто обеспечивает лучшую альтернативу, чем длинный ряд операторов if-eise-if.
    Switch отличается от if тем, что может проверять только равенство (своей переменной с case-метками), тогда как if может оценивать любой тип булевского выражения. То есть, switch отыскивает только соответст­вие между значением выражения и одной из его case-меток.
    Общая форма оператора switch:

    switch (expression) {
        case value1:
        // последовательность операторов1
        break;
        case value2:
        // последовательность операторов2
        break;
    // ...
    // ...
    // ...
        case valueN:
        // последовательность операторовN
        break;
    default:
       // последовательность операторов по умолчанию
    } 

    Здесь expression должно иметь тип byte, short, int ИЛИ char; каждое value, указанное в операторах case, должно иметь тип, совместимый с типом выражения. Каждое значение case должно быть уникальной константой (а не переменной). Дублирование значений case недопустимо.
    Оператор switch работает следующим образом. Значение выражения срав­нивается с каждым из указанных значений в case-операторах. Если соответ­ствие найдено, то выполняется кодовая последовательность, следующая по­сле этого оператора case. Если ни одна из case-констант не соответствует значению выражения, то выполняется оператор default. Однако оператор default необязателен. Если согласующихся case нет, и default не присутст­вует, то никаких дальнейших действий не выполняется.
    Оператор break используется внутри switch, чтобы закончить последова­тельность операторов. Когда встречается оператор break, выполнение пере­дается к первой строке кода, которая следует за полным оператором switch. Он создает эффект досрочного выхода из switch.

    Результат работы программы:

    Нетрудно заметить, что на каждом проходе цикла выполняются операторы, связанные с case-меткой, которая соответствует переменной цикла i. Все другие case-ветви обходятся. После того как i становится больше трех, ни­какого соответствия case-меткам не возникает, поэтому выполняется опера­тор default.
    Оператор break – необязательный. Если он пропускается, выполнение бу­дет продолжено со следующей case-метки. Иногда желательно иметь мно­жественные case-ветви без операторов break между ними. Например, рас­смотрим следующую программу:

    Программа 5 раз выдаст сообщение "i меньше 5", затем, 5 раз "i меньше 10" и 2 раза "i равно 10 или больше"

    Операторы цикла

    Операторы цикла (итераций) Java – это while, do while и for.
    Цикл while повторяет оператор или блок операторов, пока его управляющее выражение имеет значение true.

    While (condition) {
      // тело цикла
    }

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

    Цикл do while всегда выполняет свое тело по крайней мере один раз, потому что его условное выражение размещается в конце цикла. В цикле do while проверяется условие продолжения, а не окончания цикла.

    do {
      // тело цикла
    } while (condition);

    Главное отличие между while и do while в том, что инструкция в цикле do while всегда выполняется не менее одного раза, даже если вычисленное выражение ложное с самого начала. В цикле while, если условие ложное в первый раз, инструкция никогда не выполнится. На практике do while используется реже, чем while.

    Цикл for наиболее удобен в тех случаях, когда тело цикла должно быть выполнено определенное количество раз. Общая форма оператора for:

    for (initialization; condition; iteration) {
      // тело цикла
    }

    Цикл for работает следующим образом.
    В начале работы цикла выполняется выражение initialization. В общем случае это выражение устанавливает значение переменной управления циклом, которая действует как счетчик. Важно понять, что выражение инициализации выполняется только один раз.
    Затем оценивается condition. Оно должно быть булевским выражением и обычно сравнивает переменную управления циклом с некоторым граничным значением. Если это выражение – true, то отрабатывают операторы из тела цикла, если – false, цикл заканчивается.
    Далее выполняется часть цикла iteration. Обычно это выражение, которое осуществляет инкрементные или декрементные операции с переменной управления циклом.
    Затем цикл реализует итерации. В каждом проходе цикла – сначала оценивается условное выражение, потом выполняется тело цикла и затем – выражение iteration. Этот процесс повторяется до тех пор, пока управляющее выражение не станет false.
    Вот, например, как можно запрограммировать печать целых чисел от 0 до 4:

    for (int i=0; i < 5; i++) {
    	System.out.println(i);
    }

    Часто переменная, которая управляет циклом for, необходима только для целей цикла и не используется в другом месте. Когда дело обстоит так, можно объявить переменную внутри инициализационной части for (как в примере выше). Важно помнить, что область действии переменной заканчивается там же, где и цикл for.
    Чтобы позволить двум или большему числу переменных управлять циклом for, Java разрешает включать множественные операторы как в инициализационную, так и в итерационную части for-заголовка. Каждый оператор отделяется от следующего запятой. Вы можете определить несколько переменных внутри инструкции for, но они должны быть одного типа:

    for(int i = 0, j = 1; i < 10 && j != 11; i++, j++)    {
      /* тело цикла for */;
    }

    Пример вычисления факториала числа:

    int fact = 1, x = 5;
    for (int i=1; i <= x; i++) {
      fact = fact*i;
    }
    System.out.println("fact = " + fact);

    Результат вычислений:

    Операторы перехода

    Оператор break в Java используется в трех случаях. Во-первых, он заканчивает последовательность операторов в ветвях оператора switch. Во-вторых, его можно использовать для выхода из цикла. В-третьих, он может применяться как «цивилизованная» форма оператора безусловного перехода goto. В этом разделе объясняются два последних случая.
    В следующем примере оператор break можно использовать для выхода из цикла while, который иначе выполнялся бы до бесконечности:

    int i=0;
    while(true) {
    	System.out.println(i);
    	i++;
    	if (i > 10) break;
    }

    Иногда полезно начать очередную итерацию цикла пораньше. То есть нужно продолжить выполнение цикла, но прекратить обработку остатка кода в его теле для данной частной итерации. На самом деле это – goto-переход мимо следующих операций тела в конец блока цикла. Такое действие выполняет оператор continue. В циклах while и do while оператор continue вызывает передачу управления непосредственно условному выражению, которое управляет циклом. В цикле for управление переходит сначала к итерационной части оператора for и затем к условному выражению.
    В следующем примере оператор continue предотвращает ошибку деления на ноль:

    for( int i = -10; i < 10; i++) {
    	if (i == 0) continue;
    	System.out.println(1/i);
    	// сюда передается управление
    }

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

    class power {
    	public int toN(int base, int n) {
    		int result=base;
    		for(int i=0; i < n - 1; i++) {
    			result = result * base;
    		}
    		return result;
    		// код после оператора return никогда не получит управления
    	}
    }

    Эта функция вычисляет n-ю степень своего аргумента и возвращает полученное значение с помощью оператора return. Если после оператора return есть еще какие-то операторы, то они никогда не получат управления. Тип значения, возвращаемого оператором return, должен совпадать с типом, указанным в объявлении метода; если же тип метода объявлен с помощью ключевого слова void, то в операторе return можно не указывать никакого значения (то есть поставить точку с запятой сразу после ключевого слова return). Таким образом, оператор return – это, с одной стороны, функциональная замена оператора goto на уровне методов, а с другой – способ возвращения результата работы метода.

    Использование операторов try и catch

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

Для ответа в этой теме необходимо авторизоваться.