diff --git a/modules/45-logic/10-bool-type/ru/README.md b/modules/45-logic/10-bool-type/ru/README.md index 3b1a714..f0d21e0 100644 --- a/modules/45-logic/10-bool-type/ru/README.md +++ b/modules/45-logic/10-bool-type/ru/README.md @@ -1,22 +1,24 @@ -Кроме арифметических операций, из школьной математики нам известны еще и операции сравнения, например: +Кроме арифметических операций, из школьной математики нам известны еще и операции сравнения, например `5 > 4` или `3 < 1`. Они есть и в программировании. Сравнения часто применяются в реальных задачах, связанных с числами. Когда мы оформляем покупку в интернет-магазине, система проверяет, хватает ли у пользователя денег на счете. Если сумма на счете больше или равна цене товара, заказ подтверждается. При нехватке средств появляется сообщение об ошибке. -```text -5 > 4 -``` +## Сравнение в программировании -Это звучит как вопрос: «Пять больше четырех?». В данном случае, ответ «да». В других случаях, ответом может быть «нет», например, для такого выражения: +Начнем с примера, в котором сравниваются два числа. Результат сравнения выводим на экран: -```text -3 < 1 +```java +System.out.println(5 > 4); // => true +System.out.println(4 > 4); // => false ``` -Операции сравнения не имеют привязки к числам. Сравнивать можно практически что угодно — например, строки. Когда мы входим на какой-то сайт, внутри происходит сравнение введенного логина и пароля с теми, какие есть в базе. Если совпадение есть, то происходит авторизация. +Результат сравнения — это значение типа `boolean`. У этого типа всего два возможных варианта, `true` и `false`. Это специальные значения языка, их можно выводить напрямую: -Языки программирования адаптировали все математические операции сравнения практически в неизменном виде. Единственное серьезное отличие – **операторы равенства и неравенства**. +```java +System.out.println(true); // => true +System.out.println(false); // => false +``` -В математике для этого используется обычное равно `=`, но в программировании такое встречается нечасто. Во многих языках символ `=` используется для присваивания значений переменным, поэтому для сравнения взяли `==`. +На практике их редко используют так напрямую, но на их основе строится логика поведения программы. Мы сталкиваемся с этим каждый день, когда вводим пинкоды и пароли, когда выполняем действия с разными возможными исходами. Все эти варианты прописаны внутри программы в виде условных выражений. Программа рассуждает примерно так: *если так, делай раз, если по-другому, делай два*. -Список операций сравнения в Java: +В Java доступны следующие операции сравнения: * `<` — меньше * `<=` — меньше или равно @@ -25,40 +27,52 @@ * `==` — равно * `!=` — не равно -Посмотрим на пару примеров логических операций: +Языки программирования адаптировали все математические операции сравнения в неизменном виде, кроме операторов равенства и неравенства. В математике для равенства используется обычное `=`, но в программировании символ `=` присваивает переменным значения. Поэтому в Java сравнивают с помощью `==`. Несколько примеров с выводом результата на экран: -```text -5 > 4 -password == text +```java +System.out.println(5 >= 3); // => true +System.out.println(7 < 0); // => false +System.out.println(5 > 5); // => false +System.out.println(5 >= 5); // => true +System.out.println(2 == 5); // => false +System.out.println(2 != 5); // => true ``` -Оба примера — это выражения. Результат вычисления этих выражений — это одно из двух специальных значений - -* `true` — «истина» -* `false`— «ложь» - -Это новый для нас тип данных — **boolean**. Он содержит всего лишь два этих значения. Так выглядит пример кода с ним: +Любую операцию сравнения можно сохранить в переменную типа `boolean`, а потом вывести: ```java -var result = 5 > 4; +boolean result = 5 > 4; System.out.println(result); // => true ``` -Попробуем написать метод, который принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до года: +Когда в сравнении стоят жестко заданные числа, операция кажется бессмысленной. Мы и так знаем ее результат, и он всегда одинаковый, ведь три больше двух при любых обстоятельствах. Картина меняется, когда значения приходят извне. Напишем метод, который принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до года: ```java -// Метод, возвращающий boolean, называется предикатом -// Обычно такие методы имеют префикс has, can, is, was и так далее public static boolean isInfant(int age) { return age < 1; } ``` -Пользуемся тем фактом, что любая операция — это выражение. Поэтому единственной строчкой функции пишем «вернуть то значение, которое получится в результате сравнения `age < 1`». - -В зависимости от пришедшего параметра, сравнение будет либо истинным (`true`), либо ложным (`false`). В итоге `return` вернет этот результат: +Единственной строкой метода мы пишем "вернуть то значение, которое получится в результате сравнения `age < 1`". В зависимости от пришедшего аргумента сравнение будет либо истинным (`true`), либо ложным (`false`). Метод вернет этот результат: ```java System.out.println(App.isInfant(3)); // => false +System.out.println(App.isInfant(1)); // => false System.out.println(App.isInfant(0)); // => true ``` + +## Предикаты + +Когда методы возвращают результат сравнения, они отвечают на вопрос "да" или "нет". Такие методы называют **предикатами**. Их узнают по тому, что они возвращают логическое значение `true` или `false`. Часто в названии предиката стоит вопрос или утверждение, которое можно проверить (`is`, `has`, `can`, `was`). Вот метод, проверяющий, отрицательное ли число: + +```java +public static boolean isNegative(int number) { + // Проверяем, меньше ли число нуля + return number < 0; +} + +System.out.println(App.isNegative(-5)); // => true +System.out.println(App.isNegative(7)); // => false +``` + +Метод `isNegative` собирает условие внутри, а наружу отдает короткий ответ. Так вычисление прячется за понятным именем. diff --git a/modules/45-logic/10-bool-type/ru/data.yml b/modules/45-logic/10-bool-type/ru/data.yml index c193be4..f1cf7b2 100644 --- a/modules/45-logic/10-bool-type/ru/data.yml +++ b/modules/45-logic/10-bool-type/ru/data.yml @@ -1,5 +1,9 @@ --- name: Логический тип +tips: + - > + [Тип boolean в + Java](https://docs.oracle.com/javase/specs/jls/se21/html/jls-4.html#jls-4.2.5) definitions: - name: Логический тип (boolean) description: 'тип данных с двумя возможными значениями: true (истина) и false (ложь).' diff --git a/modules/45-logic/25-logical-operators/ru/README.md b/modules/45-logic/25-logical-operators/ru/README.md index f9b1144..6dcb12e 100644 --- a/modules/45-logic/25-logical-operators/ru/README.md +++ b/modules/45-logic/25-logical-operators/ru/README.md @@ -1,70 +1,86 @@ - Мы уже умеем писать методы, которые проверяют одиночные условия. В этом уроке мы продолжим работу с методами и научимся строить составные условия. -Такие навыки пригождаются в довольно распространенных задачах — например, при проверке пароля. Как вы знаете, некоторые сайты при регистрации просят придумать пароль от 8 до 20 символов в длину. +Такие навыки пригождаются в распространенных задачах, например при проверке пароля. Некоторые сайты при регистрации просят придумать пароль от 8 до 20 символов в длину. -В математике мы бы написали `8 <= x <= 20`, но в Java такой трюк не пройдет. Нам придется сделать два отдельных логических выражения и соединить их специальным оператором «И». +В математике мы записали бы это как `8 <= x <= 20`, но в Java такой трюк не пройдет. Нам придется сделать два отдельных логических выражения и соединить их специальным оператором "И". -Напишем метод, который принимает пароль и говорит, соответствует ли он условиям: +Напишем метод, который принимает пароль и говорит, соответствует ли он условиям. Результат выводим на экран: ```java -// Пароль длиннее 8 символов **И** пароль короче 20 символов +// Пароль длиннее 8 символов И пароль короче 20 символов public static boolean isCorrectPassword(String password) { var length = password.length(); return length > 8 && length < 20; } -isCorrectPassword("qwerty"); // false -isCorrectPassword("qwerty1234"); // true +System.out.println(App.isCorrectPassword("qwerty")); // => false +System.out.println(App.isCorrectPassword("qwerty1234")); // => true ``` -Оператор `&&` означает «И». В этом случае выражение считается истинным, только если истинен каждый *операнд* — каждое из составных выражений. Другими словами, `&&` означает «и то, и другое». +Оператор `&&` означает "И". В математической логике это называют конъюнкцией. Все выражение считается истинным, только когда истинен каждый **операнд**, то есть каждое из составных выражений. Другими словами, `&&` означает "и то, и другое". Приоритет этого оператора ниже, чем приоритет операторов сравнения, поэтому выражение `length > 8 && length < 20` отрабатывает правильно без скобок. -Приоритет этого оператора ниже, чем приоритет операторов сравнения, поэтому выражение отрабатывает правильно без скобок. +Кроме `&&` часто используется оператор `||`, который означает "ИЛИ" (дизъюнкция). Он читается как "или то, или другое, или оба". Выражение `a || b` считается истинным, когда истинен хотя бы один из операндов или когда истинны оба. В остальных случаях выражение ложное. -Кроме `&&` часто используется оператор `||` — «ИЛИ». Он означает «или то, или другое, или оба». Операторы можно комбинировать в любом количестве и любой последовательности. Единственное исключение — когда одновременно встречаются `&&` и `||`, то приоритет лучше задавать скобками: +Посмотрим на метод, который определяет, положена ли человеку скидка. Скидку дают тем, кто младше 18 лет, или студентам: ```java -a && b || c; // Без скобок сложно понять приоритет -a && (b || c) // Приоритет очевиден +public static boolean hasDiscount(int age, boolean isStudent) { + return age < 18 || isStudent; +} + +System.out.println(App.hasDiscount(15, false)); // => true (младше 18) +System.out.println(App.hasDiscount(25, true)); // => true (студент) +System.out.println(App.hasDiscount(15, true)); // => true (оба условия) +System.out.println(App.hasDiscount(25, false)); // => false ``` -Рассмотрим еще один пример. Представим, что мы хотим купить квартиру, которая удовлетворяет таким условиям: +Операторы можно комбинировать в любом количестве и любой последовательности. Когда в коде одновременно встречаются `&&` и `||`, приоритет лучше задавать скобками: -> Больше 100 м^2 на любой улице **ИЛИ** больше 80 м^2 на центральной улице *Main Street* +```java +a && b || c; // Без скобок сложно понять приоритет +a && (b || c); // Со скобками понятно, что к чему относится +``` -Напишем метод, проверяющий квартиру. Он принимает два параметра: площадь и название улицы: +Рассмотрим еще один пример. Представим, что мы хотим купить квартиру, которая удовлетворяет таким условиям: -```java -isGoodApartment(91, "Queens Street"); // false -isGoodApartment(78, "Queens Street"); // false -isGoodApartment(70, "Main Street"); // false +> Больше 100 м² на любой улице **ИЛИ** больше 80 м² на центральной улице *Main Street* -isGoodApartment(120, "Queens Street"); // true -isGoodApartment(120, "Main Street"); // true -isGoodApartment(80, "Main Street"); // true +Напишем метод, проверяющий квартиру. Он принимает два параметра, площадь и название улицы. Строки сравниваем через `.equals(...)`, потому что для строк это правильный способ проверки на равенство: +```java public static boolean isGoodApartment(int area, String street) { - return area >= 100 || (area >= 80 && "Main Street".equals(street)); + return area >= 100 || (area >= 80 && "Main Street".equals(street)); } + +System.out.println(App.isGoodApartment(91, "Queens Street")); // => false +System.out.println(App.isGoodApartment(78, "Queens Street")); // => false +System.out.println(App.isGoodApartment(70, "Main Street")); // => false + +System.out.println(App.isGoodApartment(120, "Queens Street")); // => true +System.out.println(App.isGoodApartment(120, "Main Street")); // => true +System.out.println(App.isGoodApartment(80, "Main Street")); // => true ``` -Область математики, в которой изучаются логические операторы, называется **булевой алгеброй**. Ниже показаны «таблицы истинности» — по ним можно определить, каким будет результат применения оператора: +Скобки вокруг `area >= 80 && "Main Street".equals(street)` задают приоритет. Без них правило прочиталось бы иначе, а так сразу видно, какая часть относится к какому оператору. + +## Таблицы истинности + +Область математики, в которой изучаются логические операторы, называется булевой алгеброй. **Таблицы истинности** показывают, каким будет результат при применении каждого оператора. ### Оператор И `&&` | A | B | A && B | | ----- | ----- | ------- | -| TRUE | TRUE | **TRUE** | -| TRUE | FALSE | FALSE | -| FALSE | TRUE | FALSE | -| FALSE | FALSE | FALSE | +| true | true | **true** | +| true | false | false | +| false | true | false | +| false | false | false | ### Оператор ИЛИ `||` | A | B | A ❘❘ B | | ----- | ----- | -------- | -| TRUE | TRUE | **TRUE** | -| TRUE | FALSE | **TRUE** | -| FALSE | TRUE | **TRUE** | -| FALSE | FALSE | FALSE | +| true | true | **true** | +| true | false | **true** | +| false | true | **true** | +| false | false | false | diff --git a/modules/45-logic/25-logical-operators/ru/data.yml b/modules/45-logic/25-logical-operators/ru/data.yml index 90a94f2..339c024 100644 --- a/modules/45-logic/25-logical-operators/ru/data.yml +++ b/modules/45-logic/25-logical-operators/ru/data.yml @@ -7,3 +7,8 @@ tips: [Конъюнкция](https://ru.wikipedia.org/wiki/Конъюнкция) - | [Дизъюнкция](https://ru.wikipedia.org/wiki/Дизъюнкция) +definitions: + - name: Логические операторы + description: >- + операторы "И" (`&&`) и "ИЛИ" (`||`), позволяющие создавать составные + логические условия. diff --git a/modules/45-logic/28-logical-negation/ru/README.md b/modules/45-logic/28-logical-negation/ru/README.md index 5ed1885..b0ce34d 100644 --- a/modules/45-logic/28-logical-negation/ru/README.md +++ b/modules/45-logic/28-logical-negation/ru/README.md @@ -1,24 +1,102 @@ -Наряду с конъюнкцией (**И**) и дизъюнкцией (**ИЛИ**), часто используется операция «**отрицание**». +Наряду с логическими операторами **И** и **ИЛИ** часто используется операция "**отрицание**". Она меняет логическое значение на противоположное. В Java отрицанию соответствует унарный оператор `!`: -Отрицание меняет логическое значение на противоположное. В программировании ему соответствует оператор `!`. Если есть метод, проверяющий четность числа, то с помощью отрицания можно выполнить проверку нечетности: +```java +System.out.println(!true); // => false +System.out.println(!false); // => true +``` + +Если есть метод, проверяющий четность числа, то с помощью отрицания можно выполнить проверку нечетности: ```java public static boolean isEven(int number) { return number % 2 == 0; } -isEven(10); // true -!isEven(10); // false +System.out.println(App.isEven(10)); // => true +System.out.println(!App.isEven(10)); // => false +``` + +В примере выше мы добавили `!` слева от вызова метода и получили обратное действие. Отрицание позволяет выражать задуманные правила в коде без написания новых методов. + +Отрицание применяется не только к вызову метода, но и к целому выражению. Скобки задают, к чему именно относится оператор: + +```java +System.out.println(!(5 == 5 || 5 == 3)); // => false + +// Это же выражение можно записать и по-другому, +// "число не равно 5 и не равно 3" +System.out.println(5 != 5 && 5 != 3); // => false +``` + +## Двойное отрицание + +Отрицание разрешается ставить несколько раз подряд. В логике двойное отрицание равносильно отсутствию отрицания: + +```java +System.out.println(!!true); // => true +System.out.println(!!false); // => false + +System.out.println(!!App.isEven(10)); // => true +System.out.println(!!App.isEven(11)); // => false +``` + +## Приоритет + +Оператор `!` можно комбинировать с `&&` и `||`. Среди логических операторов у отрицания наивысший приоритет, поэтому оно применяется первым: + +```java +// (!true) || true => false || true => true +System.out.println(!true || true); // => true + +// (!true) && false => false && false => false +System.out.println(!true && false); // => false ``` -То есть мы просто добавили `!` слева от вызова метода и получили обратное действие. Отрицание можно применять не только к вызову метода, но и к целому выражению: +Скобки меняют порядок вычисления, и `!` применяется уже к результату внутри них: ```java -!(x == 5 || x == 3) +// !(true || true) => !true => false +System.out.println(!(true || true)); // => false -// Это же выражение можно записать и по-другому: -// x не равен 5 и не равен 3 -x != 5 && x != 3 +// !(true && false) => !false => true +System.out.println(!(true && false)); // => true +``` + +Практический пример. Метод проверяет, может ли водитель сесть за руль. Нужны права и трезвость, поэтому второе условие проходит через отрицание: + +```java +public static boolean canDrive(boolean hasLicense, boolean isDrunk) { + return hasLicense && !isDrunk; +} + +System.out.println(App.canDrive(true, false)); // => true (есть права, трезвый) +System.out.println(App.canDrive(true, true)); // => false (есть права, но пьяный) +System.out.println(App.canDrive(false, false)); // => false (нет прав) +``` + +Теперь вы знаете, что означают операторы **И**, **ИЛИ** и `!`. С их помощью вы сможете задавать составные условия из двух и более логических выражений. + +## Законы де Моргана + +При работе со сложными логическими выражениями бывает нужно их инвертировать или переписать в равносильную форму, которую удобнее читать. Для этого существуют **законы де Моргана**, два правила, которые описывают, как отрицание распределяется по составному выражению: + +```java +!(A && B) == !A || !B +!(A || B) == !A && !B +``` + +Первый закон говорит, что отрицание конъюнкции равно дизъюнкции отрицаний. Проверим обе части на конкретных значениях: + +```java +System.out.println(!(true && false)); // => true +System.out.println(!true || !false); // => true +``` + +Второй закон говорит, что отрицание дизъюнкции равно конъюнкции отрицаний: + +```java +System.out.println(!(true || false)); // => false +System.out.println(!true && !false); // => false ``` -Отрицание — мощный инструмент, который позволяет лаконично выражать задуманные правила в коде без необходимости писать новые методы. +На практике законы де Моргана помогают упрощать условия. Вместо `!(isAdmin || isModerator)` можно написать `!isAdmin && !isModerator`. Второй вариант читается как "не администратор и не модератор", и за ним легче уследить. diff --git a/modules/45-logic/28-logical-negation/ru/data.yml b/modules/45-logic/28-logical-negation/ru/data.yml index dd24f7f..b823220 100644 --- a/modules/45-logic/28-logical-negation/ru/data.yml +++ b/modules/45-logic/28-logical-negation/ru/data.yml @@ -3,3 +3,8 @@ name: Отрицание tips: - | [Законы Де Моргана](https://ru.wikipedia.org/wiki/Законы_де_Моргана) +definitions: + - name: Отрицание + description: > + логическая операция, которая меняет логическое значение на + противоположное. diff --git a/modules/45-logic/90-logical-expressions/App.java b/modules/45-logic/90-logical-expressions/App.java new file mode 100644 index 0000000..378d08d --- /dev/null +++ b/modules/45-logic/90-logical-expressions/App.java @@ -0,0 +1,9 @@ +public class App { + public static void main(String[] args) { + // BEGIN + var age = 20; + var hasConsent = true; + System.out.println(age >= 18 && hasConsent); + // END + } +} diff --git a/modules/45-logic/90-logical-expressions/Makefile b/modules/45-logic/90-logical-expressions/Makefile new file mode 100644 index 0000000..d0d0a48 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/Makefile @@ -0,0 +1,2 @@ +test: + @ test.sh diff --git a/modules/45-logic/90-logical-expressions/Test.java b/modules/45-logic/90-logical-expressions/Test.java new file mode 100644 index 0000000..c33f319 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/Test.java @@ -0,0 +1,24 @@ +import static org.assertj.core.api.Assertions.assertThat; + +import java.io.ByteArrayOutputStream; +import java.io.FileDescriptor; +import java.io.FileOutputStream; +import java.io.PrintStream; + +class Test { + public static void main(String[] args) { + final var expected = "true"; + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + System.setOut(new PrintStream(out)); + + App.main(null); + + final var actual = out.toString().trim(); + + System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out))); + System.out.println(actual); + + assertThat(actual).isEqualTo(expected); + } +} diff --git a/modules/45-logic/90-logical-expressions/ru/EXERCISE.md b/modules/45-logic/90-logical-expressions/ru/EXERCISE.md new file mode 100644 index 0000000..9aa44e2 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/ru/EXERCISE.md @@ -0,0 +1,10 @@ + +Форма регистрации принимает данные пользователя. Перед отправкой программа проверяет сразу два условия: пользователю есть 18 лет и он отметил согласие на обработку данных. + +В переменной `age` лежит возраст `20`, а в переменной `hasConsent` лежит значение `true`. Соедините проверку совершеннолетия `age >= 18` и согласие `hasConsent` оператором `&&` и выведите результат составного выражения на экран. + +Ожидаемый вывод: + +```text +true +``` diff --git a/modules/45-logic/90-logical-expressions/ru/README.md b/modules/45-logic/90-logical-expressions/ru/README.md new file mode 100644 index 0000000..9c27d87 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/ru/README.md @@ -0,0 +1,84 @@ +Одиночное сравнение вроде `age >= 18` отвечает на один вопрос. Реальные проверки собирают несколько таких вопросов в одно составное выражение. Форма на сайте принимает данные и проверяет сразу совершеннолетие пользователя и его согласие на обработку данных. Все это умещается в одну строку: + +```java +var age = 20; +var hasConsent = true; +System.out.println(age >= 18 && hasConsent); // => true +``` + +Составное логическое выражение в Java всегда вычисляется в `true` или `false`. Промежуточные части тоже превращаются в логические значения, и финальный результат собирается из них шаг за шагом. + +## Порядок вычисления + +В одном выражении встречаются арифметика, сравнения и логические операторы. Java вычисляет их в строгом порядке приоритетов: + +```text +Приоритет (от высокого к низкому): + + () скобки + ↓ + * / % + - арифметика + ↓ + < <= > >= == != сравнения + ↓ + ! отрицание + ↓ + && логическое И + ↓ + || логическое ИЛИ +``` + +Сначала считается арифметика, затем сравнения дают `true` или `false`, и только потом логические операторы соединяют эти значения. Оператор `&&` истинен, когда истинны оба операнда. Оператор `||` истинен, когда истинен хотя бы один. Оператор `!` меняет значение на противоположное. + +## Вычисление по шагам + +Разберем выражение из примера выше. У нас `age` равен `20`, а `hasConsent` равен `true`: + +```java +age >= 18 && hasConsent +20 >= 18 && true // подставили значения переменных +true && true // сравнение 20 >= 18 дало true +true // оба операнда && истинны +``` + +Возьмем выражение посложнее, где участвуют все три оператора. Проверяем, что число в диапазоне от 1 до 10 и при этом четное: + +```java +var number = 4; +System.out.println(number >= 1 && number <= 10 && number % 2 == 0); // => true +``` + +Java разворачивает его так: + +```java +4 >= 1 && 4 <= 10 && 4 % 2 == 0 +true && true && 4 % 2 == 0 // два сравнения дали true +true && true && 0 == 0 // посчитали остаток 4 % 2 +true && true && true // последнее сравнение дало true +true // все операнды && истинны +``` + +## Скобки и приоритет + +Когда в выражении смешаны `&&` и `||`, порядок задают скобки. Без них `&&` срабатывает раньше `||`, и смысл может оказаться не таким, как задумано: + +```java +// && связывает b и c, поэтому это a || (b && c) +System.out.println(true || false && false); // => true + +// скобки меняют порядок, сначала считается то, что внутри +System.out.println((true || false) && false); // => false +``` + +Первое выражение сначала вычисляет `false && false`, получает `false`, а затем `true || false` дает `true`. Во втором случае скобки заставляют посчитать `true || false` первым, получается `true && false`, и результат `false`. + +## Сокращенное вычисление + +Java останавливается, как только результат уже понятен. Если левый операнд `||` истинен, правый не вычисляется, ведь все выражение уже истинно. Если левый операнд `&&` ложен, правый тоже пропускается: + +```java +var hasAccess = true; +System.out.println(hasAccess || age < 0); // => true, правую часть Java не считает +``` + +Такое поведение называют сокращенным вычислением. Оно ускоряет проверки и защищает от лишней работы в правой части выражения. diff --git a/modules/45-logic/90-logical-expressions/ru/data.yml b/modules/45-logic/90-logical-expressions/ru/data.yml new file mode 100644 index 0000000..15c0ea2 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/ru/data.yml @@ -0,0 +1,15 @@ +--- +name: Логические выражения +tips: + - > + [Операторы и приоритет в + Java](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html) +definitions: + - name: Составное логическое выражение + description: > + выражение из нескольких сравнений и логических операторов, которое + вычисляется в одно значение true или false. + - name: Сокращенное вычисление + description: > + пропуск правого операнда оператора, когда результат выражения уже + определен левым операндом.