Операторы перехода в java

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

Используются в Java , чтобы присвоить значения переменным. Например,

Оператор « = » присваивает значение справа от себя переменной, находящейся слева. В примере переменной age присвоено значение 5 .

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

Арифметические операторы Java используются, чтобы производить математические операции сложения, вычитания умножения и так далее.

Оператор	Значение
+	Сложение (также используется для конкатенации строк)
—	Вычитание
*	Умножение
Деление
%	Остаток от деления

Пример 2: Арифметические операторы

В примере с оператором деления Java , приведенном выше, использованные операнды – переменные. Кроме этого могут использоваться символьные значения. Например:

Оператор « + » также может быть использован, чтобы соединить ( конкатенировать ) две строки или больше.

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

Унарный оператор Java производит операцию только над одним операндом.

Оператор	Значение
+	Унарный плюс (не нужен, так как числа положительные и без него).
—	Унарный минус; инвертирует знак выражения.
++	Оператор инкремента; увеличивает значение на 1.
—	Оператор декремента; уменьшает значение на 1.
!	Оператор логического отрицания; инвертирует значение булевой переменной.

Пример 4: Унарный оператор

В Java можно использовать операторы « ++ » и « — » в качестве префикса и постфикса. Оператор « ++ » увеличивает значение на 1 , а « — » уменьшает значение на 1 .

Есть большая разница в использовании операторов Java инкремента и декремента в префиксе и в постфиксе. Рассмотрим пример:

Пример 5: Унарный оператор

Когда выполняется выражение System.out.println(number++) , первым вычисляется изначальное значение. Переменная number увеличивается только после этого. Поэтому вы получите на выходе 5.2 . Далее, когда выполняется System.out.println(number) , показывается значение 6.2 .

Тем не менее, когда выполняется System.out.println(++number) , number увеличивается на 1 перед тем, как будет выведено на экран. Так же обстоят дела и с оператором Java декремента.

Операторы равенства и отношений

Операторы равенства и отношений проверяют, является ли операнд больше, меньше, равен, неравен второму и так далее. Получаемый результат равен true или false .

Оператор	Описание	Пример
==	равен	5 == 3 результат false
!=	неравен	5 != 3 результат true
>	Больше	5 > 3 результат true
=	Больше или равен	5 >= 5 результат true
Java , на экран выведется:

Здесь мы использовали оператор « > », чтобы проверить, больше ли number1 , чем number2 .

Так как number2 больше, чем number1 , результатом выражения number1 > number2 будет false .

Кроме операторов отношений, есть оператор сравнения типов instanceof , который сравнивает объект и определенный тип.

Оператор instanceof

Пример оператора instanceof .

Когда вы запустите программу, на экран выведется true . Это происходит от того, что test — экземпляр класса String .

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

Java логические операторы || ( условное-ИЛИ (OR) ) и && ( условное-И (AND) ) совершают операции над булевыми выражениями. Вот как они работают.

Оператор	Описание	Пример
||	условное-ИЛИ; true если хотя бы одно из булевых выражений истинно (true)	false || true результат — true
&&	условное-И; истинно если все булевы выражения истинны (true).	false && true результат — false

Тернарный оператор

Условный оператор или тернарный оператор Java « ? :» — это сокращение выражения if-then-else . Синтаксис условного оператора:

Вот как это работает.

• Если значение выражения — true , expression1 присваивается переменной ;
• Если значение выражения — false , expression2 присваивается переменной .

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

Чтобы осуществлять побитовые операции, в Java используются такие операторы.

Оператор

Описание

Побитовое дополнение.
>
Правый сдвиг.

>>>
Беззнаковый правый сдвиг.

&
Побитовое И.

^
Побитовое исключающее ИЛИ.

|
Побитовое включающее ИЛИ.

Эти операторы применяются нечасто.

Другие операторы присваивания

В начале статьи мы рассмотрели только один оператор присваивания = . Существует еще несколько операторов Java присваивания.

Оператор	Пример	Эквивалент
+=	x += 5	x = x + 5
-=	x -= 5	x = x – 5
*=	x *= 5	x = x * 5
/=	x /= 5	x = x / 5
%=	x %= 5	x = x / 5
>=	x >>= 5	x = x >> 5
&=	x &= 5	x = x & 5
^=	x ^= 5	x = x ^ 5
|=	x |= 5	x = x | 5

Данная публикация представляет собой перевод статьи « Java Operators » , подготовленной дружной командой проекта Интернет-технологии.ру

Битовая операция ИЛИ

Следующая битовая операция – поразрядное ИЛИ. Она задается оператором | и
ее таблица истинности выглядит следующим образом.

x	y	ИЛИ
1	1
1	1
1	1	1

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

byte flags = 8;  //двоичный вид:  00001000
byte mask = 5;   //двоичный вид:  00000101
 
flags = (byte)(flags | mask);   //двоичная запись 00001101 (число 13)
 
System.out.println(flags);

Здесь мы имеем
такую картину.

flags=	1
mask=	1	1
flags=	1	1	1

то есть,
операция поразрядное ИЛИ, как бы собирает все единички из обеих переменных и
получается такое своеобразное сложение. Кстати, в этом случае действительно
получилось 8+5=13. Но это будет не всегда так, например, если

byte flags = 9;  //двоичный вид:  00001001

то результат
тоже будет 13, так как операция ИЛИ включает бит вне зависимости был ли он уже
включен или нет, все равно на выходе будет единица. И здесь уже 9+5=13, что
математически неверно.

Операции сравнения

Операции сравнения позволяют проверить, больше ли один операнд другого, либо что один операнд равен другому и т. д.

Вот список операций сравнения в Java:

==  равенство (обратите внимание, что нужно использовать два символа равно для сравнения, а не один)

!=  неравенство

>  больше

>=  больше или равно

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

Пример:

class Main {
public static void main(String[] args) {
int x = 3;
double d = 3.1;
System.out.println(x == d); // false
System.out.println(x > d); // false
System.out.println(x < d); // true
}
}

1 2 3 4 5 6 7 8 9

classMain{ publicstaticvoidmain(Stringargs){ intx=3; doubled=3.1; System.out.println(x==d);// false System.out.println(x>d);// false System.out.println(x<d);// true } }

При сравнении используются следующие правила:

• Если один из операндов
  NaN, то результат
  false.
• -Infinity  меньше
  +Infinity
• -0.0 с плавающей точкой равен +0.0 с плавающей точкой
• При сравнении примитивов разных типов значение меньшего типа преобразуется в больший тип.

Импорт и использование классов

Один из важных принципов программирования — DRY: Don’t Repeat Youself (не повторяйся). Разработчик должен уметь использовать то, уже создано, отлажено и работает.

Java поставляется с набором packages (пакетов). Они содержат скомпилированные классы, сгруппированные по тематике. На неё указывает имя пакета: java.io, java.util, java.net и так далее.

В игре нам потребуется случайное число от 0 до 9. Писать генератор случайных чисел незачем, так как в пакете java.util есть готовый класс Random. Чтобы использовать класс из пакета, его нужно импортировать. Строки с директивами импорта располагаются в самом начале файла класса.

import java.util.Random;

Создадим объект на основании класса, чтобы можно было вызвать нужный метод. Слева от знака присваивания (=) объявляем ссылочную переменную (объект) random типа Random. Справа создаём объект с помощью директивы new.

Random random = new Random();

Вызываем метод через точку после имени объекта: random.nextInt(10). Цифра 10 ограничивает диапазон генерируемых чисел (от 0 до 9). В результате получим строку из 30 случайных чисел

Запустите программу несколько раз и обратите внимание, что последовательность чисел не повторяется

import java.util.Random;
 
class RandomInt {
    public static void main(String args) {
        Random random = new Random();
        for (int i = ; i < 30; i++) {
            System.out.print(random.nextInt(10) + " ");
        }
    }
}

Объекты

Все в Java является объектом.

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

Что же такое объект?

Объект — это сгруппированные вместе данные и методы для того, чтобы эти данные обрабатывать. Когда мы говорим о данных, имеем в виду переменные, конечно.

Про переменные объекта говорят, что это «данные объекта» или «состояние объекта».

Про методы объекта говорят: это «поведение объекта». Состояние объекта (переменные объекта) принято менять только с помощью методов того же объекта. Менять переменные объекта напрямую (не через методы объекта) считается дурным тоном.

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

У каждого объекта есть собственная копия переменных класса (полей класса). Если в классе была объявлена нестатическая переменная int a, и ваша программа во время работы создала 10 объектов этого класса, теперь в каждом объекте есть собственная переменная int a.

Взаимодействие с объектом

Самый удобный способ работы с объектом — сохранить ссылку на объект в переменную, и потом вызывать методы у этой переменной. Выглядит это для вас знакомо:

Где — это переменная, которая хранит в себе ссылку на объект, а метод — это метод класса объекта.

Если вы хотите обратиться к полю (переменной) объекта, то тоже нужно использовать оператор точка:

Где — это переменная, которая хранит в себе ссылку на объект, а поле — это переменная класса (поле объекта).

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

Есть следующие операторы сравнения, поддерживаемые на языке Java. Предположим, переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены реляционные операторы или операторы сравнения в Java:

Оператор	Описание	Пример
==	Проверяет, равны или нет значения двух операндов, если да, то условие становится истинным	(A == B) — не верны
!=	Проверяет, равны или нет значения двух операндов, если значения не равны, то условие становится истинным	(A != B) — значение истинна
>	Проверяет, является ли значение левого операнда больше, чем значение правого операнда, если да, то условие становится истинным	(A > B) — не верны
=	Проверяет, является ли значение левого операнда больше или равно значению правого операнда, если да, то условие становится истинным	(A >= B) — значение не верны
> (сдвиг вправо)	Бинарный оператор сдвига вправо. Значение правых операндов перемещается вправо на количество бит, заданных левых операндом.	A >> 2 даст 15, который является 1111
>>> (нулевой сдвиг вправо)	Нулевой оператор сдвига вправо. Значение левых операндов перемещается вправо на количество бит, заданных правым операндом, а сдвинутые значения заполняются нулями.	A >>> 2 даст 15, который является 0000 1111

Пример

Следующий простой пример показывает, программно побитовые операторы в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:

Будет получен следующий результат:

Игра «Угадай число»

Мы узнали достаточно, чтобы написать игру «Угадай число». В ней компьютер «загадывает» целое число от 0 до 9, а человек должен угадать его — есть три попытки.

Создадим класс GuessTheNumber с методом main(), импортируем нужные нам классы и добавим соответствующие объекты. Класс Scanner обеспечит чтение чисел с консоли (System.in — консоль).

import java.util.Scanner;
import java.util.Random;
 
class GuessTheNumber {
    public static void main(String args) {
        Random random = new Random();
        Scanner sc = new Scanner(System.in);
    }
}

Объявим и инициируем три переменные: счётчик попыток count, для чтения числа с консоли — guess, для хранения загаданного числа — number.

int count = ;
int guess = -1; 
int number = random.nextInt(10);

Опишем основной игровой цикл, используя while. В цикле запрашиваем число с консоли, сравниваем с загаданным. В случае несовпадения выводим подсказку и увеличиваем счётчик попыток на 1.

while (count < 3 && guess != number) {
    System.out.print("Guess the number (0..9): ");
    guess = sc.nextInt();
    if (number != guess) {
        System.out.println("Your number is " +
            ((guess > number)? "greater"  "less"));
        count++;
    }
}

Тело цикла while повторяется, пока логическое значение в скобках возвращает true. Таким образом наш цикл будет повторяться, пока значение счётчика попыток меньше 3 и число не отгадано

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

Если условие в скобках true, то возвращается значение слева от двоеточия, если false — справа.

(guess > number)? "greater"  "less"

Остаётся добавить строку с выводом результата игры (победа или проигрыш) после цикла — тут снова используется тернарный оператор. Текст работающей программы выглядит так:

import java.util.Scanner;
import java.util.Random;
 
class GuessTheNumber {
    public static void main(String args) {
        Random random = new Random();
        Scanner sc = new Scanner(System.in);
        int count = ;
        int guess = -1;
        int number = random.nextInt(10);
        while (count < 3 && guess != number) {
            System.out.print("Guess the number (0..9): ");
            guess = sc.nextInt();
            if (number != guess) {
                System.out.println("Your number is " +
                    ((guess > number)? "greater"  "less"));
                count++;
            }
        }
        System.out.println("You " +
            ((guess == number)? "WIN!"  "Lose: " + number));
    }
}

Сохраняем программу в файл GuessTheNumber.java, компилируем (javac), вызываем JVM (java) — и пробуем выиграть у компьютера.

Добавим заключительный штрих: используя цикл do-while, позволим пользователю повторять сеанс игры без перезапуска программы. В приведённом ниже коде комментарий нужно заменить на соответствующий фрагмент из предыдущей программы. Попробуйте сделать это самостоятельно.

import java.util.Random;
import java.util.Scanner;
 
class GuessTheNumber {
    public static void main(String args) {
        Random random = new Random();
        Scanner sc = new Scanner(System.in);
        do {
            //
            // Вставьте фрагмент, который должен повторяться
            //
            System.out.println("Repeat game? Yes - 1, No - 0");
        } while (sc.nextInt() == 1);
    }
}

Обратите внимание, что тело цикла do-while повторяется на тех же условиях, что и тело цикла while: логическое выражение в скобках должно быть true

Плюсы и минусы Java

У всех качеств Java, будь то строгая типизация или объектная ориентированность, есть свои плюсы и минусы, а ещё они есть у самой Java как у языка.

Плюсы

• Независимость — ваш код будет работать на любой платформе, которая поддерживает Java.
• Надёжность — в немалой мере достигается благодаря строгой статической типизации.
• Мультифункциональность.
• Сравнительно простой синтаксис.
• Java — основной язык для Android-разработки.
• Объектно-ориентированное программирование (ООП) тоже приносит много выгод:

1. параллельная разработка;
2. гибкость;
3. одни и те же классы можно использовать много раз;
4. код хорошо организован, и его легче поддерживать.

Минусы

• Низкая скорость (по сравнению с С и С++).
• Требует много памяти.
• Нет поддержки низкоуровневого программирования (Java — высокоуровневый язык). Например, у неё нет указателей.
• С 2019 года обновления для бизнеса и коммерческого использования стали платными.
• Для ООП нужен опыт, а планирование новой программы занимает много времени.

JSON

Сериализация и Десериализация

JSON — невероятно удобный и полезный синтаксис для хранения и обмена данными. Java полностью поддерживает это.

Прим. перев. Для использования JSON из примера необходимо подключить библиотеку JSON Simple.

Вы можете сериализовать данные следующим образом:

Получается следующая строка JSON:

Десериализация в Java выглядит так:

Используемый в примере файл JSON (jsonDemoFile.json):

Прим. перев. В Java проектах очень часто для работы с JSON используют библиотеки Gson от Google или Jackson. Обе библиотеки очень популярны и хорошо поддерживаются. Попробуйте и их.

⇑

7. Пример описания и использования переменных с плавающей запятой.

float f;    // переменная с именем f типа float
f = 3.998f; // переменной f присвоить значение 3.998

double d; // переменная с именем d типа double
d = -340.349489287;

float ff = -3.99f; // инициализация переменной ff типа float

double dd = 779303028.3398; // инициализация переменной dd типа double

8. Какие особенности применения символьного типа данных char?

В Java для представления символов введен тип данных char.

Переменные типа char занимают в памяти компьютера 16 бит. Это связано с тем, что для представления символов char в Java используется кодировка Юникод (Unicode). Диапазон допустимых значений этого типа составляет от до 65535.

Использование кодировки Unicode связано с тем, что программы на Java используются во всем мире, то есть в странах, где для представления символа нужно 2 байта (16 бит). Такими странами есть, например, Япония, Китай.

9. Примеры описания и использования переменных типа char

char c;  // переменная с именем c типа char
c = 'Z'; // присвоение литерала 'Z'
c = 90;  // c = 'Z'
c--;     // c = 'Y'

char cc = '2'; // инициализация переменной cc значением '2'

10. Какое назначение в программах имеет тип boolean?

Тип boolean предназначен для сохранения логических значений. Переменные типа boolean могут принимать только два значения: true или false.

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

boolean b;
b = true;
boolean bb=false; // bb = false

bb = 5>4;   // bb = true
bb = 55==6; // bb = false

11. Какие отличия между примитивными типами и типами-ссылками?

Между примитивными типами и типами-ссылками существуют следующие отличия:

• переменная примитивного типа не является переменной-ссылкой (объектом);
• переменная примитивного типа есть «автоматической» и сохраняется в стеке. Объект (переменная) сохраняется в «куче». Поэтому производительность работы с переменными примитивного типа выше;
• при объявлении переменной примитивного типа не нужно выделять память оператором new;
• переменная примитивного типа напрямую сохраняет свое значение в отличие от переменной-ссылки.

12. Существуют ли беззнаковые примитивные типы?

Нет. В языке Java все примитивные типы являются знаковыми, то есть, могут принимать отрицательные значения.

• Литералы. Идентификаторы. Ключевые слова. Комментарии
• Переменные. Объявление переменных. Инициализация переменных
• Преобразование и приведение типов. Автоматическое продвижение типов в выражениях

Синтаксис оператора switch

switch (variable/expression) {
case value1:
   // statements of case1
   break;

case value2:
   // statements of case2
   break;

   .. .. ...
   .. .. ...

default:
   // default statements
}

Оператор switch оценивает выражение (в основном переменное) и сравнивает его со значениями (могут быть выражениями) каждой метки case.

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

Например, если переменная / выражение равно значению 2. В этом случае выполняются все операторы этого совпадающего case (операторы case2).

Это важно, потому что если break не используется, все операторы после соответствующего case выполняются последовательно до конца оператора switch. Что следует помнить:

Что следует помнить:

• Для выражения переключения может быть одно или N значений case.
• Значение case должно быть только типа выражения переключения. Значение case должно быть буквальным или постоянным. Он не допускает переменных.
• Значения case должны быть уникальными. В случае повторяющегося значения он отображает ошибку времени компиляции.
• Выражение переключателя Java должно быть byte, short, int, long, перечислением и строкой.
• Каждый оператор case может иметь оператор break, который не является обязательным.
• Когда элемент управления достигает оператора break, он переходит к элементу управления после выражения switch.
• Также case может иметь метку по умолчанию, которая является необязательной.

Оператор break

Оператор
break  позволяет прервать текущее выполнение
switch  или  цикла
for ,
while  и
do-while  и перейти к следующему оператору после него. Примеры:

Java

int n = 0;
while (true) {
System.out.println(n);
if (n == 10) break;
n++;
}

1 2 3 4 5 6

intn=; while(true){ System.out.println(n); if(n==10)break; n++; }

Java

int n = 0;
do {
System.out.println(n);
if (n == 10) break;
n++;
} while (true);

1 2 3 4 5 6

intn=; do{ System.out.println(n); if(n==10)break; n++; }while(true);

Java

for (int n = 0; 😉 {
System.out.println(n);
if (n == 10) break;
n++;
}

1 2 3 4 5

for(intn=;;){ System.out.println(n); if(n==10)break; n++; }

Все приведённые выше примеры выводят в консоль числа от 0 до 10.

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

Java

// метка для внешнего цикла.
outer_for:
for (int n = 0; n < 10; n++) {
//…
// метка для внутреннего цикла
inner_for:
for (int m = 0; m < 10; m++) {

// прерываем внешний цикл для n == 2 и m ==4
if ((n == 9) && (m == 4)) break outer_for;

// прерываем внутренний цикл для n == 7 и m == 2
if ((n == 7) && (m == 2)) break;

// можно прервать внутренний цикл и по метке.
if ((n == 9) && (m % 2 == 1)) break inner_for;

System.out.println(«n=» + n + «; m=» + m);
}
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// метка для внешнего цикла. outer_for for(intn=;n<10;n++){ //… // метка для внутреннего цикла inner_for for(intm=;m<10;m++){ // прерываем внешний цикл для n == 2 и m ==4 if((n==9)&&(m==4))breakouter_for; // прерываем внутренний цикл для n == 7 и m == 2 if((n==7)&&(m==2))break; // можно прервать внутренний цикл и по метке. if((n==9)&&(m%2==1))breakinner_for; System.out.println(«n=»+n+»; m=»+m); } }

Тригонометрические функции

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

Mathkpi

Константа Math.PI представляет собой двойное значение, значение которого очень близко к значению PI – математическому определению PI.

Math.sin()

Метод Math.sin() вычисляет значение синуса некоторого значения угла в радианах:

double sin = Math.sin(Math.PI);
System.out.println("sin = " + sin);

Math.cos()

Метод Math.cos() вычисляет значение косинуса некоторого значения угла в радианах:

double cos = Math.cos(Math.PI);
System.out.println("cos = " + cos);

Math.tan()

Метод Math.tan() вычисляет значение тангенса некоторого значения угла в радианах:

double tan = Math.tan(Math.PI);
System.out.println("tan = " + tan);

Math.asin()

Метод Math.asin() вычисляет значение синусоиды значения от 1 до -1:

double asin = Math.asin(1.0);
System.out.println("asin = " + asin);

Math.acos()

Метод Math.acos() вычисляет значение арккосинуса от 1 до -1:

double acos = Math.acos(1.0);
System.out.println("acos = " + acos);

Math.atan()

Метод Math.atan() вычисляет значение арктангенса для значения от 1 до -1:

double atan = Math.atan(1.0);
System.out.println("atan = " + atan);

Вот что говорит JavaDoc:

Если вам нужен этот метод, пожалуйста, прочитайте JavaDoc.

Math.sinh()

Метод Math.sinh() вычисляет значение гиперболического синуса значения между 1 и -1:

double sinh = Math.sinh(1.0);
System.out.println("sinh = " + sinh);

Math.cosh()

Метод Math.cosh() вычисляет значение гиперболического косинуса от 1 до -1:

double cosh = Math.cosh(1.0);
System.out.println("cosh = " + cosh);

Math.tanh()

Метод Math.tanh() вычисляет значение гиперболического тангенса значения от 1 до -1:

double tanh = Math.tanh(1.0);
System.out.println("tanh = " + tanh);

Math.toDegrees()

Метод Math.toDegrees() преобразует угол в радианах в градусы:

double degrees = Math.toDegrees(Math.PI);
System.out.println("degrees = " + degrees);

Math.toRadians()

Метод Math.toRadians() преобразует угол в градусах в радианы:

double radians = Math.toRadians(180);
System.out.println("radians = " + radians);

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

Арифметические операторы — используются в математических выражениях таким же образом, как они используются в алгебре. Предположим, целая переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены арифметические операторы в Java:

Оператор	Описание	Пример
+	Складывает значения по обе стороны от оператора	A + B даст 30
—	Вычитает правый операнд из левого операнда	A — B даст -10
*	Умножает значения по обе стороны от оператора	A * B даст 200
Оператор деления делит левый операнд на правый операнд	B / A даст 2
%	Делит левый операнд на правый операнд и возвращает остаток	B % A даст 0
++	Инкремент — увеличивает значение операнда на 1	B++ даст 21
—	Декремент — уменьшает значение операнда на 1	B— даст 19

Пример

Следующий простой пример показывает программно арифметические операторы. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу:

Это произведет следующий результат:

Проверка условий

Любой язык программирования высокого уровня позволяет изменять порядок выполнения программы в зависимости от заданного условия. В Java для этого используется конструкция if. После этого ключевого слова в скобках записывается логическое выражение, затем в фигурных скобках — группа команд. Если результат логического выражения — true (истина), то эта группа команд выполняется, если false (ложь) — нет.

class ComparisonShort {
    public static void main(String args) {
        int i = 10;
        if (i == 10) {
            System.out.println("i = 10");
        }
    }
}

Результат этого примера — строка “i = 10” в консоли, так как результат логического выражения (проверка на равенство) будет true.

В качестве знаков сравнения допустимы: <, <=, >, >=, ==, !=. Добавив ключевое слово else, получаем полную форму оператора сравнения.

class ComparisonFull {
    public static void main(String args) {
        int i = 10 + 2;
        if (i == 10) {
            System.out.println("i = 10");
        } else {
            System.out.println("i != 10");
        }
    }
}

Выполнив эту программу, мы увидим в консоли сообщение “i != 10”, так как результат сравнения значения переменной i и цифры 10 будет false. Поэтому выполнится набор команд в фигурных скобках после слова else.

Присвоение с выполнением другой операции

Операции 
+= (сложение с присвоением),
-= (вычитание с присвоением), 
*= (умножение с присвоением),
/= (деление с присвоением),
%= (взятие остатка с присвоением),
&= (битовый И с присвоением),
^=  (битовое исключающее ИЛИ с присвоением),
|= (битовое ИЛИ с присвоением),
<<= (сдвиг влево с присвоением),
>>= (знаковый сдвиг вправо с присвоением),
>>>=  (беззнаковый сдвиг вправо с присвоением) позволяют сразу выполнить операции и присвоить результат другой переменной.

Они работают так:

Java

E1 compop E2

1	E1 compop E2

эквивалентно

Java

E1 = (T) E1 op E2;

1	E1=(T)E1 op E2;

, где
T  — это тип переменной
E1.

То есть
intx1+=x2 эквивалентно
intx1=(int)x1+x2.

Main.java

Java

class Main {
public static void main(String[] args) {
int x1 = 100;
byte x2 = 100;
int x3 = 100;

x1 += 300; // эквивалентно x1 = (int) x1 + 300;
x2 += 300; // эквивалентно x2 = (byte) x2 + 300;
x3 += 300.1; // эквивалентно x3 = (int) x3 + 300.1;

System.out.println(«x1=» + x1); // 400
System.out.println(«x2=» + x2); // -112
System.out.println(«x3=» + x3); // 400
}
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

classMain{ publicstaticvoidmain(Stringargs){ intx1=100; bytex2=100; intx3=100; x1+=300;// эквивалентно x1 = (int) x1 + 300; x2+=300;// эквивалентно x2 = (byte) x2 + 300;       x3+=300.1;// эквивалентно x3 = (int) x3 + 300.1; System.out.println(«x1=»+x1);// 400 System.out.println(«x2=»+x2);// -112 System.out.println(«x3=»+x3);// 400 } }

Попрактикуемся

Чтобы убедиться, что вы не просто вызубрили теорию, а хорошо понимаете предмет, на собеседовании вам могут предложить задания вроде «что произойдёт при выполнении кода»

Разберём типовые задачи на понимание коллекций.

Задачи для ArrayList

Вариант попроще

Что будет напечатано после выполнения кода ниже:

Правильный ответ: test2:test4:test1:test4:test2:test3:

Объяснение

Элементы в ArrayList нумеруются начиная с нуля. Поэтому элемент с номером 1 — это test2.

Следующим действием мы добавляем строку «test4» в ячейку с индексом 1. При этом элементы с бо́льшим индексом сдвигаются вправо.

Вторая часть вывода (test4) показывает, что теперь по индексу 1 извлекается именно test4.

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

Вариант посложнее

Что будет выведено при выполнении кода:

Правильный ответ: 2:2

Объяснение

Первая часть понятна: добавили два элемента, поэтому размер списка равен двум. Остаётся вопрос: почему не был удалён «test1»?

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

Строки сравниваются по значению, поэтому «test3» не эквивалентно «test1» и «test2». А раз ни один элемент не соответствует критерию поиска, ничего не удалится — размер списка останется прежним.

Проверьте себя: подумайте, что произойдёт, если вместо

написать

Как начать писать на Java

Если вы планируете разрабатывать приложения на Java на своем настольном компьютере, то вам нужно будет загрузить и установить JDK.

Вы можете получить последнюю версию JDK непосредственно с сайта Oracle. Как только вы установите его, ваш компьютер будет иметь возможность понимать и запускать код на Java. Тем не менее, вам все равно понадобится некоторое вспомогательное ПО, чтобы было действительно удобно писать код. Это так называемая «интегрированная среда разработки» или IDE: интерфейс, используемый разработчиками для ввода текста кода и вызова JDK.

При разработке для Android вы будете использовать IDE Android Studio. Она не только послужит интерфейсом для кода на Java (или Kotlin), но и станет мостом для доступа к специфичным для Android вызовам из SDK.

Для целей нашего краткого руководства по Java может быть и проще написать свой код непосредственно в приложении-компиляторе Java. Они могут быть скачаны для Android и iOS, можно даже найти веб-приложения, которые работают в вашем браузере. Эти инструменты предоставляют все необходимое в одном месте и позволяют сразу начать тестирование кода. Например, compilejava.net.

А что с работой?

Прежде чем учить какой-то язык программирования, вы наверняка хотите знать: «А что же потом?»

Поэтому мы собрали для вас небольшую статистику по вакансиям.

На Яндекс.Работе в Москве от 900 до 1000 вакансий для Java-разработчиков, а на HeadHunter — около 2000 (все данные приведены за декабрь 2019 года).

Вакансии, в которых указана зарплата, начинаются от 70 тысяч рублей. Большинство предложений попадает в диапазон от 100 до 200 тысяч, а продвинутым разработчикам предлагают до 300 тысяч рублей.

Как вы видите, Java-разработчики востребованы, и даже по московским меркам у них хорошая зарплата (по данным Банка заработных плат HeadHunter, средняя зарплата по Москве в третьем квартале 2019 года составила 85 707 рублей).

Арифметические операции

Арифметические операции позволяют выполнять сложение (операция «+»), вычитание (операция «-»), умножение (операция «*»), деление (операция «/») и взятие остатка (операция «%»).  Эти операции имеют такие же приоритеты, что и в обычной математике, которую изучают в школе, то есть умножение и деление выполняется перед сложением и вычитанием.

Java

double x1 = 1.1 + 2.3; // 3.4
double x2 = 1.1 — 0.1; // 1.0
double x3 = 1.1 * 2 + 1; // 3.2
double x4 = 6 / 2.0; // 3.0
int x5 = 12 + 3; // 15
int x6 = 13 % 5; // 3

1 2 3 4 5 6

doublex1=1.1+2.3;// 3.4 doublex2=1.1-0.1;// 1.0 doublex3=1.1*2+1;// 3.2 doublex4=62.0;// 3.0 intx5=12+3;// 15 intx6=13%5;// 3

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

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

1. Если один из операндов имеет тип
   double, то результат выражения имеет тип
   double, иначе смотри пункт 2.
2. Если один из операндов имеет тип
   float, то результат выражения имеет тип
   float, иначе смотри пункт 3.
3. Если один из операндов имеет тип
   long, то результат выражения имеет тип
   long, иначе результат выражения имеет тип
   int.

(например, при сложении
int  и
long  результат будет иметь тип
long, а при сложении
long  и
float  результат будет иметь тип
float, а при сложении
float  и
double  результат будет иметь тип
double).

Если результат операции с целочисленными данными выходит за диапазон, то старшие биты отбрасываются, и результирующее значение будет совершенно неверным. При попытке деления на 0 возникает исключение
java.lang.ArithmeticExceptionzero.

При выполнении операций с плавающей точкой при выходе за верхнюю или нижнюю границу диапазона получается
+Infinity  (
Double.POSITIVE_INFINITY  и
Float.POSITIVE_INFINITY) и
-Infinity  (
Double.NEGATIVE_INFINITY  и
Float.NEGATIVE_INFINITY ) соответственно, а при получении слишком маленького числа, которое не может быть нормально сохранено в этом типе данных получается -0.0 или +0.0.

При выполнении операций с плавающей точкой результат
NaN  (
Double.NaN  и
Float.NaN) получается в следующих случаях:

• Когда один из операндов
• В неопределённых результатах:
  • Деления 0/0, ∞/∞, ∞/−∞, −∞/∞,  −∞/−∞
  • Умножения 0×∞ and 0×−∞
  • Степень 1∞
  • сложения ∞ + (−∞), (−∞) + ∞ и эквивалентные вычитания.
• Операции с комплексными результатами:
  • Квадратный корень из отрицательного числа
  • Логарифм отрицательного числа
  • Тангенс 90 градусов и ему подобных (или π/2 радиан)
  • Обратный синус и косинус от числа меньше −1 и больше +1.

Краткие выводы

• Все логические операторы применяются к булевским выражениям, то есть таким, о которых можно сказать, true они или false.
• Если операторы , или применяются к числам, речь идёт уже не о логических операциях, а о побитовых. То есть оба числа переводятся в двоичную систему и к этим числам побитово применяют операции логического сложения, умножения или вычитания.
• В математической логике операторам и соответствуют конъюнкция и дизъюнкция.
• Логическое И похоже на умножения 1 (true) и 0 (false).
• Логическое ИЛИ напоминает поиск максимума среди 1 (true) и 0 (false).
• Для побитового отрицания целого числа a используется операция .
• Для логического отрицания булевского выражения a используется операция .
• Отрицательные числа хранятся и обрабатываются в дополнительном коде.
• Поразрядный сдвиг вправо может сохранять знак (), а может — не сохранять ().