diff --git a/modules/30-variables/10-definition/ru/README.md b/modules/30-variables/10-definition/ru/README.md index 213b2fc..ae494ac 100644 --- a/modules/30-variables/10-definition/ru/README.md +++ b/modules/30-variables/10-definition/ru/README.md @@ -1,40 +1,116 @@ -Представьте себе задачу — нужно напечатать на экран фразу *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! @@ -42,4 +118,8 @@ Mother! Mother! ``` -Для удобства анализа программы переменные принято создавать как можно ближе к тому месту, где они используются. +Количество переменных зависит от логики программы. Чем сложнее задача, тем больше промежуточных данных приходится где-то хранить. + +## Где создавать переменные + +Программисты стараются создавать переменные ближе к месту, где они используются. Это делает код более читаемым. Особенно это важно в больших программах, где переменных могут быть десятки и сотни тысяч. diff --git a/modules/30-variables/10-definition/ru/data.yml b/modules/30-variables/10-definition/ru/data.yml index 713f5d8..783a00b 100644 --- a/modules/30-variables/10-definition/ru/data.yml +++ b/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: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/12-change/ru/README.md b/modules/30-variables/12-change/ru/README.md index 4690d4e..62697ce 100644 --- a/modules/30-variables/12-change/ru/README.md +++ b/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 и других динамических языках подобное поведение не считается ошибкой, и переменная может изменить свой тип в процессе работы. + +## Обратная сторона изменчивости + +Переменные дают способ хранить данные, которые меняются по ходу выполнения программы. Благодаря этому можно писать программы, которые ведут себя по-разному в зависимости от условий, действий пользователя или результатов вычислений. + +Но у изменчивости есть и обратная сторона. Иногда сложно понять, что именно записано в переменную в конкретный момент времени. Разработчику приходится отслеживать, где и как она изменилась, особенно если код длинный. + +Именно это делают во время отладки. Разработчик разбирается, почему программа работает иначе, чем задумано. Проверяют значения переменных, отслеживают порядок выполнения кода, ищут, где что-то пошло не так. diff --git a/modules/30-variables/12-change/ru/data.yml b/modules/30-variables/12-change/ru/data.yml index 87e50d6..15da5a7 100644 --- a/modules/30-variables/12-change/ru/data.yml +++ b/modules/30-variables/12-change/ru/data.yml @@ -1,2 +1,8 @@ --- name: Изменение переменной +tips: [] +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/13-variables-naming/ru/README.md b/modules/30-variables/13-variables-naming/ru/README.md index 30452ce..a7c5a7f 100644 --- a/modules/30-variables/13-variables-naming/ru/README.md +++ b/modules/30-variables/13-variables-naming/ru/README.md @@ -1,15 +1,38 @@ -Представим себе, что программа из прошлого урока выглядит так: +Представьте, что у нас есть такая программа: ```java var x = "Father!"; System.out.println(x); -System.out.println(x); ``` -Она по-прежнему работает, но в ней изменилось имя переменной на `x`. Компьютеру без разницы, как мы называем переменные. Названия важны для программистов, ведь мы гораздо чаще читаем код, чем пишем. Причем не свой, а написанный другими людьми. От качества и понятности имен переменных зависит половина успеха в анализе кода. +С технической точки зрения все работает. Но здесь используется переменная с названием `x`. Плохие имена мешают читать и понимать код. Вот несколько примеров неудачных переменных: + +```java +var a = "John"; +var n = 42; +var ddr = "New York"; +``` + +Что это за переменные? Что в них хранится? Чтобы это понять, нужно читать весь остальной код и догадываться по контексту. + +Компьютеру все равно, как называется переменная. Для него `x`, `abc`, `message` или `elephantInTheRoom` будут просто метками для хранения данных. Людям важно другое. Программисты читают код гораздо чаще, чем пишут, причем не только свой, но и написанный другими людьми. Поэтому имена переменных становятся важной частью общения через код. + +## Хорошие примеры + +```java +var userName = "Arya Stark"; +var unpaidOrdersCount = 3; +var maxAttempts = 5; +``` + +Хорошее имя переменной помогает понять, что делает программа, без необходимости вчитываться в каждую строчку. Особенно важно давать такие имена, смысл которых понятен без контекста, без чтения всего кода вокруг. + +Вот несколько советов: -Лучше посидеть и придумать название, которое описывает суть переменной, чем назвать ее как попало, а в будущем переделывать. Постарайтесь давать им такие имена, чтобы они были максимально понятны без контекста, без изучения окружающего кода. +- Используйте английский язык. Это международный стандарт. Лучше писать `ordersCount` вместо `kolvoZakazov`. Если с английским пока сложно, используйте переводчик, это нормально. Со временем станет проще. +- Старайтесь, чтобы имя отражало смысл переменной. Пусть оно будет чуть длиннее, но понятное. +- Не бойтесь тратить время на подбор хорошего названия. Это инвестиция в читаемость и поддержку кода. -Существует общепринятое правило: не используйте транслит для имен, только английский язык. Если вы испытываете сложности с английским, то пользуйтесь переводчиком. Со временем, копаясь в чужом коде, вы сформируете правильные понятия для именования. +Среди программистов даже есть шутка: "Одними из самых трудных задач в программировании остаются инвалидация кеша и придумывание имен переменным". Иногда придумать подходящее имя действительно сложно. Вот пример: как бы вы назвали переменную, в которой хранится количество неоплаченных заказов от клиентов с задолженностью за предыдущий квартал? -Среди разработчиков есть шутка: «самое сложное в программировании — названия переменных и инвалидация кеша». Придумывать названия и правда сложно. Как бы вы назвали переменную, в которой хранится «количество неоплаченных заказов от клиентов, имеющих задолженность в предыдущем квартале»? +А теперь небольшое упражнение. Придумайте название для переменной, в которой будет храниться "количество братьев и сестер короля". Запишите его в блокноте или отправьте себе на почту. Только название, без объяснений. Через какое-то время посмотрите на него снова и проверьте, понятен ли смысл переменной по одному имени. diff --git a/modules/30-variables/13-variables-naming/ru/data.yml b/modules/30-variables/13-variables-naming/ru/data.yml index 99148c5..b19c1c4 100644 --- a/modules/30-variables/13-variables-naming/ru/data.yml +++ b/modules/30-variables/13-variables-naming/ru/data.yml @@ -1,2 +1,14 @@ --- name: Выбор имени переменной +tips: + - > + [Именование в + программировании](https://ru.hexlet.io/blog/posts/naming-in-programming?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson) + - > + [Ошибки в именовании + переменных](https://ru.hexlet.io/blog/posts/naming-errors-1?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson) +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/15-variable-expressions/ru/data.yml b/modules/30-variables/15-variable-expressions/ru/data.yml index 22901e1..ad39410 100644 --- a/modules/30-variables/15-variable-expressions/ru/data.yml +++ b/modules/30-variables/15-variable-expressions/ru/data.yml @@ -4,3 +4,8 @@ tips: - > Для перевода строчки можно использовать `\n` между выводом долларов и рублей, либо нужное количество раз использовать метод `println()`. +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/18-variables-concatenation/ru/README.md b/modules/30-variables/18-variables-concatenation/ru/README.md index e646cdb..5340aca 100644 --- a/modules/30-variables/18-variables-concatenation/ru/README.md +++ b/modules/30-variables/18-variables-concatenation/ru/README.md @@ -1,11 +1,17 @@ -Переменные и конкатенацию можно объединять. Синтаксически ничего не меняется, ведь мы умеем конкатенировать — то есть склеивать две строки: +Строки можно склеивать напрямую с помощью конкатенации. Теперь сделаем то же самое, но с переменными. Синтаксис остается тем же, программа подставляет значения переменных. + +## Склеиваем две строки напрямую ```java var what = "Kings" + "road"; System.out.println(what); // => Kingsroad ``` -Значит, мы сумеем конкатенировать строку и одну переменную, в которой записана строка: +Здесь две строки соединяются в одну. Так работает конкатенация: оператор `+` складывает строки и создает новую строку. + +## Склеиваем строку и переменную + +Если в переменной `first` лежит строка `"Kings"`, мы можем склеить ее с другой строкой: ```java var first = "Kings"; @@ -13,11 +19,65 @@ var what = first + "road"; System.out.println(what); // => Kingsroad ``` -Можно даже конкатенировать две переменные, в которых записаны строки: +Java подставит значение переменной, выполнит операцию и создаст итоговую строку. + +## Склеиваем две переменные + +Точно так же можно объединить значения двух переменных, если обе содержат строки: ```java var first = "Kings"; var last = "road"; var what = first + last; -System.out.println(what); //=> Kingsroad +System.out.println(what); // => Kingsroad +``` + +Можно добавлять и пробелы: + +```java +var first = "Kings"; +var last = "road"; +var full = first + " " + last; +System.out.println(full); // => Kings road ``` + +```text +first = "Kings" +last = "road" + +first + " " + last +└─┬──┘ └─┬─┘ +"Kings" + " " + "road" +└────────┬─────────┘ + "Kings road" +``` + +## А что если переменная содержит число + +В Java оператор `+` умеет соединять строку с числом. Если хотя бы один операнд является строкой, число автоматически превращается в строку, и получается общая строка: + +```java +var age = 42; +System.out.println("Age: " + age); // => Age: 42 +``` + +Java видит строку `"Age: "` слева, поэтому переводит число `42` в строку `"42"` и склеивает их вместе. То же самое работает и с результатами вычислений: + +```java +var price = 50 * 1.25 * 6.91; // => 431.875 +System.out.println("Price in yuans: " + price); +// => Price in yuans: 431.875 +``` + +Здесь Java сначала вычисляет выражение, получает число `431.875`, затем превращает его в строку и приклеивает к тексту слева. + +## Порядок вычисления важен + +Когда в одном выражении встречаются числа и строки, результат зависит от порядка операций. Слева направо `+` сначала складывает два числа, и только потом приклеивает их к строке: + +```java +System.out.println("Sum: " + 2 + 3); // => Sum: 23 +System.out.println("Sum: " + (2 + 3)); // => Sum: 5 +``` + +В первой строке `"Sum: " + 2` уже превращается в строку `"Sum: 2"`, а затем к ней приклеивается `3`, и получается `"Sum: 23"`. Во второй строке скобки заставляют сначала сложить `2 + 3`, получить число `5`, и только потом склеить его со строкой. diff --git a/modules/30-variables/18-variables-concatenation/ru/data.yml b/modules/30-variables/18-variables-concatenation/ru/data.yml index 53c1018..08199b3 100644 --- a/modules/30-variables/18-variables-concatenation/ru/data.yml +++ b/modules/30-variables/18-variables-concatenation/ru/data.yml @@ -6,4 +6,10 @@ tips: чтобы получить такой двухстрочный вывод тела письма. - > Помните, что можно создать строку, которая содержит только управляющую - последовательность `\n`. + последовательность `\n`. Вы можете конкатенировать эту строку с переменными + для правильного форматирования текста. +definitions: + - name: Конкатенация + description: > + операция соединения двух строк. Например, `System.out.println("King's " + + "Landing")` diff --git a/modules/30-variables/19-naming-style/ru/README.md b/modules/30-variables/19-naming-style/ru/README.md index bd7c382..f869dd8 100644 --- a/modules/30-variables/19-naming-style/ru/README.md +++ b/modules/30-variables/19-naming-style/ru/README.md @@ -1,18 +1,41 @@ +`greeting` служит примером простого и понятного имени переменной. Но часто имен вроде `name`, `email` или `price` оказывается недостаточно. Например, нужно описать имя пользователя, общее количество заказов, максимальную длину сообщения. Такие имена уже состоят из нескольких слов. Как в таком случае будет выглядеть имя переменной? -`greeting` — пример простого имени, но не все имена так просты. Довольно часто они составные, то есть включают в себя несколько слов. Например, «имя пользователя». В разных языках применяются разные стили кодирования, и имя переменной будет отличаться. +В разных языках программирования используются разные стили именования. От этого зависит, как будет выглядеть составное имя. Например, вот как можно записать переменную, которая хранит максимальную длину сообщения: -В именовании переменных можно выделить четыре основных подхода, которые иногда комбинируют друг с другом. Все эти подходы проявляют себя, когда имя переменной состоит из нескольких слов: +1. `maxmessagelength` +1. `maxMessageLength` +1. `max-message-length` +1. `max_message_length` -* kebab-case — составные части переменной разделяются дефисом (`my-super-var`) -* snake_case — для разделения используется подчеркивание (`my_super_var`) -* CamelCase — каждое слово в переменной пишется с заглавной буквы (`MySuperVar`) -* lowerCamelCase — каждое слово в переменной пишется с заглавной буквы, кроме первого (`mySuperVar`) +## Основные стили -В Java используется CamelCase и его вариация lowerCamelCase, при котором первая буква первого слова — строчная. +В именовании переменных можно выделить четыре основных подхода. Все они проявляют себя, когда имя состоит из нескольких слов: -Именно lowerCamelCase применяется для переменных. Это значит, что имена соединяются друг с другом, при этом все имена кроме первого становятся с заглавной буквы: `userName`. С тремя словами это выглядит так: `mySuperVariable`. +- kebab-case: слова разделяются дефисом, например `max-message-length`. -Посмотрим, как это выглядит в коде: + В Java не работает, потому что дефис воспринимается как оператор вычитания. + +- snake_case: слова разделяются подчеркиванием, например `max_message_length`. + +- CamelCase (или UpperCamelCase): каждое слово с заглавной буквы без разделителей, например `MaxMessageLength`. + +- lowerCamelCase: то же самое, но первое слово начинается со строчной буквы, например `maxMessageLength`. + +## Как правильно в Java + +Для имен переменных в Java принят стиль lowerCamelCase. Слова соединяются друг с другом, и каждое слово кроме первого пишется с заглавной буквы: + +```java +var userName = "Daenerys"; +var maxLength = 280; +var totalOrdersCount = 17; +``` + +- Первое слово начинается со строчной буквы +- Каждое следующее слово начинается с заглавной буквы +- Разделителей между словами нет + +Посмотрим на это в коде: ```java var firstName = "John"; @@ -21,3 +44,9 @@ System.out.println(firstName); // => John var playerNumber = 24; System.out.println(playerNumber); // => 24 ``` + +## Как не надо + +Не стоит включать тип данных в имя переменной. Такие имена хуже читаются и быстро устаревают. Например, `userNameString` или `messagesNumber` описывают не смысл переменной, а ее техническую реализацию. + +Имя должно отвечать на вопрос "что хранится?", а не "какого это типа?". Поэтому лучше писать `userName` вместо `userNameString` и `messagesCount` вместо `messagesNumber`. diff --git a/modules/30-variables/19-naming-style/ru/data.yml b/modules/30-variables/19-naming-style/ru/data.yml index c8364ef..e6f5e00 100644 --- a/modules/30-variables/19-naming-style/ru/data.yml +++ b/modules/30-variables/19-naming-style/ru/data.yml @@ -1,6 +1,8 @@ --- name: Именование переменных -tips: [] +tips: + - | + [Snake case](https://ru.wikipedia.org/wiki/Snake_case) definitions: - name: Стандарт кодирования - description: Набор синтаксических и стилистических правил написания кода. + description: набор синтаксических и стилистических правил написания кода. diff --git a/modules/30-variables/23-constants/ru/README.md b/modules/30-variables/23-constants/ru/README.md index ceffe88..4f5b7e4 100644 --- a/modules/30-variables/23-constants/ru/README.md +++ b/modules/30-variables/23-constants/ru/README.md @@ -1,12 +1,58 @@ -Некоторые данные никогда не меняются — например, математические постоянные. Возьмем число *π*. Приближенно оно всегда равно *3.14* и не может измениться. +Иногда в программе встречаются значения, которые никогда не должны меняться. Например: -Для обращения к подобным данным в Java принято использовать константы: +- Математическая константа π (пи). +- Курс доллара на определенную дату. +- Фиксированная комиссия сервиса. + +Такие значения называются константами, и их принято отличать от обычных переменных, чтобы не возникало желания их менять. + +## Пример: число π + +Возьмем число π. Приближенно оно всегда равно *3.14* и не может измениться: ```java final var pi = 3.14; -System.out.println(pi); // 3.14 +System.out.println(pi); // => 3.14 ``` -В отличие от переменных, в начале определения константы используют ключевое слово `final`. Оно сообщает компилятору запрет на изменение. Любая попытка поменять константу приведет к ошибке. +Здесь `pi` будет константой, которая хранит значение числа π. Смысл константы в том, что ее значение не меняется в ходе работы программы. + +## Чем константа отличается от переменной + +Концепт констант распространен в большинстве языков программирования. В Java перед определением константы ставят ключевое слово `final`. Оно сообщает компилятору запрет на изменение. Любая попытка поменять константу приведет к ошибке: + +```java +final var pi = 3.14; +pi = 3.14159; +// Error: +// cannot assign a value to final variable pi +// нельзя присвоить значение константе pi +``` + +Компилятор находит такую ошибку без запуска кода. В этом сила `final`: язык сам следит за тем, чтобы значение оставалось неизменным. + +## Как оформляются константы + +Константа, как и переменная, может использоваться в любом выражении. Единственное ограничение в том, что ее нельзя изменить. + +Когда константа описана на уровне всего класса и доступна всей программе, в Java принят особый стиль написания имени: + +- Все буквы заглавные +- Слова разделяются символом подчеркивания `_` +- Стиль называется UPPER_SNAKE_CASE (еще его называют SCREAMING_SNAKE_CASE) + +Такие константы обычно объявляют с `static final`: + +```java +static final double PI = 3.14; +static final int MAX_USERS = 100; +static final int DEFAULT_TIMEOUT = 30; +``` + +По имени сразу видно, что перед нами константа, а не обычная переменная. Заглавные буквы выделяют ее в коде. + +## Зачем нужны константы + +Константы делают код понятнее и безопаснее. Они помогают сразу увидеть, какие значения в программе считаются фиксированными и не должны меняться. Это особенно важно при работе с математическими и физическими постоянными, настройками по умолчанию или фиксированными лимитами. -Константа, как и переменная, может использоваться в любом выражении. Единственное ограничение — константу нельзя изменить, что звучит довольно логично. +Использование констант снижает риск ошибок. По ключевому слову `final` компилятор не даст случайно изменить значение. Кроме того, если значение все же нужно поменять, например в настройках, достаточно поправить его в одном месте, и изменение подхватится во всей программе. diff --git a/modules/30-variables/23-constants/ru/data.yml b/modules/30-variables/23-constants/ru/data.yml index 1786fc2..c4a1647 100644 --- a/modules/30-variables/23-constants/ru/data.yml +++ b/modules/30-variables/23-constants/ru/data.yml @@ -1,2 +1,8 @@ --- name: Константы +tips: [] +definitions: + - name: Константа + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде; константы нельзя изменять, в отличие от переменных.