Условия и циклы Kotlin

Введение: Что такое управляющие конструкции и зачем они нужны?

Представь, что ты пишешь инструкцию для робота, который помогает тебе убираться в комнате. Ты не можешь просто сказать: «Убери комнату». Роботу нужны чёткие шаги: «Если видишь носок на полу — подними его. Если носок грязный — положи в стирку. Если чистый — сложи в ящик. Повторяй, пока все носки не будут убраны». Вот это и есть управляющие конструкции — они говорят программе, что делать в разных ситуациях и сколько раз это повторять.

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

1. Условные операторы: если… то… иначе…

1.1. Простое условие if

Самый базовый способ принять решение — это оператор if. Он проверяет условие и, если оно истинно (правда), выполняет блок кода. Если ложно — пропускает.

Аналогия из жизни: Мама говорит: «Если ты сделаешь уроки, то получишь печенье». Если условие «сделал уроки» = истина, то ты получаешь печенье. Если нет — ничего не происходит.

fun main() {
    val возраст = 16

    // Проверяем условие: возраст больше или равен 18?
    if (возраст >= 18) {
        println("Ты совершеннолетний! Можешь голосовать.")
    }

    println("Программа завершена.")
    // Вывод: "Программа завершена."
    // Условие не сработало, так как 16 < 18
}

Обрати внимание: условие пишется в круглых скобках (возраст >= 18), а код, который выполняется, — в фигурных { ... }. Фигурные скобки создают блок кода — группу команд, которые выполняются вместе.

1.2. Развилка: if-else

Что если мы хотим сделать что-то в обоих случаях? Например: «Если температура выше 25 градусов — надень футболку, иначе — надень кофту». Для этого используем else (иначе).

fun main() {
    val температура = 20

    if (температура > 25) {
        println("Надеваем футболку!")
    } else {
        println("Надеваем кофту!")
    }
    // Вывод: "Надеваем кофту!" (так как 20 не больше 25)
}

Теперь программа всегда делает выбор: либо первое, либо второе. Никаких «если не знаешь, что делать».

1.3. Каскад условий: if-else if-else

В жизни редко бывает только два варианта. Например, оценка за тест: 5 — «Отлично», 4 — «Хорошо», 3 — «Удовлетворительно», 2 — «Плохо». Тут нужно несколько условий подряд.

Аналогия: Светофор. Если горит зелёный — иди. Если жёлтый — приготовься. Если красный — стой. Иначе (светофор сломался) — будь внимателен.

fun main() {
    val баллы = 85

    if (баллы >= 90) {
        println("Оценка: 5 (Отлично!)")
    } else if (баллы >= 75) {
        println("Оценка: 4 (Хорошо)")
    } else if (баллы >= 50) {
        println("Оценка: 3 (Удовлетворительно)")
    } else {
        println("Оценка: 2 (Нужно подтянуть знания)")
    }
    // Вывод: "Оценка: 4 (Хорошо)" — 85 попадает в диапазон от 75 до 89
}

Важно: проверка идёт сверху вниз. Как только находим первое истинное условие — выполняем его блок и выходим из всей конструкции. else в конце — это «ловушка» для всех остальных случаев.

1.4. when — элегантная замена длинным if-else

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

Аналогия: Ты подходишь к автомату с газировкой. Нажимаешь кнопку «1» — получаешь колу, «2» — спрайт, «3» — фанту. when делает то же самое.

fun main() {
    val номерКнопки = 2

    when (номерКнопки) {
        1 -> println("Вы выбрали Колу!")
        2 -> println("Вы выбрали Спрайт!")
        3 -> println("Вы выбрали Фанту!")
        else -> println("Такого напитка нет.") // Если ничего не подошло
    }
    // Вывод: "Вы выбрали Спрайт!"
}

Стрелка -> разделяет вариант и действие. Можно проверять не только числа, но и строки, диапазоны и даже сложные условия.

fun main() {
    val деньНедели = "Суббота"

    when (деньНедели) {
        "Понедельник", "Вторник", "Среда", "Четверг", "Пятница" -> println("Рабочий день")
        "Суббота", "Воскресенье" -> println("Выходной!")
        else -> println("Некорректный день")
    }
    // Вывод: "Выходной!"
}

2. Логические операторы: И, ИЛИ, НЕ

Условия редко бывают простыми. Часто нужно проверить несколько вещей сразу. Например: «Если на улице идёт дождь И температура ниже 10 градусов — надень куртку». Или: «Если у тебя есть деньги ИЛИ ты получил подарок — ты можешь купить мороженое».

Для этого служат логические операторы:

• && — И (AND). Оба условия должны быть истинны.
• || — ИЛИ (OR). Хотя бы одно условие истинно.
• ! — НЕ (NOT). Меняет истину на ложь и наоборот.

fun main() {
    val возраст = 15
    val естьРазрешениеРодителей = true

    // Проверяем: возраст >= 18 ИЛИ есть разрешение?
    if (возраст >= 18 || естьРазрешениеРодителей) {
        println("Можно войти в кинотеатр!")
    } else {
        println("Вход запрещён.")
    }
    // Вывод: "Можно войти в кинотеатр!" — второе условие истинно

    val температура = 30
    val идетДождь = false

    // Если температура > 25 И НЕ идет дождь
    if (температура > 25 && !идетДождь) {
        println("Идём на пляж!")
    } else {
        println("Остаёмся дома.")
    }
    // Вывод: "Идём на пляж!" — оба условия истинны
}

Обрати внимание: !идетДождь означает «не идёт дождь». Если переменная идетДождь равна false, то !false = true.

3. Циклы: повторение — мать учения

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

3.1. Цикл while — «пока условие истинно»

Аналогия: Ты моешь посуду. Пока есть грязные тарелки (условие истинно), ты моешь одну тарелку. Как только тарелки закончились (условие стало ложным) — прекращаешь.

fun main() {
    var грязныеТарелки = 5 // У нас 5 грязных тарелок

    // Пока есть грязные тарелки (больше 0) — моем
    while (грязныеТарелки > 0) {
        println("Мою тарелку №$грязныеТарелки")
        грязныеТарелки-- // Уменьшаем счётчик на 1
    }

    println("Все тарелки чистые!")
    // Вывод:
    // Мою тарелку №5
    // Мою тарелку №4
    // Мою тарелку №3
    // Мою тарелку №2
    // Мою тарелку №1
    // Все тарелки чистые!
}

Важно: если условие сразу ложно, цикл не выполнится ни разу. А если условие всегда истинно — получится бесконечный цикл (программа зависнет). Будь осторожен!

3.2. Цикл for — «для каждого элемента»

for идеален, когда нужно перебрать известное количество элементов. Например, числа от 1 до 10, или все элементы списка.

Аналогия: Учитель проверяет тетради. Он берёт первую тетрадь, потом вторую, третью… пока не проверит все.

fun main() {
    // Перебираем числа от 1 до 5 (включительно)
    for (число in 1..5) {
        println("Квадрат числа $число равен ${число * число}")
    }
    // Вывод:
    // Квадрат числа 1 равен 1
    // Квадрат числа 2 равен 4
    // Квадрат числа 3 равен 9
    // Квадрат числа 4 равен 16
    // Квадрат числа 5 равен 25
}

1..5 — это диапазон (range) от 1 до 5 включительно. Переменная число на каждом шаге принимает следующее значение из диапазона.

Можно перебирать и в обратном порядке:

fun main() {
    // Обратный отсчёт от 10 до 1
    for (i in 10 downTo 1) {
        println("Осталось $i секунд")
    }
    println("ПУСК!")
}

Или с шагом:

fun main() {
    // Чётные числа от 0 до 10
    for (i in 0..10 step 2) {
        print("$i ") // Вывод: 0 2 4 6 8 10
    }
}

3.3. Цикл for со списками и строками

Циклы отлично работают с коллекциями данных. Например, можно перебрать все символы в строке или все элементы списка.

fun main() {
    val имя = "Анна"

    // Перебираем каждый символ в строке
    for (буква in имя) {
        println("Буква: $буква")
    }
    // Вывод:
    // Буква: А
    // Буква: н
    // Буква: н
    // Буква: а

    val списокДрузей = listOf("Петя", "Маша", "Вася")
    // Перебираем элементы списка
    for (друг in списокДрузей) {
        println("Привет, $друг!")
    }
    // Вывод:
    // Привет, Петя!
    // Привет, Маша!
    // Привет, Вася!
}

4. Управление циклами: break и continue

Иногда нужно прервать цикл досрочно или пропустить итерацию.

• break — немедленно выходит из цикла. Дальнейшие итерации не выполняются.
• continue — пропускает текущую итерацию и переходит к следующей.

Аналогия для break: Ты ищешь книгу на полке. Как только нашёл нужную — прекращаешь поиск (break).

Аналогия для continue: Ты ешь коробку конфет, но не любишь с орехами. Каждый раз, когда попадается конфета с орехом — ты её пропускаешь (continue) и берёшь следующую.

fun main() {
    // Поиск числа 7 в диапазоне от 1 до 10
    for (i in 1..10) {
        if (i == 7) {
            println("Нашли число 7! Останавливаемся.")
            break // Выходим из цикла
        }
        println("Проверяем число $i")
    }
    // Вывод:
    // Проверяем число 1
    // Проверяем число 2
    // ...
    // Проверяем число 6
    // Нашли число 7! Останавливаемся.

    println("---")

    // Выводим только числа, которые не делятся на 3
    for (i in 1..10) {
        if (i % 3 == 0) {
            continue // Пропускаем числа, кратные 3
        }
        println("Число $i не делится на 3")
    }
    // Вывод: 1, 2, 4, 5, 7, 8, 10 (без 3, 6, 9)
}

5. Вложенные конструкции: циклы внутри условий и наоборот

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

Аналогия: Ты играешь в компьютерную игру. Пока у тебя есть жизни (внешний цикл), ты проходишь уровни. На каждом уровне ты проверяешь: если встретил монстра — сражайся (условие), если монстров нет — иди дальше.

fun main() {
    // Таблица умножения: для каждого числа от 1 до 5
    for (i in 1..5) {
        println("Таблица умножения для числа $i:")
        // Внутренний цикл: умножаем на числа от 1 до 5
        for (j in 1..5) {
            println("$i * $j = ${i * j}")
        }
        println("---") // Разделитель между таблицами
    }
}

Вложенные конструкции нужно использовать аккуратно — они могут сделать программу сложной для понимания. Старайся не углубляться больше чем на 2-3 уровня.

6. Практические задания

Теперь твоя очередь! Попробуй решить эти задачи самостоятельно. Не бойся ошибаться — это нормально. Если что-то не работает, перечитай соответствующий раздел урока.

Задание 1. Калькулятор оценок

Напиши программу, которая запрашивает у пользователя число баллов (от 0 до 100) и выводит оценку по следующей шкале:

• 90-100: "Отлично! Ты гений!"
• 75-89: "Хорошо! Молодец!"
• 50-74: "Удовлетворительно. Можно лучше."
• 0-49: "Плохо. Нужно учить!"

Используй конструкцию when или if-else if-else. Подсказка: можно проверять диапазоны в when как in 90..100 -> ....

// Примерный шаблон решения:
fun main() {
    println("Введите количество баллов (0-100):")
    val баллы = readLine()?.toIntOrNull() ?: 0 // Читаем ввод пользователя

    // Твой код здесь
    when (баллы) {
        in 90..100 -> println("Отлично! Ты гений!")
        // ... допиши остальные варианты
        else -> println("Некорректный ввод")
    }
}

Задание 2. Сумма чётных чисел

Напиши программу, которая с помощью цикла for находит сумму всех чётных чисел от 1 до 100 (включительно). Выведи результат.

Подсказка: используй step 2 или проверку if (i % 2 == 0).

// Шаблон:
fun main() {
    var сумма = 0

    for (i in 1..100) {
        // Добавь проверку на чётность
        if (i % 2 == 0) {
            сумма += i // Прибавляем к сумме
        }
    }

    println("Сумма чётных чисел от 1 до 100 равна: $сумма")
}

Задание 3. Угадай число

Напиши программу, которая загадывает число от 1 до 10 (можно использовать val secret = 7), а затем даёт пользователю 3 попытки его угадать. После каждой попытки программа должна говорить: "Больше", "Меньше" или "Угадал!". Если пользователь не угадал за 3 попытки — вывести "Ты проиграл!".

Подсказка: используй цикл for на 3 итерации, внутри — if-else для сравнения.

// Шаблон:
fun main() {
    val загаданное = 7
    val максПопыток = 3

    println("Угадай число от 1 до 10. У тебя $максПопыток попытки.")

    for (попытка in 1..максПопыток) {
        println("Попытка №$попытка. Введи число:")
        val догадка = readLine()?.toIntOrNull() ?: 0

        // Сравниваем догадку с загаданным числом
        if (догадка == загаданное) {
            println("Поздравляю! Ты угадал!")
            return // Выходим из программы
        } else if (догадка < загаданное) {
            println("Загаданное число больше.")
        } else {
            println("Загаданное число меньше.")
        }
    }

    println("Ты проиграл! Загаданное число было $загаданное.")
}

Заключение

Сегодня ты узнал, как управлять программой с помощью условий и циклов. Это фундаментальные навыки, без которых не обходится ни одна программа. Теперь ты можешь:

• Принимать решения с помощью if, if-else и when.
• Повторять действия с помощью while и for.
• Комбинировать эти конструкции для решения сложных задач.

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

«Компьютер — это самый удивительный инструмент, который я когда-либо видел. Это велосипед для нашего сознания.» — Стив Джобс

В следующем уроке мы научимся работать с функциями — способом упаковывать куски кода в многократно используемые блоки. А пока — практикуйся с циклами и условиями. Удачи!