Какого оператора не существует в java

Тест на знание операторов языка Java?

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

Какой группы операторов не существует?

Как правильно называется оператор "="?

Как выглядит оператор под названием декремент?

Как обозначается побитовый оператор сдвиг влево?

Выберите правильное утверждение

Оператор || — логическое "ИЛИ", а | — логическое "И"

Оператор || — побитовое "ИЛИ", а | — логическое"ИЛИ"

Оператор || — логическое "ИЛИ", а | — побитовое "ИЛИ"

Какое название носит оператор ": ?"?

Какое значение должна иметь переменная a, чтобы на экране появилось "Correct"?

Любое больше 10

Любое меньше 10

Каким оператором является "()"?

Не является оператором

Каковы значения a, b и c после выполнения следующего кода?

Какой оператор имеет больший приоритет?

Является ли instanceof оператором?

Какого оператора не существует?

Вы разбираетесь в теме на начальном уровне

Вам известны какие-то базовые факты, но более сложные вещи вызывают у Вас затруднения. Обязательно уделите достаточно времени этой теме, ведь без нее практически невозможно написать программу любой сложности! Удачи! Поделитесь тестом с друзьями и проверьте их знания 🙂

Вы разбираетесь в теме на среднем уровне

Вы без труда используете многие операторы Java, но иногда теряетесь при решении более сложных задачек. Не расстраивайтесь! Подтяните теорию и закрепите на практике, и у Вас обязательно все получится! Поделитесь тестом с друзьями и проверьте их знания 🙂

Вы отлично разбираетесь в теме

Вы отлично ответили на все вопросы, и можно спокойно заявить: тема усвоена на твердую пятерку! Пришло время изучать язык дальше и переходить к вещам посложнее. Удачи! Поделитесь тестом с друзьями и проверьте их знания 🙂

Операторы в Java. Описание, особенности, использование логических операторов

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

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

Для того, чтобы успешно создавать программные коды на Джаве, программисту предстоит работать с разнообразными операторами. Без них обойтись невозможно. Довольно часто на практике встречаются так называемые логические операторы. В Java они мало чем отличаются от аналогичных объектов любого другого языка программирования. Данная статья расскажет о том, что это такое. Упор будет сделан на логические операторы, особенно на «или».

Немного терминологии

Но перед тем, как изучать их, стоит запомнить некоторые термины. Они пригодятся в основном новичкам. Бывалые программисты и без того помнят, с чем предстоит иметь дело в процессе написания программных кодов:

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

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

Оператор – определение

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

Представлен символами, которые отвечают за передачу информации транслятору о том, что пользователь или программист хочет сделать с теми или иными операндами. Некоторые варианты требуют одного операнда, а какие-то – несколько. В первом случае целесообразно говорить об унарном типе.

• арифметическими;
• присваивания;
• логическими;
• побитовыми;
• прочими.

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

Арифметические

Арифметический оператор применяется в математических выражениях. Делается это также, как и в математике при счете.

Выше представлена таблица, которая поможет ориентироваться в данном варианте.

Сравнение

Бывает так, что значение переменной нужно с чем-то сравнить. Для этого Java использует отельные operators. Они называются операторами сравнения. Результат может принимать значение true и false.

Этот вариант тоже довольно часто применяется на практике. Таблица, представленная выше, поможет разобраться, какие «символы» задают рассматриваемую категорию объектов.

Побитовые

Для того, чтобы выделять память на устройстве, Java использует операторы побитового типа, но только в отношении целочисленных:

• int;
• long;
• char;
• byte;
• short.

Работает с битами, выполняет задаваемые операции последовательно.

Для того, чтобы лучше ориентироваться в этой категории, рекомендуется обратить внимание на таблицу.

Присваивание

Чтобы присвоить то или иное значение, необходимо использовать следующие записи:

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

Логические операторы

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

Логические операции будут выполняться в Джаве при помощи так называемых логических операторов. В ходе реализации задается то или иное условие. Оно проверяется и принимает значение true или false.

Работа поддерживается только с операндами, принадлежащими к типу boolean. Соответствующие «команды»:

• работают с двумя операндами;
• отвечают за объединение 2-х логических значений;
• образовывают общий результат логического типа.

Данная категория включает в себя разнообразные вариации. А именно:

• отрицание;
• «и»;
• «или»;
• исключающее или.

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

Отрицание

Унарный вариант. Использует только один операнд или булевское выражение. Иногда описывается как «логическое НЕ». Применение отвечает за корректировку состояния задействованного операнда.

Если заданное условие обладает значением true, в ходе применения рассматриваемого объекта будет произведена корректировка до результата «ложь». Иными словами, происходит замена изначального значения.

Для записи используется символ «!» без каких-либо кавычек. Вот наглядный пример:

Логическое «И»

Следующий operator – это «и». Применяется к двум выражениям. Результат – это true, только когда оба операнда обладают значением «true». В противном случае результирующим показателем служит «ложь».

Для записи используется символ «&». Чтобы лучше понимать принцип работы оного, можно представить, что:

• True = 1;
• False – 0.

В данном случае & будет работать как обычное умножение. Сюда же можно отнести условное «и» — &&. Этот вариант выдает такой же результат, как и &. Разница заключается в принципах работы соответствующих «операций».

Условное «и» применяется, когда не требуется узнавать значение второго операнда. Данный прием позволяет ускорить работу утилиты.

Логическое «или»

Логическое «или» носит название дизъюнкции:

• применяется относительно двух выражений;
• результатом служит «ложь», только если оба варианта ложны;
• true присваивается во всех остальных ситуациях.

Для записи используется символ «|». Соответственно, если хотя бы один оператор выступает в качестве true, конечный результат окажется тоже true.

Логическое «или» работает как сложение, но здесь 1+1 – это не 2, а 1. То есть, true.

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

Исключающее «или»

Это – строгая дизъюнкция. В математике данный вариант имеет немалое количество названий. Результат применения к двум операторам равно true, if оные являются отличными друг от друга и обладают false. Else – выдается результат false.

Данный вариант удобно сравнивать с вычитанием нулей и единиц, где 0 – это «ложь», а единица – true. Записывается при помощи «^».

О приоритетах

Изучая операторы, важно понимать приоритеты их выполнения. Это поможет программеру не запутаться.

В такой последовательности при написании и исполнении кода будут обрабатываться операторы.

О сложных выражениях

В программировании имеется и так называемый тернарный (сложный) оператор. Он присутствует во многих языках. Носит название «условный оператор».

Все рассматриваемые в статье объекты делятся на категории в зависимости от задействованных элементов. Тернарный оператор – это тройной. Он использует в процессе работы три аргумента. Это:

• условие;
• выражение 1;
• выражение 2.

Принцип работы осуществляется следующим образом:

Тернарный оператор возвращает аргумент 2 (первое выражение), если оный true. В противном случае произойдет возраст выражения 2.

Оператор, называемый тернарным, схож по механике работы с условной конструкцией if…Else. Только синтаксис в соответствующем варианте будет занимать намного меньше строк.

Как использовать

Тернарный оператор можно использовать несколькими способами:

1. Записать значение (true или false), которое будет возвращено, в переменную.
2. Осуществлять возврат в функциях через return.
3. Задействовать в процессе программирования множественные тернарные операции. В этом случае несколько «?» идут друг за другом.

Представленный код – это последовательная проверка каждого условия. Если первое true, booksCount получит значение «План на год выполнен!». В противном случае происходит дальнейшая проверка. Она повлечет проверку условия «>10».

Что лучше использовать

Тройной оператор (или тернарный) похож на условие «если…,то…». Но не совсем понятно, какой вариант лучше применять на практике при коддинге.

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

Чаще всего на практике вместо if…else можно использовать другую запись. А именно – тернарные условия. Но иногда подобный вариант только усложняет читаемость. Это происходит, когда:

• речь идет о множественных тернарных операторах в Java;
• использование «тройного выражения» зависит от условия, а не от присвоения значения переменной (int a, int b и так далее).

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

Знакомство с операторами Java: логические, арифметические, побитовые

Самая частая операция, которую программисты производят над числами — присвоение числового значения какой либо переменной. Она, как и оператор = тебе знакомы: Есть также арифметические операции. Они осуществляются с помощью бинарных арифметических операторов: Таблица 1. Бинарные арифметические операторы Первые четыре оператора не должны вызывать вопросов: все так же, как в математике. Последний оператор, остаток от деления, также не делает ничего сверхсложного. К примеру, если разделить 24 на 7, мы получим 3 целых и 3 в остатке. Именно остаток и вернет данный оператор: Вот примеры с сайта официальной документации Oracle: Данная программа выведет следующее: 1 + 2 = 3 3 — 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 Java позволяет комбинировать: например, операторы присваивания и арифметические операторы. Рассмотрим пример: Здесь мы задали переменную x и присвоили ей нулевое значение. Далее в каждой строке мы присваиваем значению x сумму текущего значения переменной x и единицы. В комментариях к каждой строке есть пояснения. Эту процедуру называют наращиванием или инкрементированием переменной. Операцию инкрементирования из примера выше можно заменить на аналогичную с использованием комбинации операторов: Комбинировать оператор присваивания можно с любым арифметическим оператором: Продемонстрируем работу последнего примера: Помимо бинарных, в Java есть унарные арифметические операторы. Таблица 2. Унарные арифметические операторы: Пример унарных плюса и минуса: Есть два типа данных операций — постфиксная и префиксная. В первом случае оператор пишется после переменной, во втором случае — перед переменной. Разница лишь в том, когда выполнится операция инкрементирования или декрементирования. Пример и описание в таблице ниже. Предположим, у нас есть переменная: Тогда: Таблица 3. Операторы инкремента-декремента: Демонстрация: Помимо арифметических, существуют операции сравнения (двух чисел). Результатом всегда будет истина либо ложь (true / false). Таблица 4. Операторы сравнения Примеры: Демонстрация:

Логические операции в Java

• операция отрицания ( NOT );
• операция конъюнкции, логическое И ( AND );
• операция дизъюнкции, логическое ИЛИ ( OR );
• операция сложения по модулю, исключающее ИЛИ ( XOR ).

• ! — оператор отрицания;
• && — оператор логическое И (сокращенный);
• || — оператор логическое ИЛИ (сокращенный);
• & — оператор побитовое И;
• | — оператор побитовое ИЛИ;
• ^ — оператор побитовое исключающее ИЛИ.

Побитовые операции в Java

Представление чисел в двоичной системе счисления

Согласно Википедии:

С какими данными работают побитовые операторы?

Побитовые операции в Java осуществляются только над целыми числами. А целые числа хранятся в памяти компьютера в виде набора битов. Можно сказать, что компьютер переводит любую информацию в двоичную систему счисления (в набор битов) и только потом взаимодействует с ней. Но как устроена двоичная система счисления? В десятичной системе счисления у нас есть всего 10 символов: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. С помощью этих символов мы ведем счет. После 9 идет 10, после 19 — 20, после 99 — 100, после 749 — 750. То есть мы используем комбинацию имеющихся 10 символов и можем с их помощью считать «от нуля и до обеда». В двоичной системе счисления вместо десяти символов есть всего два — 0, 1. Но комбинируя эти символы по тому же принципу, что и в десятичной системе, можем считать бесконечно долго. Продемонстрируем счет от 0 до 15 в десятичной системе и в двоичной: Как видим, все не так уж и сложно. Помимо битов, есть другие знакомые единицы измерения информации — байты, килобайты, мегабайты, гигабайты и тд. Ты, наверно, знаешь, что в 1 байте — 8 бит. Что это значит? Это значит, что 8 битов подряд занимают 1 байт. Вот примеры, какими могут быть байты: Количество возможных неповторяющихся комбинаций битов в одном байте — 256 (2 8 = 256). Но вернемся ближе к Java. Есть такой целочисленный тип данных — byte . Данный тип может принимать значения от -128 до 127 и одно число в памяти компьютера занимает ровно 8 бит, или 1 байт. Одно число этого типа занимает ровно 1 byte памяти компьютера. И здесь названия совпадают не случайно. Как мы помним, 1 байт может хранить 256 различных значений. И одно число типа byte может принимать 256 различных значений (128 отрицательных, 127 положительных и 1 ноль). Каждому значению числа byte соответствует уникальный набор из восьми битов. Так обстоят дела не только с типом byte , но и со всеми целочисленными типами. Тип byte приведен в пример как самый маленький. Ниже в таблице представлены все целочисленные типы Java и занимаемое ими место в памяти: Рассмотрим тип int . Он может хранить 2147483648 отрицательных, 2147483647 положительных значений и один ноль. Итого: Данный тип занимает в памяти компьютера 32 бита. Количество возможных комбинаций из набора 32-ух нулей и единиц равно: То же число, что и у количества значений, вмещаемых в тип int . Это всего лишь демонстрация взаимосвязи между диапазоном значений типа данных и его размером (количество бит в памяти). Любое число любого типа в Java можно перевести в двоичную систему счисления. Давай посмотрим, как легко это можно сделать это с помощью Java языка. Будем учиться на примере типа int . У данного типа есть свой класс-обертка — Integer . А у него — toBinaryString , который и сделает за нас всю работу: Вуаля — все не так уж и сложно. Но все-таки кое-что следует уточнить. int число занимает 32 бита. Но когда мы выводим число 10 в примере выше, мы видим в консоли 1010. Это потому, что ведущие нули не выводятся на печать. Если бы они выводились, вместо 1010 мы бы видели в консоли 00000000000000000000000000001010. Но для удобства восприятия все ведущие нули опускаются. Не так уж и сложно до тех пор, пока не задашься вопросом: а что с отрицательными числами? Он воспринимает информацию только в двоичной системе. Получается, что знак минус также необходимо прописывать двоичным кодом. Это можно сделать с помощью прямого или дополнительного кода.

Прямой код

Способ представления чисел в двоичной системе счисления, при котором старший разряд (крайний левый бит) отводится под знак числа. Если число положительное, в крайний левый бит записывается 0, если отрицательное — 1. Рассмотрим это на примере 8-ми битного числа: Подход несложный и в принципе понятный. Однако у него есть недостатки: возникают трудности с выполнением математических операций. К примеру со сложением отрицательных и положительных чисел. Их нельзя складывать, если не провести дополнительные манипуляции.

Дополнительный код

Типы побитовых операций

Теперь, когда мы разобрались со всеми вводными, поговорим о побитовых операциях в Java. Побитовая операция осуществляется над целыми числами, и ее результатом будет целое число. В процессе число переводится в двоичную систему, над каждым битом выполняется операция, и результат приводится обратно в десятичную систему. Список операций — в таблице ниже: Как мы уже выяснили числа можно представить в виде набора битов. Побитовые операции осуществляют операции как раз над каждым битом такого представления. Возьмем NOT , AND , OR , XOR . Вспомним, что недавно мы рассматривали таблицы истинности, только для логических операндов. В данном случае те же операции применяются к каждому биту целого числа.

Побитовый унарный оператор NOT

Данный оператор заменяет все нули на единицы, а единицы — на нули. Предположим, у нас есть число 10 в десятичной системе исчисления. В двоичной системе это число равно 1010. Если применить к данному числу унарный побитовый оператор отрицания, мы получим примерно следующее: Давай взглянем как это выглядит в Java коде: Теперь посмотрим, что выведется в консоль: В первой строке мы получили значение в двоичной системе счисления без ведущих нулей. Хоть мы их не видим, они есть. Об этом говорит вторая строка, в которой все биты трансформировались в обратные. Именно поэтому мы видим так много ведущих единиц. Это бывшие ведущие нули, которые игнорировались компилятором при выводе в первой строки. Вот небольшая программа, которая выводит для наглядности еще и ведущие нули.

Побитовый оператор AND

Данный оператор применим к двум числам. Он производит операцию AND между битами каждого числа. Рассмотрим пример: Данная операция осуществляется над двумя числами. Пример в Java коде:

Побитовый оператор OR

OR применим к двум числам. Он производит операцию OR между битами каждого числа: Теперь взглянем на то, как бы это выглядело в IDEA:

Побитовая операция, исключающее ИЛИ (XOR)

Взглянем на тот же пример, но с новой операцией: Пример кода:

Побитовый сдвиг влево

Сдвигая биты числа X на N битов влево мы умножаем число X на 2 N .

Но! У нас может измениться знак числа, если бит со значением 1 займет крайнее левое положение.

Если осуществлять сдвиг влево бесконечно долго, число просто превратится в 0. Продемонстрируем пункты 2 и 3:

Побитовый сдвиг вправо

Цикл, в котором переменная i наращивается от 1 до 10.

в переменную shiftOperationResult записываем результат сдвига числа 2048 на i битов вправо;

в переменную devideOperationResult записываем результат деления числа 2048 на 2 в степени i.

Попарно выводим два полученных значения.

Побитовый сдвиг вправо с заполнением нулями

Если обычный сдвиг битов вправо сохраняет знак числа (старший бит сохраняет свое значение), в случае со сдвигом вправо с заполнением нулями этого не происходит. А происходит заполнение старшего бита нулем. Давай посмотрим, как это выглядит:

Приоритет операций в Java

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

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

Определение четности числа

Поиск максимального элемента в массиве

Для поиска минимального элемента просто меняем знак сравнения в нужном месте.

Операторы в Java: для чего нужны и какие бывают

Знакомимся с основными инструментами языка и учимся работать с ними на практике.

Иллюстрация: Оля Ежак для Skillbox Media

Все мы со школы знакомы с математическими знаками + (плюс), – (минус), = (равно) и так далее. В Java и других языках программирования эти символы называются операторами. Они нужны для того, чтобы сообщить компилятору, какое действие совершать с операндами — числами, строками, объектами и другими значениями по обе стороны оператора.

Например, на картинке выше оператор + говорит компилятору: «Сложи два числа». Но на практике чисел в выражении может быть разное количество — и одно, и два, и три. В этих случаях и операторы будут называться по-разному: унарные — что-то делают с одним операндом, бинарные — с двумя, и тернарные — с тремя.

В этой статье рассмотрим не только эти, но все основные виды операторов в Java:

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

Оператор присваивания в Java

Оператор присваивания в Java — это знак = (равно). Его задача — переложить значение переменной справа в переменную слева:

Вот как это выглядит в коде (в комментариях — разбор синтаксиса):

Что происходит: значение true присваивается переменной b. В свою очередь, значение переменной b присваивается переменной a.

Арифметические операторы в Java

Эти операторы выполняют простые арифметические действия: сложение, вычитание, умножение, деление и деление с остатком. Все арифметические операторы являются бинарными — то есть работают только с двумя значениями.

Плюс: +

Что делает: складывает два операнда.

Ещё этот оператор применяется при соединении двух строк в одну. Например, в Java можно выполнить выражение «Я люблю» + «Москву» и получить «Я люблю Москву». Такая операция в программировании называется конкатенацией.

В Java типы данных char, byte и short при вычислениях неявно приводятся к типу int (целое число), поэтому с ними можно работать как с обычными числами. При этом тип данных char в Java отвечает за символы Unicode — каждый символ обозначает какое-то число. Например, символ a равен числу 97, а b — 98, поэтому в нашем примере и получилось значение 195.

Минус: −

Что делает: вычитает из левого операнда правый.

Умножение: *

Что делает: возвращает произведение операндов.

Деление: /

Что делает: делит левый операнд на правый.

А вот что будет, если попробовать поделить на ноль в Java:

Делить число на ноль нельзя! Программа завершится, выбросив исключение. Но если привести выражение к типу ‘double’ (число с плавающей запятой), то вы получите «бесконечность»:

Деление с остатком (деление по модулю): %

Что делает: возвращает остаток от деления.

Унарные операторы в Java

Эти операторы в Java тоже можно отнести к арифметическим, но есть нюанс — они работают только с одним операндом. Поэтому их и называют унарными.

Унарные плюс и минус: + и −

Что делают: меняют значение числа на положительное или отрицательное.

Инкремент и декремент: ++ и −−

Что делают: инкремент — увеличивает значение переменной на единицу, а декремент — уменьшает.

В свою очередь, у декремента и инкремента есть две формы: префиксная и постфиксная. Звучит сложно, но на деле всё просто:

• Префиксные операторы (++x) сразу меняют значение переменной и подставляют его в выражение.
• Постфиксные операторы (x++) делают наоборот — сначала используют старое значение переменной и только потом подставляют новое.

Инкременты и декременты часто используют в циклах в качестве счётчика, когда нужно по очереди вывести все числа в каком-то диапазоне:

Подробнее о декрементах и инкрементах можно почитать в нашей статье — рассказываем, как решать сложные выражения с этими операторами.

В Java есть ещё два унарных оператора: ! — логическое отрицание, и

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

Операторы сравнения в Java

Что делают: сравнивают два операнда и выясняют отношения между ними — что больше, что меньше, что чему равняется. При вычислении такие операторы возвращают значение типа boolean:

• true (правда);
• false (ложь).

Всего в Java шесть операторов сравнения:

Оператор	Что означает
==	Равно
>	Больше, чем
<	Меньше, чем
>=	Больше или равно
<=	Меньше или равно
!=	Не равно

Давайте посмотрим, как выглядят операторы сравнения в коде — попробуем сравнить два целых числа и вывести результаты на экран:

Ещё операторы сравнения часто используют в условных конструкциях. Это когда, в зависимости от условий, выполняется какой-то один блок кода. В этом случае, помимо операторов сравнения, нам понадобятся операторы ветвления: if-else, switch и так далее. Например, здесь мы просим Java напечатать слово true, если 1 не равно 0:

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

Логические операторы в Java: Boolean

Что делают: комбинируют логические значения типа true и false.

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

Всего в Java шесть логических операторов, но чаще всего используют эти четыре:

Символ	Логический оператор	Что означает
&&	И (AND)	Возвращает true, когда оба операнда true.
||	ИЛИ (OR)	Возвращает true, когда хотя бы один операнд — true.
^	ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR)	Возвращает true, когда один операнд true, а второй — false.
!	НЕ (NOT)	Инвертирует true в false и наоборот. Это унарный оператор — он работает только с каким-то одним выражением.

В качестве примера сравним несколько выражений:

Как это работает. Допустим, у нас есть конструкция (6 > 5) && (7 > 4). Когда мы начнём её выполнять, компилятор сначала проверит условия первого выражения, затем — второго. При этом оператор && устроен так, что если оба выражения истинны, то он и сам вернёт true. А это как раз наш случай, потому что и 6 больше 5, и 7 больше 4.

Тернарный оператор в Java: можно, только осторожно

Что делает: сокращает условную конструкцию if-else до одной строчки.

Тернарный оператор (от латинского слова ternarius — «тройной») — это языковая конструкция, которая состоит из трёх операндов: логического условия и двух выражений. Если результат логического условия будет true, выполнится первое выражение, если false — второе. Записываются тернарные операторы так:

Фишка в том, что таким образом мы можем записать конструкцию if-else всего одной строчкой. Допустим, нам нужно проверить булеву переменную condition — если она возвращает true, то переменная a = 100, а если false, то a = 200. Посмотрите, как легко это можно сделать с помощью тернарного оператора:

Кажется, что эти if-else теперь вообще больше не нужны. Мол, ставь везде тернарные операторы, и дело с концом. Однако в больших программах со сложной логикой это может повредить читаемости кода. Это в нашем примере выражение простое — а представьте, если в каждое выражение положить ещё по одному оператору. Получится неопрятно. Другому разработчику, который будет читать наш код, разобраться будет сложно.

Поэтому тернарные операторы рекомендуют использовать в тех случаях, когда условие простое и легко проверяется. А во всех остальных случаях прибегать к привычным «ифам» и «элсам».

Подробно о том, как работать с тернарными операторами, мы рассказывали в статье: «Тип Boolean и операторы сравнения в Java».

Оператор instanceof в Java

Что делает: проверяет, принадлежит ли объект к какому-то классу или интерфейсу, и возвращает булево значение — то есть true или false.

Использование instanceof актуально, когда нужно проверить родителя объекта прямо во время выполнения программы. Например, если объекты приходят в ваш код из базы данных или другого потока выполнения и вам нужно убедиться, что к ним можно применять методы какого-то класса. Записывается instanceof так:

Побитовые операторы в Java и смещение битов

Зачем нужны: чтобы писать алгоритмы, работающие с битами, — например, это полезно в криптографии и шифровании данных.

В Java существует семь побитовых операторов. Четыре из них отвечают за побитовые вычисления. Они похожи на логические операции, только вместо true и false вы имеете дело с нулями и единицами в двоичной системе счисления. Каждый разряд вычисляется поочерёдно — но в отличие от математики, когда складываются две единицы, результат не переносится на старший разряд и ответом будет 1. Это как если бы мы считали столбиком, а всё, что «в уме», — выкидывали.

Побитовые операторы вычисления бывают следующими:

Чтобы посмотреть, как работают побитовые вычисления в Java, переведём несколько десятичных чисел в двоичную систему счисления:

Теперь попробуем выполнить с ними логические операции:

В последнем примере мы видим, что при побитовом отрицании числа 0, почему-то получается -1. Тут есть два нюанса:

• 0 в нашем примере имеет тип int и занимает в памяти 4 байта — то есть 32 бита.
• Самый старший бит переменной (первый слева) является знаковым. Если он равен 0, то число будет положительным, а если 1 — отрицательным.

Если разобраться в концепции старшего бита, можно без труда освоить три оставшихся побитовых оператора, которые называются операторами смещения битов:

Символ	Что означает
<<	Сдвиг битов влево
>>	Сдвиг битов вправо
>>>	Беззнаковый сдвиг битов вправо

Операторы сдвига смещают все биты в левую или правую сторону, но делают это по-разному:

• >> не трогает старший бит, оставляя число с тем же знаком (отрицательным или положительным). Ячейки отрицательных чисел при >> заполняются единицами.
• >>> и << — затрагивают все биты. Освободившиеся ячейки справа заполняются нулями. Наполнение ячеек слева зависит от знака и оператора.

Звучит сложно, на деле — тоже сложно. Но попробуем разобраться на примере — разложим какое-то десятичное число на биты и посмотрим, как работает смещение битов.

В Java есть метод toBinaryString(), который показывает, как выглядят десятичные числа в двоичной системе. Но двоичные числа — это ещё не биты. Например, число 2 занимает 32 бита, но если обработать его методом toBinaryString(), на экране появятся только два из них: 1 и 0. Оставшиеся 30 нулей просто «обрезаются». Это происходит по той же причине, по которой мы, например, не пишем десятичное число 9 как 009.

Поэтому, чтобы лучше разобраться в работе побитовых операторов, лучше использовать модифицированный метод BinaryString, который раскладывает на биты уже так, как надо:

Сдвинув биты числа 1 два раза влево, мы получаем 4. А если потом сдвинуть их ещё 29 раз, получится минимальное значение типа int: –2 147 483 648.

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

Как это работает. С помощью операторов >> и >>> мы сдвигаем все биты числа вправо. Но при обычном сдвиге (>>) отрицательное число остаётся отрицательным, потому что мы не трогаем старший бит. При беззнаковом сдвиге (>>>) наоборот — отрицательное станет положительным, потому что мы затронем эту значимую единицу.

Составные операторы присваивания в Java

Зачем нужны: чтобы записывать выражения короче и автоматически приводить операнды к единому типу.

В Java есть сокращённые формы операторов присваивания — составные. Такие операторы выполняют действие между x и y, а получившееся значение помещают в x. Выглядят составные операторы так:

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

Приоритеты операторов Java

У каждого оператора Java есть свой приоритет. Чем он выше, тем раньше оператор выполнится в выражении. Бинарные и тернарный операторы (кроме присваивания) выполняются слева направо, а остальные (унарные и присваивания) — справа налево.

Резюме: что нужно запомнить

Мы рассмотрели все основные операторы в Java и их работу на примерах. Попробуем кратко резюмировать, что нужно вынести из этой статьи:

• Оператор — это языковая конструкция, которая выполняет действие над операндом.
• Операнд— это число, переменная, объект и так далее, с которыми оператор совершает какие-то действия (например, арифметическое и логическое).
• Операторы бывают унарные, бинарные и тернарные — это зависит от того, сколько операндов они обрабатывают.
• Арифметические операторы нужны для простых математических действий: сложения, вычитания, умножения, деления и деления с остатком.
• Унарные операторы работают только с одним операндом. Это унарные минус и плюс, инкремент, декремент, логическое и побитовое отрицание.
• Операторы сравнения сопоставляют значения двух операторов и возвращают ответ — true или false.
• Логические операторы заточены уже не на числа, а на целые выражения — и на их основе создают сложные условия, например, для работы в циклах.
• Тернарный оператор умеет работать сразу с тремя операндами: условием и двумя выражениями. То есть им вполне можно заменить ветвления типа if-else.
• Операторinstanceof определяет принадлежность объекта к классу.
• Побитовые операторы нужны для проведения операций с битами — если упростить, то с нулями и единицами в двоичной системе счисления.
• Составные операторы неявно приводят типы данных, если они разные.
• У каждого оператора есть свой приоритет.

Для более глубокого понимания темы можно почитать другие наши статьи: «Тип Boolean и операторы сравнения в Java» и «Логические операторы в Java». А если хотите совсем хорошо разобраться, почитайте официальную документацию Java — это вообще лучший способ освоить язык со всеми его тонкостями.