Переменные, константы и математические операторы в Kotlin

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

Уроки по теме «Выражения, переменные и константы в Kotlin»:

Содержание данной статьи:

Как работает компьютер
Способы представления чисел в информатике
Бинарные, или двоичные числа
Шестнадцатеричные числа
Как работает код
Начало работы с Kotlin
Задачи для проверки
Ключевые аспекты программирования на Kotlin

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

Как работает компьютер

Может показаться странным, но на самом деле компьютер не очень умен. Сила компьютеров проистекает из того, как они программируются людьми. Если вы хотите успешно использовать возможности компьютера, важно понимать, как они работают.

Вы можете удивиться, узнав, что компьютеры сами по себе являются довольно простыми машинами. В основе компьютера лежит центральный процессор (ЦП, CPU). По сути, это математическая машина. Он выполняет сложение, вычитание и другие арифметические операции с числами. Все, что вы видите при работе с компьютером, основано на процессоре, обрабатывающем числа миллионы раз в секунду. Разве не удивительно, что используются только цифры?

CPU сохраняет числа в небольших блоках памяти, которые называются регистрами. CPU может считывать числа в регистры из основной памяти компьютера, известной как оперативная память (ОЗУ, RAM). Он также может записывать число, хранящееся в регистре, обратно в RAM. Это позволяет процессору работать с большими объемами данных, которые не помещаются в банк регистров.

Далее дана схема того, как это работает:

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

Каждый раз, когда CPU выполняет сложение, вычитание, чтение из RAM или запись в RAM, он выполняет одну инструкцию. Каждая компьютерная программа обычно состоит из тысяч или миллионов инструкций. Сложная компьютерная программа вроде операционной системы типа iOS, Android, macOS, Windows или Linux (да, это тоже компьютерные программы!) может содержать в общей сложности миллионы инструкций.

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

Вместо написания отдельных инструкций вы пишете код на определенном языке программирования, которым в нашем случае будет Kotlin. Этот код пропускается через компьютерную программу, называемую компилятором, которая преобразует код в инструкции, которые CPU знает, как выполнять. Каждая строка кода, который вы пишете, превратится во множество инструкций — некоторые строки могут оказаться десятками инструкций!

В случае Kotlin, который возник как язык на Java Virtual Machine или JVM, существует дополнительный уровень между компилятором и OS. Компилятор Kotlin создает так называемый байт-код, который запускается на JVM и попутно преобразуется в собственный код. Kotlin начал с JVM, но теперь можно скомпилировать Kotlin непосредственно в собственный код. Это будет показано в будущих уроках.

Способы представления чисел в информатике

Вы наверняка знаете, что числа являются фундаментальной основой компьютера и всего того, что он делает. Любая информация, которую вы посылаете компилятору, в конечном итоге становится числом. К примеру, каждый символ внутри блока текста представлен числом. Подробнее об этом будет рассказано в Уроке №3, в котором подробно рассматриваются типы, включая строки string — компьютерный термин для блока текста.

Изображения не являются исключением. На компьютере каждая картинка представлена серией чисел. Изображение разделено на тысячи и даже миллионы элементов — пикселей, каждый из который является сплошным цветом. Если вы внимательно посмотрите на экран компьютера, вы сможете различить эти блоки. Однако это не получится сделать, если ваш дисплей с очень высоким разрешением, где пиксели невероятно малы! Каждый из этих сплошных цветных пикселей обычно представлен тремя числами — для красного, зеленого и синего (RGB). Например, полностью красный пиксель будет на 100% красным, 0% зеленым и 0% синим.

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

Десятичное число 423 состоит из трех единиц, двух десятков и четырех сотен:

В десятичной системе каждая цифра числа может иметь значение 0, 1, 2, 3, 4, 5, 6, 7, 8 или 9, что дает в общей сложности 10 возможных значений для каждой цифры. Отсюда и название.

Однако истинное значение каждой цифры зависит от ее положения в числе. Двигаясь справа налево, каждая цифра умножается на возрастающую степень 10. Таким образом, множитель для крайней правой позиции равен 10 в степени 0, то есть 1. Двигаясь влево, следующий множитель будет равен 10 в степени. степень 1, то есть 10. Двигаясь снова влево, следующий множитель будет 10 в степени 2, которая равна 100. И так далее.

Это означает, что каждая цифра имеет значение в десять раз больше, чем цифра справа. Число 423 равно следующему:

(0 * 1000) + (4 * 100) + (2 * 10) + (3 * 1) = 423

1	(0 * 1000) + (4 * 100) + (2 * 10) + (3 * 1) = 423

Бинарные, или двоичные числа

Так как вы постоянно оперируете десятичной системой, вы особо не задумываетесь над чтением чисел — процесс кажется естественным. Однако для компьютера десятичная система будет слишком сложной. Компьютеры работают с двоичной системой.

Вы наверняка слышали о бинарной, или двоичной системе. В ней есть только два варианта для цифры — 0 или 1.

Почти все современные компьютеры используют двоичный код, потому что на физическом уровне проще всего обрабатывать только два варианта для каждой цифры. В цифровой электронной схеме наличие электрического напряжения равно 2, а отсутствие — 0. Это двоичная система!

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

Далее показано число 1101 в двоичной системе:

В десятичной системе значения разряда увеличиваются в 10 раз: 1, 10, 100, 1000 и так далее. В двоичной системе они увеличиваются в 2 раза: 1, 2, 4, 8, 16 и так далее. Общее правило — умножать каждую цифру на возрастающую степень базового числа — в данном случае на степень двойки — двигаясь справа налево.

Таким образом, крайняя правая цифра представляет (1 * 2 ^ 0), то есть (1 * 1), то есть 1. Следующая цифра левее представляет (0 * 2 ^ 1), то есть (0 * 2), то есть 0. На приведенной выше схеме вы можете увидеть степень 2 над блоками.

Другими словами, каждая степень двойки либо равна (1), либо (0) не присутствует в качестве компонента двоичного числа. Десятичная версия двоичного числа — это сумма всех степеней двойки, составляющих это число. Итак, двоичное число 1101 равно:

(1 * 8) + (1 * 4) + (0 * 2) + (1 * 1) = 13

1	(1 * 8) + (1 * 4) + (0 * 2) + (1 * 1) = 13

Если вам нужно конвертировать десятичное число 423 в двоичное, требуется просто разбить 423 на его компоненты со степенью 2. В результате вы получите следующее:

(1 * 256) + (1 * 128) + (0 * 64) + (1 * 32) + (0 * 16) + (0 * 8) + (1 * 4) + (1 * 2) + (1 * 1) = 423

1	(1 * 256) + (1 * 128) + (0 * 64) + (1 * 32) + (0 * 16) + (0 * 8) + (1 * 4) + (1 * 2) + (1 * 1) = 423

Как видно в приведенном выше уравнении, полученное двоичное число будет 110100111. Вы можете доказать , что оно равно 423, выполнив математические вычисления. Компьютерным термином для каждой цифры двоичного числа является бит (bit сокращение от «binary digit», или «бинарное число»). Байт составляет восемь бит. Четыре бита — это полубайт, или ниббл.

Ограниченная память компьютера означает, что он обычно может обрабатывать числа до определенной длины. Каждый регистр обычно имеет длину 32 или 64 бита, поэтому мы говорим о 32-битных и 64-битных процессорах.

Следовательно, 32-разрядный процессор может обрабатывать максимальное базовое число 4 294 967 295, которое в двоичной системе равно 111111111111111111111111111111. Это 32 единицы — посчитайте сами!

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

Шестнадцатеричные числа

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

Ввиду отсутствия шестнадцати уникальных цифр, их только 10, используются первые шесть букв английского алфавита от a до f.

Эквиваленты десятичным числам в шестнадцатеричной системе:

a = 10;
b = 11;
c = 12;
d = 13;
e = 14;
f = 15.

Далее представлен пример шестнадцатеричного числа:

Обратите внимание, что шестнадцатеричные числа похожи на слова. Возможно, работать с ними будет веселее.

Теперь значение каждого числа соотносится в 16-ой степени. Как и раньше, вы можете конвертировать данное число в десятичное следующим образом:

(12 * 4096) + (0 * 256) + (13 * 16) + (14 * 1) = 49374

1	(12 * 4096) + (0 * 256) + (13 * 16) + (14 * 1) = 49374

Можно перевести буквы в их десятичные эквиваленты и затем выполнить вычисления как обычно.

Но зачем?

Шестнадцатеричный формат важен, потому что каждая шестнадцатеричная цифра может представлять ровно четыре двоичных цифры. Двоичное число 1111 эквивалентно шестнадцатеричному f. Из этого следует, что вы можете просто объединить двоичные цифры, представляющие каждую шестнадцатеричную цифру, создавая шестнадцатеричное число, которое короче, чем его двоичные или десятичные эквиваленты.

Рассмотрим число c0de из примера выше:

c = 1100
0 = 0000
d = 1101
e = 1110

c0de = 1100 0000 1101 1110

c = 1100

0 = 0000

d = 1101

e = 1110

c0de = 1100 0000 1101 1110

Это оказывается довольно полезным, учитывая, как компьютеры используют длинные 32-битные или 64-битные двоичные числа. Напомним, что самое длинное 32-битное десятичное число — 4 294 967 295. В шестнадцатеричном формате это ffffffff. Это намного компактнее и понятнее.

Как работает код

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

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

К примеру:

Step 1. Load photo from hard drive.
Step 2. Resize photo to 400 pixels wide by 300 pixels high.
Step 3. Apply sepia filter to photo.
Step 4. Print photo.

Step 1. Load photo from hard drive.

Step 2. Resize photo to 400 pixels wide by 300 pixels high.

Step 3. Apply sepia filter to photo.

Step 4. Print photo.

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

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

Каждый язык программирования представляет собой предопределенный высокоуровневый способ выражения данных шагов. Компилятор знает, как интерпретировать код, который вы пишете, и преобразовывать его в инструкции, которые может выполнять CPU.

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

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

Начало работы с Kotlin

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

Для начала попробуем организовать код наиболее оптимальным способом. Приступим!

Задачи для проверки

Перед изучением следующего урока проверьте, как вы усвоили материал о константах и переменных. Можете работать в IntelliJ IDEA.

1. Объявите константу exercises со значением 9 и переменную exercisesSolved со значением 0. Увеличивайте переменную каждый раз при решении задачи (включая эту);

2. Дан следующий код:

age = 16
print(age)
age = 30
print(age)

age = 16

print(age)

age = 30

print(age)

Объявите age для компиляции. Вы будете использовать ключевое слово var или val?

3. Рассмотрите следующий код:

val a: Int = 46
val b: Int = 10

1 2	val a: Int = 46 val b: Int = 10

Выясните, чему равен answer при замене финальной строчки кода свыше на каждую из опций ниже:

// 1
val answer1: Int = (a * 100) + b
// 2
val answer2: Int = (a * 100) + (b * 100)  
// 3
val answer3: Int = (a * 100) + (b / 10)

// 1

val answer1: Int = (a * 100) + b

// 2

val answer2: Int = (a * 100) + (b * 100)

// 3

val answer3: Int = (a * 100) + (b / 10)

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

5 * 3 - 4 / 2 * 2

1	5 * 3 - 4 / 2 * 2

5. Объявите две константы а и b типа Double и присвойте обеим значения. Вычислите среднее арифметическое чисел a и b и поместите результат в константу под названием average;

6. Температуру в °C можно конвертировать в °F через умножение на 1.8 и последующее увеличение на 32. Сделайте обратное: конвертируйте температуру из °F в °С. Объявите константу под названием fahrenheit типа Double и присвойте им значение. Посчитайте соответствующую температуру в °С и поместите результат в константу под названием celcius;

7. Предположим, что клетки на шахматной доске пронумерованы слева направо, сверху вниз, причем 0 — верхний левый квадрат, а 63 — нижний правый квадрат. Строки пронумерованы сверху вниз от 0 до 7. Столбцы нумеруются слева направо от 0 до 7. Объявите константу position и присвойте ей значение от 0 до 63. Вычислите соответствующие номера строк и столбцов и поместите результаты в константах row (строка) и column (столбец);

8. Круг состоит из 2? радиан, что соответствует 360 градусам. Объявите константу degrees типа Double и присвойте ей начальное значение. Вычислите соответствующий угол в радианах и сохраните результат в константе под названием radians;

9. Объявите четыре константы с названиями x1, y1, x2 и y2 типа Double. Эти константы представляют собой двумерные координаты двух точек. Вычислите расстояние между этими двумя точками и сохраните результат в виде константы distance.

Решения задач

import kotlin.math.PI
import kotlin.math.sqrt


fun main() {
	// Решение задачи №1
	val exercises: Int = 9
	var exercisesSolved: Int = 0
	exercisesSolved += 1

	// Решение задачи №2
	var age: Int  // здесь var, не val
	age = 16
	print(age)
	age = 30
	print(age)
	exercisesSolved += 1

	// Решение задачи №3
	val a: Int = 46
	val b: Int = 10
	val answer1: Int = (a * 100) + b
	val answer2: Int = (a * 100) + (b * 100)
	val answer3: Int = (a * 100) + (b / 10)
	exercisesSolved += 1

	// Решение задачи №4
	(5 * 3) - ((4 / 2) * 2)
	exercisesSolved += 1

	// Решение задачи №5
	val x: Double = 7.5
	val y: Double = 5.0
	val average: Double = (x + y) / 2
	exercisesSolved += 1

	// Решение задачи №6
	val fahrenheit: Double = 121.0
	val celcius: Double = (fahrenheit - 32) / 1.8
	exercisesSolved += 1

	// Решение задачи №7
	val position: Int = 54
	val row: Int = position / 8
	val column: Int = position % 8
	exercisesSolved += 1

	// Решение задачи №8
	val degrees: Double = 360.0
	val radians: Double = (degrees / 180) * PI
	exercisesSolved += 1

	// Решение задачи №9
	val x1: Double = 1.0
	val y1: Double = 1.0
	val x2: Double = 3.0
	val y2: Double = 3.0
	val dx: Double = x2 - x1
	val dy: Double = y2 - y1
	val distance: Double = sqrt(dx * dx + dy * dy)
	exercisesSolved += 1
}

import kotlin.math.PI

import kotlin.math.sqrt

fun main() {

// Решение задачи №1

val exercises: Int = 9

var exercisesSolved: Int = 0

exercisesSolved += 1

// Решение задачи №2

var age: Int // здесь var, не val

age = 16

print(age)

age = 30

print(age)

exercisesSolved += 1

// Решение задачи №3

val a: Int = 46

val b: Int = 10

val answer1: Int = (a * 100) + b

val answer2: Int = (a * 100) + (b * 100)

val answer3: Int = (a * 100) + (b / 10)

exercisesSolved += 1

// Решение задачи №4

(5 * 3) - ((4 / 2) * 2)

exercisesSolved += 1

// Решение задачи №5

val x: Double = 7.5

val y: Double = 5.0

val average: Double = (x + y) / 2

exercisesSolved += 1

// Решение задачи №6

val fahrenheit: Double = 121.0

val celcius: Double = (fahrenheit - 32) / 1.8

exercisesSolved += 1

// Решение задачи №7

val position: Int = 54

val row: Int = position / 8

val column: Int = position % 8

exercisesSolved += 1

// Решение задачи №8

val degrees: Double = 360.0

val radians: Double = (degrees / 180) * PI

exercisesSolved += 1

// Решение задачи №9

val x1: Double = 1.0

val y1: Double = 1.0

val x2: Double = 3.0

val y2: Double = 3.0

val dx: Double = x2 - x1

val dy: Double = y2 - y1

val distance: Double = sqrt(dx * dx + dy * dy)

exercisesSolved += 1

}

Ключевые аспекты программирования на Kotlin

На базовом уровне компьютеры выполняют обычные математические операции;
Язык программирования дает возможность писать код, который компилятор конвертирует в инструкции, которые CPU может выполнить. Код на Kotlin на JVM сначала конвертируется в байт-код;
Компьютеры оперируют числам в двоичной, или бинарной системе;
Комментарии в коде выделяются знаками // в начале строки. Для многострочных комментариев используется /* и */.
Комментарии в коде можно использовать для документации кода;
Для вывода результата в консоль используется команда println;
В Kotlin используются следующие арифметические операторы:

Java

Сложение: + Вычитание: - Умножение: * Деление: / Остаток: %

1
2
3
4
5

Сложение: +
Вычитание: -
Умножение: *
Деление: /
Остаток: %
Константы и переменные являются названиями данных;
Константу изменить нельзя, а переменную можно;
Старайтесь давать переменным и константам понятные названия, чтобы с ними было удобнее работать;

Операторы осуществляют арифметические действия и затем присваивают результат обратно переменной:

Сложение и присваивание: +=
Вычитание и присваивание: -=
Умножение и присваивание: *=
Деление и присваивание: /=

Сложение и присваивание: +=

Вычитание и присваивание: -=

Умножение и присваивание: *=

Деление и присваивание: /=

Что дальше?

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