Переменные, выражения и типы

Итак, вы хотите стать разработчиком на языке Kotlin?

Тогда вы пришли в нужное место!

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

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

Давайте приступим!

Введение в переменные

Это круг.

Еще в Древней Греции Архимед открыл способ измерения длины линии круга, именуемой окружностью. Вы, вероятно, помните это уравнение из уроков геометрии в младших классах школы.

Окружность круга равна 2 умножить на π, умноженное на радиус круга.

В приведенном выше уравнении буква r не является числом. Эта буква обозначает радиус – расстояние между центром круга и его краем.

Буква r называется переменной, потому что радиус может меняться в зависимости от размера круга. Другими словами, переменная r – это не число, а что-то вроде ведра, которое содержит число – любое число.

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

var r = 5.2

На самом деле приведенный выше исходный код делает две вещи в одной строке.

1. Объявление: при написании var r объявляется новая переменная с именем r. Объявить переменную – это все равно что создать ведро.

2. Присваивание: при написании r = 5.2 переменной r присваивается значение 5.2. Другими словами, число 5.2 помещается в ведро.

Давайте разберем три главные части этой строки исходного кода.

В приведенном выше исходном коде:

• var – это ключевое слово, сообщающее компилятору Kotlin, что нужно создать новую переменную;
• r – это имя переменной. Эту часть также принято называть идентификатором переменной;
• число 5.2 – это значение, которое присваивается переменной.

var – это лишь одно из многочисленных ключевых слов языка Kotlin, с которыми вы познакомитесь в данной книге. Главное – нужно помнить о том, что ключевые слова нельзя использовать в качестве имен своих программных компонентов. Например, var нельзя использовать в качестве имени пере менной.

var var = 5

Переприсваивание значений переменным

Как уже отмечалось выше, переменная r уравнения 2πr в разных ситуациях может представлять разные числа.

Если будет решено, что r должно содержать другое число, то в языке Kotlin достаточно его переприсвоить, то есть присвоить переменной повторно, как показано во второй строке ниже.

var r = 5.2
r = 6.7

При переприсваивании этой переменной нового значения не нужно снова использовать ключевое слово var, потому что переменная уже была объявлена в первой строке.

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

Давайте снова взглянем на уравнение окружности:

Греческая буква π (произносится как «пи») сильно отличается от переменной r. В отличие от r, которая может содержать любое число, π может содержать только одно конкретное число, которое приближенно равняется 3.14.

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

В этих случаях вместо объявления переменной через var она объявляется через val, как показано ниже:

val π = 3.14

Если теперь попытаться переприсвоить π новое значение, то будет получена ошибка.

val π = 3.14
π = 1.23

Единожды поместив что-то в это ведро, его уже невозможно никогда заменить!

Обратите внимание, что независимо от того, каким образом объявлен объект, будь то через var либо через val, компилятор Kotlin все равно считает его переменной, и эта переменная по-прежнему обладает значением. Поэтому π считается переменной, невзирая на то что ее значение не может изменяться.

Объявлять переменную через val – это отличный способ заботиться о том, чтобы то, что не должно меняться, не было нечаянно изменено. На самом деле совсем неплохая идея – взять за правило всегда начинать с val и переходить к var только в случае необходимости.

Именование переменных

Было забавно использовать букву π в исходном коде, но если вы не живете в Греции, то, скорее всего, у вас ее нет на клавиатуре. С этого момента давайте упростим жизнь всем и будем ее именовать pi. Также вместо r давайте будем называть эту переменную radius, чтобы другие разработчики, которые появятся позже, точно знали, что, собственно говоря, эта переменная представляет. Не хотелось бы, чтобы другим приходилось гадать о смысле буквы r!

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

var radiusOfTheCircle = 5.2

Разобравшись с основами объявления переменных и присваивания им значений, теперь можно начать присваивать им не только обыкновенные числа – самое время начать присваивать им более сложные вычисления, например уравнение окружности! Давайте погрузимся в выражения!

Выражения и инструкции

Давайте взглянем на это уравнение еще раз:

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

Все, что нужно сделать, – это перемножить 2, pi и radius. В Kotlin, как и в большинстве языков программирования, умножение обозначается не крестиком x, а звездочкой *, поэтому исходный код будет выглядеть следующим образом.

var radius = 5.2
val pi = 3.14

val circumference = 2 * pi * radius

Пока что присваивались только простые значения, такие как 5.2 и 3.14. Сейчас же впервые присваивается что-то более сложное: 2 * pi * radius.

Когда компилятор Kotlin это видит, он просто вычисляет результат за вас – он умножает 2 на pi и radius, а затем, конечно же, берет полученное значение и присваивает его переменной с именем circumference. В данном случае (с радиусом 2.8) окружность будет равна 17.584.

Поскольку результат 2 * pi * radius можно рассчитать, принято говорить, что его значение можно вычислить. Фрагмент исходного кода, вычисление которого возвращает значение, называется выражением. Вот несколько примеров выражений:

• 2 + 3
• 2 * pi * r
• pi * r * r

Сами переменные тоже являются выражениями – их вычисление возвращает любое значение, которое они содержат:

• radius
• pi

Число, набранное на клавиатуре вручную (в отличие от набора имени переменной), называется литералом числа.

Сами литералы тоже являются выражениями – их вычисление возвращает их самих! Вот несколько примеров:

• 2
• 5.2
• 3.14

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

Вот простой способ понять, что перед вами находится – выражение или же инструкция:

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

Давайте применим это правило к первому выражению из трех приведенных выше списков (2 + 3, radius и 2). В следующем ниже листинге исходного кода выделенные части являются выражениями.

val a = 2 + 3
val b = radius
val c = 2

Поскольку каждое может быть присвоено переменной, все они являются выражениями.

Единственная встретившаяся ранее инструкция была инструкцией присваивания, val pi = 3.14. Следуя приведенным выше указаниям, эту инструкцию можно попытаться присвоить переменной, но это не сработает.

val a = val pi = 3.14

При попытке это сделать компилятор Kotlin выдает полезное сообщение об ошибке: «Ожидается выражение» (англ. Expecting an expression). Если вы когда-нибудь увидите это сообщение об ошибке, то это означает, что вы попытались использовать инструкцию там, где компилятор Kotlin хотел видеть выражение.

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

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

Типы: разновидности значений

В языке Kotlin разные переменные могут содержать разные виды значений. Разновидность содержащихся в переменной значений называется ее типом.

Давайте еще раз взглянем на переменные radius и pi.

var radius = 5.2
val pi = 3.14

В данном случае и radius, и pi представляют числа с десятичной точкой, то есть тип, который в Kotlin называется Double. Кроме того, компилятору Kotlin можно сообщать тип переменной в явной форме, как показано ниже.

var radius: Double = 5.2
val pi: Double = 3.14

Используя такую запись, программист конкретизирует тип явным образом.

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

Поэтому при написании…

var radius = 5.2

…компилятор Kotlin знает, что 5.2 имеет тип Double, поэтому он автоматически использует Double в качестве типа переменной radius.

Помимо типа Double, полезно знать о еще нескольких базовых типах! Давайте взглянем на некоторые из них.

Целые и длинные числа

Пока что использовались только числа с десятичной точкой, такие как 5.2 и 3.14. Но помимо них также используются числа без десятичной точки, например 5 или 3. Такие разновидности чисел называются целыми, и в Kotlin целочисленный тип называется коротко Int. Вот пример, в котором создается целочисленная переменная.

val numberOfDogs: Int = 3

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

Булевы величины

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

В таких случаях хорошо помогает булева переменная, у которой может быть только два значения – true и false – и оба этих значения являются ключевыми словами языка Kotlin.

val puffinsCanFly: Boolean = true
val penguinsCanFly: Boolean = false

Тип Boolean получил свое название от имени британского математика 1800-х годов Джорджа Буля, разработавшего подраздел алгебры, в котором вместо чисел используются истина и ложь.

Строковые литералы

Кроме того, переменным также можно присваивать текстовые значения. В программистском сообществе для обозначения текста нередко принято использовать причудливое словечко «строка». На самом деле это строковый литерал, потому что это цепочка символов – букв, цифр и знаков, – «нанизанных» друг за другом.

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

val text: String = "Это строковый литерал"

Другие типы

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

Типы и переприсваивание

Тип каждой переменной в языке Kotlin устанавливается в момент написания исходного кода, и после этого ее тип никогда не изменяется (если только не переписывать исходный код). Именно поэтому данный подход называется статической типизацией. Как только переменная объявлена с тем или иным типом, в нее невозможно поместить значение другого типа. Например, если создать переменную типа Int, то ей нельзя присвоить значение типа String.

var numberOfDogs: Int = 5
numberOfDogs = "пять"

В последующих главах вы увидите, как некоторые типы могут иметь подтипы. Но не будем забегать вперед! А пока же давайте завершим эту главу.

Краткий итог

Проделана отличная работа – ведь вы преодолели первую главу! Благодаря кругам разного размера ваше понимание переменных, типов и выражений языка Kotlin начинает обретать форму!

В этой главе вы узнали о том:

• как использовать ключевое слово var для переменных, которым могут переприсваиваться новые значения;
• как использовать ключевое слово val для переменных с доступом только для чтения;
• что выражения возвращают результат вычисления;
• что инструкции не возвращают результат вычисления;
• что в языке Kotlin есть числовые типы Double и Int;
• как использовать тип Boolean для значений true и false;
• как использовать тип String для текстовых значений.

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

Share this article: