Введение в Kotlin

Введение в Kotlin: Первое знакомство с миром программирования

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

Kotlin — это современный язык программирования, который используют компании вроде Google, JetBrains и многие другие. Он понятный, элегантный и очень дружелюбный к новичкам. На нём пишут приложения для Android, веб-сервисы и даже программы для компьютеров. И самое классное: он учит тебя думать как настоящий программист, но при этом не перегружает сложными правилами.

В этом уроке мы разберём самые основы. Ты узнаешь, как Kotlin "думает", как записывать команды и как заставить компьютер выполнять твои инструкции. Готов? Поехали!

Что такое программа и как её "понимает" компьютер?

Давай начнём с аналогии. Представь, что ты даёшь другу рецепт пиццы. Ты пишешь: "Возьми тесто, раскатай его, добавь соус, посыпь сыром, поставь в духовку". Друг читает каждую строчку и выполняет действие. Точно так же работает программа: ты пишешь инструкции на языке Kotlin, а компьютер их выполняет.

Разница лишь в том, что компьютер очень буквальный. Если ты напишешь "поставь в духовку", но не уточнишь температуру и время, он не догадается. Поэтому программисты учатся быть точными и последовательными.

💡 Запомни: компьютер — это очень умный, но абсолютно бездумный исполнитель. Он делает только то, что ты ему скажешь, и именно так, как ты скажешь.

Kotlin — это язык, который переводит твои инструкции в машинный код (единицы и нули), понятные процессору. Но тебе не нужно думать о нулях — ты пишешь почти как на английском, но с правилами. Давай посмотрим, как выглядит самая простая программа.

Твоя первая программа: "Привет, мир!"

Любой программист начинает с того, что заставляет компьютер написать "Привет, мир!". Это традиция. Вот как это выглядит в Kotlin:

// Это комментарий. Компьютер его игнорирует, он для людей.
// Следующая строка — главная функция, с неё начинается любая программа.

fun main() {
    // Команда println выводит текст на экран
    println("Привет, мир!")
}

Давай разберём каждую часть:

• fun main() — это объявление функции. Fun означает "функция" (действие), main — это имя. Главная функция main — это точка входа, с неё всё начинается. Как дверь в дом: без неё не войдёшь.
• { } — фигурные скобки. Они показывают начало и конец блока кода. Всё, что внутри, принадлежит функции.
• println — это команда "печатать строку". Она берёт текст в кавычках и выводит его на экран. Print line — "печатать строку".
• ("Привет, мир!") — это аргумент. Данные, которые мы передаём команде. В данном случае — текст.
• // — однострочный комментарий. Всё, что после // до конца строки, компьютер игнорирует.

Попробуй мысленно выполнить этот код: компьютер видит fun main(), заходит внутрь скобок, видит println и выводит текст. Всё просто!

Переменные: коробочки для данных

В программировании мы постоянно работаем с данными: числами, текстом, датами, списками. Чтобы хранить эти данные, мы используем переменные. Представь, что переменная — это коробка с наклейкой. На наклейке написано имя (например, "возраст"), а внутри лежит значение (например, 15).

В Kotlin есть два способа создать переменную:

• val — от слова "value" (значение). Это коробка, которую нельзя заменить. Положил один раз — и навсегда. Как дата твоего рождения.
• var — от слова "variable" (изменяемый). Это коробка, содержимое которой можно менять. Как твой вес: он может увеличиваться или уменьшаться.

Смотри пример:

fun main() {
    // val — неизменяемая переменная
    val имя = "Аня"  // Тип String (строка) — текст
    println("Привет, " + имя)  // Выведет: Привет, Аня
    
    // var — изменяемая переменная
    var возраст = 12  // Тип Int (целое число)
    println("Тебе " + возраст + " лет")
    
    // Меняем значение var
    возраст = 13
    println("Теперь тебе " + возраст + " лет")
    
    // А вот так делать нельзя! val нельзя изменить:
    // имя = "Оля"  // Ошибка! val нельзя переназначить
}

Обрати внимание: Kotlin сам догадывается, какого типа данные ты хранишь. Если ты написал 12, он понимает, что это число (Int). Если написал "Аня" в кавычках — это текст (String). Это называется вывод типов — одна из фишек Kotlin, которая делает код короче.

Но можно указать тип явно, если хочешь:

fun main() {
    val имя: String = "Петя"  // Явно указали тип String
    var возраст: Int = 14      // Явно указали тип Int
    
    println("Меня зовут $имя")  // Упрощённый способ вставить переменную в текст
    println("Мне $возраст лет")
}

Видишь $имя? Это строковая интерполяция. Вместо того чтобы склеивать куски текста знаком +, можно просто поставить $ перед именем переменной, и Kotlin сам подставит её значение. Очень удобно!

Основные типы данных: числа, буквы и правда

В программировании данные бывают разных видов. Kotlin поддерживает множество типов, но пока нам хватит четырёх основных:

Тип	Описание	Пример
Int	Целые числа (без дробной части)	5, -3, 1000
Double	Дробные числа (с точкой)	3.14, -0.5, 2.0
String	Текст (строка символов)	"Привет", "Kotlin"
Boolean	Логическое значение (правда/ложь)	true, false

Посмотри, как они работают в коде:

fun main() {
    // Целые числа
    val возраст: Int = 15
    val годРождения: Int = 2024 - возраст  // Kotlin сам посчитает
    
    // Дробные числа
    val рост: Double = 1.65  // Метры
    val вес: Double = 55.5   // Килограммы
    
    // Текст
    val имя: String = "Максим"
    val любимыйПредмет: String = "Математика"
    
    // Логические значения
    val любитПрограммировать: Boolean = true
    val ужеСпалСегодня: Boolean = false  // Надеюсь, ты не спал на уроке!
    
    println("Привет! Меня зовут $имя, мне $возраст лет.")
    println("Мой рост: $рост м, вес: $вес кг.")
    println("Люблю программировать? $любитПрограммировать")
}

💡 Запомни: Boolean (или булев) — это тип, который может быть только true (истина) или false (ложь). Как выключатель: либо включено, либо выключено. Очень полезно для принятия решений!

Арифметические операции: компьютер считает быстрее тебя

Компьютеры отлично считают. Kotlin поддерживает все основные математические действия:

fun main() {
    val a = 10
    val b = 3
    
    val сумма = a + b        // 13
    val разность = a - b     // 7
    val произведение = a * b // 30
    val частное = a / b      // 3 (целочисленное деление!)
    val остаток = a % b      // 1 (остаток от деления)
    
    println("Сумма: $сумма")
    println("Разность: $разность")
    println("Произведение: $произведение")
    println("Частное: $частное")
    println("Остаток: $остаток")
    
    // Если нужно дробное деление, используй Double
    val дробное = 10.0 / 3.0  // 3.3333333333333335
    println("Дробное деление: $дробное")
}

Обрати внимание на % — это оператор остатка от деления. Он показывает, сколько осталось, если разделить одно число на другое нацело. Например, 10 % 3 = 1, потому что 3 * 3 = 9, и остаётся 1. Этот оператор очень полезен для проверки чётности чисел или работы с циклами.

Ещё важный момент: если ты делишь целые числа (Int), результат тоже будет целым. Kotlin отбрасывает дробную часть. Если хочешь получить дробный результат, хотя бы одно из чисел должно быть Double.

Логические операции: как компьютер принимает решения

Компьютеры постоянно принимают решения: "Если пользователь нажал кнопку, то показать меню; иначе — скрыть". Для этого используются логические операции. Они работают с типом Boolean (true/false).

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

• == — равно (проверяет, равны ли два значения)
• != — не равно
• > — больше
• < — меньше
• >= — больше или равно
• <= — меньше или равно

А также логические операторы:

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

Смотри пример:

fun main() {
    val возраст = 14
    val естьПрава = false
    
    // Сравнение
    val можно учить = возраст >= 12  // true (больше или равно 12)
    val взрослый = возраст > 18      // false
    
    println("Можно учить программирование? $можно учить")
    println("Взрослый? $взрослый")
    
    // Логические операции
    val можетВодить = (возраст >= 18) && естьПрава  // false (оба условия ложны)
    val можетКататьсяНаВелике = (возраст >= 14) || естьПрава  // true (возраст подходит)
    
    println("Может водить машину? $можетВодить")
    println("Может кататься на велике? $можетКататьсяНаВелике")
    
    // Отрицание
    val неВзрослый = !взрослый  // true (меняем false на true)
    println("Не взрослый? $неВзрослый")
}

💡 Важно: == (два знака равно) — это проверка равенства. Один знак = — это присваивание (положить значение в переменную). Не путай их! Это одна из самых частых ошибок новичков.

Условный оператор if: ветвление программы

Теперь самое интересное — заставим программу принимать решения. Для этого используется конструкция if (если). Это как развилка на дороге: если условие верно, идём по одной ветке, если нет — по другой.

Базовая структура:

if (условие) {
    // код, который выполнится, если условие true
} else {
    // код, который выполнится, если условие false
}

Пример из жизни:

fun main() {
    val возраст = 15
    val оценка = 4
    
    // Простой if
    if (возраст >= 14) {
        println("Тебе можно смотреть фильмы с рейтингом 14+")
    }
    
    // If-else
    if (оценка >= 4) {
        println("Молодец! Ты хорошо учишься!")
    } else {
        println("Нужно подтянуть учёбу!")
    }
    
    // If-else if-else (несколько условий)
    val температура = 25
    if (температура > 30) {
        println("Очень жарко, иди купаться!")
    } else if (температура > 20) {
        println("Тепло, можно гулять")
    } else if (температура > 10) {
        println("Прохладно, надень куртку")
    } else {
        println("Холодно, сиди дома!")
    }
    
    // If можно использовать как выражение (присваивать результат)
    val времяСуток = 14
    val приветствие = if (времяСуток < 12) {
        "Доброе утро!"
    } else if (времяСуток < 18) {
        "Добрый день!"
    } else {
        "Добрый вечер!"
    }
    println(приветствие)  // Выведет: Добрый день!
}

Обрати внимание на последний пример: мы присвоили результат if переменной приветствие. В Kotlin if — это не просто оператор, а выражение, которое возвращает значение. Это очень удобно и делает код короче.

Функции: создаём свои собственные команды

Ты уже видел функцию main() и команду println(). Но ты можешь создавать свои собственные функции! Функция — это как рецепт: ты даёшь ей имя, описываешь действия, а потом можешь вызывать её сколько угодно раз.

Зачем это нужно? Представь, что в твоей программе нужно 10 раз посчитать площадь прямоугольника. Вместо того чтобы писать одни и те же строки 10 раз, ты пишешь функцию один раз и вызываешь её.

Структура функции:

fun имяФункции(параметры): возвращаемыйТип {
    // тело функции
    return результат
}

Параметры — это данные, которые функция принимает на вход. Возвращаемый тип — это тип данных, который функция выдаёт после выполнения. Если функция ничего не возвращает, пишем Unit (или просто ничего не пишем).

Примеры:

// Функция без параметров, ничего не возвращает
fun показатьПриветствие() {
    println("Привет, ученик!")
    println("Добро пожаловать на урок Kotlin!")
}

// Функция с параметрами, возвращает число
fun сложить(a: Int, b: Int): Int {
    val результат = a + b
    return результат
}

// Функция с параметрами, возвращает строку
fun приветствие(имя: String): String {
    return "Привет, $имя! Рад тебя видеть!"
}

// Функция с параметром по умолчанию
fun умножить(a: Int, b: Int = 2): Int {
    return a * b
}

fun main() {
    // Вызываем функции
    показатьПриветствие()
    
    val сумма = сложить(5, 3)
    println("Сумма 5 и 3 = $сумма")
    
    val сообщение = приветствие("Аня")
    println(сообщение)
    
    // Используем параметр по умолчанию
    println("5 * 2 = ${умножить(5)}")       // b = 2 по умолчанию
    println("5 * 10 = ${умножить(5, 10)}")  // b = 10
}

Видишь, как удобно? Мы создали функцию сложить, и теперь можем складывать любые два числа, просто вызывая её. Функции делают код:

• Переиспользуемым — написал один раз, используй много раз
• Читаемым — имя функции объясняет, что она делает
• Модульным — можно исправить ошибку в одном месте, а не везде

💡 Совет: Давай функциям понятные имена. Не f1(), а посчитатьПлощадь(). Твой будущий коллега (или ты сам через месяц) скажет тебе спасибо!

Комментарии: твой разговор с будущим собой

Когда пишешь код, ты общаешься не только с компьютером, но и с людьми (включая себя в будущем). Комментарии — это текст, который компьютер игнорирует, но который помогает понять, что делает код.

В Kotlin есть два вида комментариев:

• // — однострочный комментарий. Всё до конца строки игнорируется.
• /* */ — многострочный комментарий. Можно писать на нескольких строках.

/*
 * Это многострочный комментарий.
 * Его используют для описания целых функций или сложных частей кода.
 * Очень удобно для документации!
 */

fun main() {
    // Это однострочный комментарий
    // Он объясняет, что делает следующая строка
    
    val имя = "Коля"  // Здесь комментарий в конце строки
    
    /* Ещё один способ
       написать многострочный
       комментарий */
    
    println("Привет, $имя!")
}

Пиши комментарии, когда код неочевиден. Но не комментируй очевидные вещи — это захламляет код. Например, не пиши "// Выводим приветствие" перед println — это и так понятно.

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

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

Задание 1: Калькулятор возраста

Напиши программу, которая:

1. Создаёт переменную годРождения (например, 2009)
2. Создаёт переменную текущийГод (например, 2024)
3. Вычисляет возраст: текущийГод - годРождения
4. Выводит сообщение: "Если ты родился в 2009, то сейчас тебе 15 лет."
5. Используй строковую интерполяцию ($)

Подсказка: Используй val для неизменяемых данных и println для вывода.

Задание 2: Оценка температуры

Создай программу, которая:

1. Принимает температуру (val температура = 18)
2. Используя if-else if-else, выводит:
   • "Жарко" если температура > 25
   • "Тепло" если от 15 до 25 включительно
   • "Прохладно" если от 5 до 14 включительно
   • "Холодно" если меньше 5

Подсказка: Используй операторы сравнения && (И) для проверки диапазонов. Например: температура >= 15 && температура <= 25.

Задание 3: Функция приветствия