feat(30-variables): перенос теории из Python и адаптация под java

modules/30-variables/10-definition/ru/README.md

@@ -1,45 +1,125 @@
-Представьте себе задачу — нужно напечатать на экран фразу *Father!* два раза. Эту задачу можно решить в лоб:
+Представьте, что нужно напечатать фразу *Father!* два раза:
 
 ```java
-System.out.println("Father!"); // => Father!
-System.out.println("Father!"); // => Father!
+System.out.println("Father!");
+System.out.println("Father!");
 ```
 
-В простейшем случае так и стоит поступить, но если фраза *Father!* начнет использоваться чаще, да еще и в разных частях программы, то придется ее везде повторять. Проблемы с таким подходом начнутся тогда, когда понадобится изменить нашу фразу, а такое происходит довольно часто. Нам придется найти все места, где использовалась фраза *Father!* и выполнить необходимую замену. А можно поступить по-другому. Вместо копирования нашего выражения, достаточно создать переменную с этой фразой:
+Такой способ подойдет, если фраза встречается всего пару раз. Но что, если она будет использоваться часто, в разных частях программы? Тогда придется копировать одно и то же выражение снова и снова.
+
+А что будет, если фразу нужно изменить, например заменить *Father!* на *Mother!*? Придется искать и исправлять все вхождения вручную. Это неудобно и приводит к ошибкам.
+
+## Переменные
+
+Чтобы не дублировать одну и ту же строку, ее можно сохранить в переменной и распечатывать ее содержимое:
 
 ```java
-// greeting – переводится как приветствие
-// var – нужен только при определении переменной
 var greeting = "Father!";
+
 System.out.println(greeting);
 System.out.println(greeting);
 ```
 
-В строчке `var greeting = "Father!"` - происходит присваивание значения `"Father!"` переменной с именем `greeting`.
-
-Когда переменная создана, можно начать ее использовать. Она подставляется в те места, где раньше стояла наша фраза. Во время выполнения кода в строке `System.out.println(greeting)` вместо переменной подставляется ее содержимое, а затем выполняется код. В результате вывод нашей программы будет таким:
+Результат:
 
 ```text
 Father!
 Father!
 ```
 
-Для имени переменной используется любой набор допустимых символов, к которым относятся буквы английского алфавита, цифры, символ нижнего подчеркивания `_`. При этом цифру нельзя ставить в начале. Имена переменных регистрозависимы, то есть имя `hello` и имя `heLLo` - это два разных имени и две переменные. Ниже пример с двумя разными переменными:
+**Переменная** представляет собой имя, за которым хранится значение. В этом примере мы создали переменную с именем `greeting` и записали в нее строку `"Father!"`.
+
+```text
+var greeting = "Father!";
+
+Переменная       Значение
+┌──────────┐     ┌──────────┐
+│ greeting │ ──→ │ "Father!"│
+└──────────┘     └──────────┘
+```
+
+Строчка `var greeting = "Father!"` читается так: "возьми значение `"Father!"` и присвой его переменной с именем `greeting`". Знак `=` здесь работает как оператор присваивания, а не обозначение равенства как в математике. Он кладет значение в переменную.
+
+Ключевое слово `var` сообщает компилятору, что мы создаем новую переменную. Java сама определяет тип переменной по тому значению, которое мы в нее записали. Раз справа стоит строка `"Father!"`, то и переменная `greeting` становится строковой.
+
+Когда мы пишем `System.out.println(greeting)`, программа подставляет вместо имени `greeting` то значение, которое в ней хранится. В результате на экран выводится строка `Father!`.
+
+```text
+System.out.println(greeting);
+                   |
+                   v
+System.out.println("Father!");
+```
+
+## Типы переменных
+
+В Java у каждой переменной есть тип. Тип говорит, какие данные внутри переменной хранятся. Целое число, дробное число или строка задают разные типы:
+
+```java
+var age = 25;       // целое число
+var price = 9.99;   // дробное число
+var name = "Tom";   // строка
+```
+
+В примерах выше тип определяется автоматически по значению справа от знака `=`. Можно записать тип и явно, тогда вместо `var` указывают название типа:
+
+```java
+int age = 25;
+double price = 9.99;
+String name = "Tom";
+```
+
+Оба способа создают переменную с одинаковым результатом. Запись через `var` короче, поэтому в примерах мы будем использовать ее.
+
+## Имена переменных
+
+Имена переменных придумывает сам программист. В Java можно использовать:
+
+- Латинские буквы (a-z, A-Z),
+- цифры (но не в начале),
+- нижнее подчеркивание `_`.
+
+Примеры допустимых имен: `greeting`, `name1`, `helloWorld`. Java различает строчные и заглавные буквы. Переменные `greeting`, `Greeting` и `GREETING` будут тремя разными переменными.
+
+## Переменные и литералы
+
+В коде важно различать, где мы используем переменную, а где записываем значение напрямую. Это особенно заметно на примере с `System.out.println()`:
+
+```java
+var greeting = "Mother!";
+System.out.println(greeting);   // => Mother!
+System.out.println("greeting"); // => greeting
+```
+
+В первом случае используется **переменная** `greeting`, и программа подставляет ее значение. Во втором случае `"greeting"` заключено в кавычки, поэтому это **строковый литерал**, то есть готовое значение, написанное прямо в коде. Хотя мы видим слово `greeting` в обоих случаях, с точки зрения компилятора это разные вещи.
+
+Литералы представляют собой данные, записанные явно (например, `"Hello"`, `42`, `3.14`). Идентификаторы работают как имена переменных и методов (например, `greeting`, `println`), которые указывают на уже существующие значения или команды.
+
+## Несколько переменных в программе
+
+В одной программе можно создать сколько угодно переменных. Каждая хранит свои данные и не мешает другим:
 
 ```java
 var greeting1 = "Father!";
 System.out.println(greeting1);
 System.out.println(greeting1);
+
 var greeting2 = "Mother!";
 System.out.println(greeting2);
 System.out.println(greeting2);
 ```
 
+Результат:
+
 ```text
 Father!
 Father!
 Mother!
 Mother!
 ```
 
-Для удобства анализа программы переменные принято создавать как можно ближе к тому месту, где они используются.
+Количество переменных зависит от логики программы. Чем сложнее задача, тем больше промежуточных данных приходится где-то хранить.
+
+## Где создавать переменные
+
+Программисты стараются создавать переменные ближе к месту, где они используются. Это делает код более читаемым. Особенно это важно в больших программах, где переменных могут быть десятки и сотни тысяч.

modules/30-variables/10-definition/ru/data.yml

@@ -4,3 +4,8 @@ tips:
   - >
     [Именование в
     программировании](https://ru.hexlet.io/blog/posts/naming-in-programming?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
+definitions:
+  - name: Переменная
+    description: >-
+      способ сохранить информацию и дать ей имя для последующего использования в
+      коде.

modules/30-variables/12-change/ru/README.md

@@ -1,24 +1,50 @@
-Само слово «переменная» говорит, что ее можно менять. И действительно, с течением времени внутри программы, значения переменных могут изменяться:
+Само слово "переменная" подсказывает, что ее значение может меняться. Это одна из главных причин, почему переменные вообще существуют.
+
+Вот пример:
 
 ```java
 var greeting = "Father!";
-System.out.println(greeting);
-System.out.println(greeting);
-// var уже не используется, так как переменная была определена выше
+System.out.println(greeting); // => Father!
+
+// var уже не используется, переменная определена выше
 greeting = "Mother!";
-System.out.println(greeting);
-System.out.println(greeting);
+System.out.println(greeting); // => Mother!
 ```
 
-Java — статически типизированный язык. Это значит, что тип переменной задается при определении и больше не меняется.
+Здесь мы сначала записали в переменную одну строку (*Father!*), потом другую (*Mother!*). Имя переменной не изменилось, но значение внутри стало другим. Ключевое слово `var` нужно только при создании переменной. При изменении значения его уже не пишут.
+
+```text
+До:    greeting ──→ "Father!"
+После: greeting ──→ "Mother!"
+```
+
+## Зачем менять значение
+
+В реальных программах переменные меняются постоянно. Вот несколько причин:
+
+- Программа реагирует на действия пользователя. Например, пока вы вводите данные в форму на сайте, переменные, которые эти данные содержат, постоянно меняются.
+- Промежуточные результаты. Часто данные проходят через серию преобразований, и на каждом этапе переменная обновляется новым значением. Подобный механизм есть даже в калькуляторах, когда промежуточные значения сохраняются с помощью клавиш `m+` или `m-`.
+- Хранение состояния. Если вы пишете игру, то положение персонажа, его здоровье, счет и текущий уровень будут переменными, которые постоянно меняются.
 
-В примере выше мы присвоили строку при создании переменной. Компилятор запоминает тип и проверяет все последующие изменения переменной. Если попробовать этой же переменной присвоить число, то мы получим следующую ошибку:
+## Тип переменной не меняется
+
+Java — статически типизированный язык. Тип переменной задается при создании и больше не меняется. В примере выше мы записали строку при создании переменной. Компилятор запоминает тип и проверяет все последующие изменения.
+
+Если попробовать той же переменной присвоить число, мы получим ошибку:
 
 ```java
 greeting = 5;
-# Error:
-# incompatible types: int cannot be converted to java.lang.String
-# несовместимые типы: число не может быть превращено в строку
+// Error:
+// incompatible types: int cannot be converted to java.lang.String
+// несовместимые типы: число не может быть превращено в строку
 ```
 
-Компилятор делает такую проверку без запуска кода на выполнение, именно поэтому такой вид типизации называют **статическим**. В JavaScript, Ruby, PHP, Python и других динамических языках подобное поведение не является ошибкой, переменная может легко изменить свой тип в процессе работы.
+Компилятор делает такую проверку без запуска кода на выполнение. Именно поэтому такой вид типизации называют **статическим**. В JavaScript, Ruby, PHP, Python и других динамических языках подобное поведение не считается ошибкой, и переменная может изменить свой тип в процессе работы.
+
+## Обратная сторона изменчивости
+
+Переменные дают способ хранить данные, которые меняются по ходу выполнения программы. Благодаря этому можно писать программы, которые ведут себя по-разному в зависимости от условий, действий пользователя или результатов вычислений.
+
+Но у изменчивости есть и обратная сторона. Иногда сложно понять, что именно записано в переменную в конкретный момент времени. Разработчику приходится отслеживать, где и как она изменилась, особенно если код длинный.
+
+Именно это делают во время отладки. Разработчик разбирается, почему программа работает иначе, чем задумано. Проверяют значения переменных, отслеживают порядок выполнения кода, ищут, где что-то пошло не так.

modules/30-variables/12-change/ru/data.yml

@@ -1,2 +1,8 @@
 ---
 name: Изменение переменной
+tips: []
+definitions:
+  - name: Переменная
+    description: >-
+      способ сохранить информацию и дать ей имя для последующего использования в
+      коде.