Цикл — это конструкция, содержащая в себе программный код, который должен быть выполнен определённое количество раз. Количество проходов цикла (раз выполнения или шагов цикла) задаётся конкретным логическим условием.
Применение циклов позволяет уменьшить количество повторяющихся строк кода и тем самым ускорить разработку программного продукта, а также придать коду эстетически приятный вид.
На языке Java существуют три вида циклов:
- Цикл с чётким количеством проходов — for();
- Цикл с предусловием, условие проверяется ДО выполнения инструкций в теле цикла — while();
- Цикл с постусловием, условие проверяется ПОСЛЕ выполнения инструкций в теле цикла — do { … } while();
Для изменения переменной-счётчика принято использовать инкремент (увеличение) или декремент (уменьшение).
Запомните: всё, что было создано в цикле, после его завершения «умирает»!
Цикл for()
Данный тип цикла отличителен тем, что в нём чётко прописывается количество шагов.
Формула реализации такого цикла следующая:
for (переменная-счётчик; логическое_условие; изменение_счётчика) { тело_цикла }
Выведем слово «Привет!» десять раз. Для реализации данной задачи можно прописать десять раз функцию вывода с соответствующим сообщением. А если вывести нужно тысячу раз? А если необходимо что-то добавить в данное сообщение? Все эти действия будут очень долгими и неудобными. Здесь нам поможет цикл!
|
1 2 3 4 5 6 7 8 |
public class Main { public static void main(String[] args) { for (int i=0; i<10; i++){ //выполнить инструкцию в теле цикла 10 раз (от 0 до 9 включительно) System.out.println("Привет!"); //вывод сообщения } } } |
В результате на экран получаем:
|
1 2 3 4 5 6 7 8 9 10 |
Привет! Привет! Привет! Привет! Привет! Привет! Привет! Привет! Привет! Привет! |
При каждом проходе цикла шаг (переменная-счётчик) наращивается на единицу. Это называется наращиваем счётчика на единицу.
Но вот что интересно: счёт мы начали с нуля и закончили девятью. Всему виной наше логическое условие и особенности программирования. Любой счёт в программировании начинается с нуля, а не с привычной единицы и наше логическое условие говорит «пока i меньше 10», то есть, когда i нарастилась до 10 логическое условие возвращает false (так как оно не выполнилось) и на этом цикл завершается («умирает»).
0,1,2,3,4,5,6,7,8,9 — здесь десять цифр.
Запомните: счёт в программировании начинает с цифры 0!
Модернизируем наш код и выведем также номера строк (в качестве номеров будем использовать шаг цикла).
|
1 2 3 4 5 6 7 8 |
public class Main { public static void main(String[] args) { for (int i=0; i<10; i++){ //выполнить инструкцию в теле цикла 10 раз (от 0 до 9 включительно) System.out.println(i + " - Привет!"); //вывод сообщения c номером строки } } } |
В результате получаем:
|
1 2 3 4 5 6 7 8 9 10 |
0 - Привет! 1 - Привет! 2 - Привет! 3 - Привет! 4 - Привет! 5 - Привет! 6 - Привет! 7 - Привет! 8 - Привет! 9 - Привет! |
Также можно пойти в обратном порядке, начать счёт не с 0 до 10, а с 10 до 0. Для этого необходимо изменить логическое условие и изменить инкремент на декремент.
|
1 2 3 4 5 6 7 8 |
public class Main { public static void main(String[] args) { for (int i=10; i>0; i--){ //выполнить инструкцию в теле цикла 10 раз (от 10 до 1 включительно) System.out.println(i + " - Привет!"); //вывод сообщения c номером строки } } } |
В результате получаем:
|
1 2 3 4 5 6 7 8 9 10 |
10 - Привет! 9 - Привет! 8 - Привет! 7 - Привет! 6 - Привет! 5 - Привет! 4 - Привет! 3 - Привет! 2 - Привет! 1 - Привет! |
От 10 до 1 — 10 цифр.
Если хотим, чтобы шаг цикла был не 1, а скажем 2, то необходимо изменить изменение переменной-счётчика. Лучше использовать краткую форму записи (так удобнее и читабельнее), но это только на Ваше усмотрение.
|
1 2 3 4 5 6 7 8 |
public class Main { public static void main(String[] args) { for (int i=0; i<10; i+=2){ //выполнить инструкцию в теле цикла с шагом 2 System.out.println(i + " - Привет!"); //вывод сообщения c номером строки } } } |
В результате получаем:
|
1 2 3 4 5 |
0 - Привет! 2 - Привет! 4 - Привет! 6 - Привет! 8 - Привет! |
В качестве шага цикла можно указать любое целочисленное значение.
Цикл while()
В данном типе цикла сначала проверяется логическое выражение, а затем (если логическое выражение вернуло true) начинает выполнение программного кода в теле цикла.
Формула реализации следующая:
while (логическое_выражение) { тело_цикла }
В этом типе цикла необходимо прописать в теле цикла изменение счётчика, иначе переменная-счётчик всегда будет одинаковой, а из-за этого цикл будет работать вечно (хотя и это порой используется).
Выведем слово «Здравствуй!» десять раз.
|
1 2 3 4 5 6 7 8 9 10 11 |
public class Main { public static void main(String[] args) { int j = 0; //создаём переменную-счётчик while(j < 10){ //проверяется условие пока j меньше 10 выполнять инструкцию в теле цикле System.out.println(j + " - Здравствуй!"); //вывод сообщения j++; //наращивание счётчика с помощью инкремента } } } |
Перед циклом обязательно нужно создать переменную и положить в неё определённое значение с которого будет начинаться цикл.
Работает данный код следующим образом:
- Проверяется логическое условие, если значение переменной j меньше 10, то выполнять инструкции в теле цикла;
- Вывод сообщения «Здравствуй!»;
- Наращивание счётчика на единицу с помощью инкремента;
- Переход к пункту 1 и так до тех пор, пока логическое выражение в скобках не вернёт false;
В результате получаем:
|
1 2 3 4 5 6 7 8 9 10 |
0 - Здравствуй! 1 - Здравствуй! 2 - Здравствуй! 3 - Здравствуй! 4 - Здравствуй! 5 - Здравствуй! 6 - Здравствуй! 7 - Здравствуй! 8 - Здравствуй! 9 - Здравствуй! |
Изменим в нашем коде изменение шага на 3.
|
1 2 3 4 5 6 7 8 9 10 11 |
public class Main { public static void main(String[] args) { int j = 0; //создаём переменную-счётчик while(j < 10){ //проверяется условие пока j меньше 10 выполнять инструкцию в теле цикле System.out.println(j + " - Здравствуй!"); //вывод сообщения j+=4; //наращивание счётчика на 4 единицы } } } |
В результате получим:
|
1 2 3 |
0 - Здравствуй! 4 - Здравствуй! 8 - Здравствуй! |
Цикл while() работает, пока логическое выражение возвращает true, как только возвращается false цикл «умирает».
Цикл do { … } while();
В данном типе цикла происходит проверка логического выражения только после выполнения программного кода в теле цикла. То есть, какое бы ни было логическое выражение, инструкции в теле цикла будут выполнены минимум один раз. Это отличительное свойство данного цикла.
Синтаксис (стандарт написания кода) точно такой же как и у цикла while(). Необходимо заранее определить переменную-счётчик, указать логическое выражение, а в теле обязательно прописать изменение счётчика.
|
1 2 3 4 5 6 7 8 9 10 |
public class Main { public static void main(String[] args) { int m = 0; //переменная-счётчик do{ //начало цикла System.out.println(m + " - Good bye!"); //вывод сообщения m++; //наращивание счётчика на 1 }while(m < 10); //проверка логического условия } } |
В результате получим:
|
1 2 3 4 5 6 7 8 9 10 |
0 - Good bye! 1 - Good bye! 2 - Good bye! 3 - Good bye! 4 - Good bye! 5 - Good bye! 6 - Good bye! 7 - Good bye! 8 - Good bye! 9 - Good bye! |
Изменим логическое выражение так, чтобы цикл не сделал ни одного прохода. Изменим знак меньше в логическом условии на знак больше.
|
1 2 3 4 5 6 7 8 9 10 |
public class Main { public static void main(String[] args) { int m = 0; //переменная-счётчик do{ //начало цикла System.out.println(m + " - Good bye!"); //вывод сообщения m++; //наращивание счётчика на 1 }while(m > 10); //проверка логического условия (некорректное) } } |
В результате получим:
|
1 |
0 - Good bye! |
Сработал только один первый проход и всё! Проверка логического условия происходит только после выполнения программного кода в теле цикла.
Вечный цикл
Вечный цикл, это цикл который выполняется бесконечно, то есть предельного количества проходов цикла не существует. Зачастую для его создания используют цикл while().
|
1 2 3 4 5 6 7 8 9 10 |
public class Main { public static void main(String[] args) { int m = 0; //переменная-счётчик while (m < 1){ //корректное логическое условие System.out.println(m + " - вечный цикл"); //вывод сообщения с номером строки //отсутствует изменение счётчика } } } |
В результате получим:
|
1 2 3 4 5 6 |
0 - вечный цикл 0 - вечный цикл 0 - вечный цикл 0 - вечный цикл 0 - вечный цикл ... |
И так до бесконечности (пока память компьютера не будет истощена, а это произойдёт не скоро). При запуске данного кода обязательно самостоятельно его прервите (иначе он просто никогда не закончится).
Таким не хитрым образом мы познакомились с темой: «Циклы в языке программирования Java«!
