Устройство вещественных чисел

Содержание:

Условные выражения
- Операции сравнения
- Логические операции
Стиль оформления кода
JavaScript Значения приоритета оператора
Тернарная операция
Унарные операции
- Отличие постфиксного и префиксного инкремента и декремента
По ссылке или по значению
Логические И и ИЛИ

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

Последнее обновление: 16.04.2018

Условные выражения представляют собой некоторое условие и возвращают значение типа boolean, то есть значение true
(если условие истинно), или значение false (если условие ложно). К условным выражениям относятся операции сравнения и логические
операции.

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

В операциях сравнения сравниваются два операнда, и возвращается значение типа — , если выражение верно,
и , если выражение неверно.

сравнивает два операнда на равенство и возвращает (если операнды равны) и (если операнды не равны)
```
int a = 10;
int b = 4;
boolean c = a == b;    		// false
boolean d = a == 10;       // true
```
сравнивает два операнда и возвращает , если операнды НЕ равны, и , если операнды равны
```
int a = 10;
int b = 4;
boolean c = a != b;    		// true
boolean d = a != 10;       // false
```
< (меньше чем)

Возвращает , если первый операнд меньше второго, иначе возвращает
```
int a = 10;
int b = 4;
boolean c = a < b; 	// false
```
> (больше чем)

Возвращает , если первый операнд больше второго, иначе возвращает
```
int a = 10;
int b = 4;
boolean c = a > b; 	// true
```
>= (больше или равно)

Возвращает , если первый операнд больше второго или равен второму, иначе возвращает
```
boolean c = 10 >= 10; 	// true
boolean b = 10 >= 4; 	// true
boolean d = 10 >= 20; 	// false
```
<= (меньше или равно)

Возвращает , если первый операнд меньше второго или равен второму, иначе возвращает
```
boolean c = 10 <= 10; 	// true
boolean b = 10 <= 4; 	// false
boolean d = 10 <= 20; 	// true
```

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

Также в Java есть логические операции, которые также представляют условие и возвращают true или false и обычно объединяют несколько операций
сравнения. К логическим операциям относят следующие:

(c равно , если либо a, либо b (либо и a, и b) равны , иначе c будет равно )
(c равно , если и a, и b равны , иначе c будет равно )
(c равно , если b равно , иначе c будет равно )
(c равно , если либо a, либо b (но не одновременно) равны , иначе c будет равно )
(c равно , если либо a, либо b (либо и a, и b) равны , иначе c будет равно )
(c равно , если и a, и b равны , иначе c будет равно )

Здесь у нас две пары операций и (а также и ) выполняют
похожие действия, однако же они не равнозначны.

Выражение будет вычислять сначала оба значения — a и b и на их основе выводить результат.

В выражении же
вначале будет вычисляться значение a, и если оно равно , то вычисление значения b уже смысла не имеет,
так как у нас в любом случае уже c будет равно . Значение b будет вычисляться только в том случае, если a равно

То же самое касается пары операций . В выражении будут вычисляться оба значения — a и b.

В выражении же сначала будет вычисляться значение a,
и если оно равно , то вычисление значения b уже не имеет смысла, так как значение c в любом случае равно .
Значение b будет вычисляться только в том случае, если a равно

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

Примеры:

boolean a1 = (5 > 6) || (4 < 6); // 5 > 6 - false, 4 < 6 - true, поэтому возвращается true
boolean a2 = (5 > 6) || (4 > 6); // 5 > 6 - false, 4 > 6 - false, поэтому возвращается false
boolean a3 = (5 > 6) && (4 < 6); // 5 > 6 - false, поэтому возвращается false (4 < 6 - true, но не вычисляется)
boolean a4 = (50 > 6) && (4 / 2 < 3); // 50 > 6 - true, 4/2 < 3 - true, поэтому возвращается true
boolean a5 = (5 > 6) ^ (4 < 6); // 5 > 6 - true, поэтому возвращается true (4 < 6 - false)
boolean a6 = (50 > 6) ^ (4 / 2 < 3); // 50 > 6 - true, 4/2 < 3 - true, поэтому возвращается false

НазадВперед

Стиль оформления кода

Генератор псевдослучайных чисел

Существует негласные правила оформления стиля при написании кода. Старайтесь их придерживаться. Также запоминайте оформление кода в документации и справочниках. Например, принято записывать имена классов с большой буквы (class JavaQuickCourseActivity). Если имя состоит из нескольких слов, то каждое слово в имени также начинается с большой буквы. Использовать символы подчеркивания или тире нежелательно (Java_Quick_Course_Activity или Java-Quick-Course-Activity).

Для методов и переменных используется такой же формат, только первый символ записывается с маленькой буквы, например, resultButton.

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

На первых порах вам этого достаточно.

JavaScript Значения приоритета оператора

Встроенные функции python

Бледно-красные записи указывают на ECMAScript 2015 (ES6) или выше.

Значение	Оператор	Описание	Пример
20	( )	Группировка выражений	(3 + 4)

19	.	Член	person.name
19	[]	Член	person
19	()	Вызов функции	myFunction()
19	new	Создание	new Date()

17	++	Постфиксный инкремент	i++
17	—	Постфиксный декремент	i—

16	++	Префикс инкремента	++i
16	—	Префикс декремента	—i
16	!	Не логический	!(x==y)
16	typeof	Тип	typeof x

15	**	Возведение в степень (ES2016)	10 ** 2

14	*	Умножение	10 * 5
14	Деление	10 / 5
14	%	Остаток от деления	10 % 5

13	+	Сложение	10 + 5
13	—	Вычитание	10 — 5

12	<<	Сдвиг влево	x << 2
12	>>	Сдвиг вправо	x >> 2
12	>>>	Сдвиг вправо (без знака)	x >>> 2

11	<	Меньше чем	x < y
11	<=	Меньше или равно	x <= y
11	>	Больше чем	x > y
11	>=	Больше или равно	x >= y
11	in	Свойство в объекте	«PI» в Математике
11	instanceof	Экземпляр объекта	instanceof Array

10	==	Равно	x == y
10	===	Строгое равно	x === y
10	!=	Не равно	x != y
10	!==	Строгое не равно	x !== y

9	&	Побитовое AND	x & y
8	^	Побитовое XOR	x ^ y
7	\|	Побитовое OR	x \| y
6	&&	Логическое AND	x && y
5	\|\|	Логическое OR	x \|\| y
4	? :	Условие	? «Yes» : «No»

3	+=	Присваивание	x += y
3	/=	Присваивание	x /= y
3	-=	Присваивание	x -= y
3	*=	Присваивание	x *= y
3	%=	Присваивание	x %= y
3	<<=	Присваивание	x <<= y
3	>>=	Присваивание	x >>= y
3	>>>=	Присваивание	x >>>= y
3	&=	Присваивание	x &= y
3	^=	Присваивание	x ^= y
3	\|=	Присваивание	x \|= y

2	yield	Функция паузы	yield x
1	,	Запятая	5 , 6

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

❮ Prev
Next ❯

Пожалуйста, включите JavaScript для просмотра комментариев, предоставленных Disqus.

Тернарная операция

Приведение типов, оператор присваивания, функции alert, prompt, confirm

Операция «?:» называется тернарной, потому что он принимает три операнда.

<выражение_boolean> ? <выражение1> : <выражение2>

1	<выражение_boolean> ? <выражение1> : <выражение2>

Тернарная операция вычисляет
<выражение_boolean>, если оно равно
true, то вычисляет и возвращает
<выражение1>, а если
false, то
<выражение2> .

Java

class Main {
public static void main(String[] args) {
int x = 3 > 2 ? 5 : -3; // 5
String str1 = 3 == 2 ? «YES»: «NO»; //»NO»
System.out.println(x);
System.out.println(str1);
}
}

1
2
3
4
5
6
7
8

classMain{

publicstaticvoidmain(Stringargs){

intx=3>2?5-3;// 5

Stringstr1=3==2?»YES»»NO»;//»NO»

System.out.println(x);

System.out.println(str1);

}

Унарные операции

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

Постфиксные унарные операции ставятся после операнда:

Инкремент (увеличение на 1)
++
Декремент (уменьшение на 1)
—

Примеры:

Java

int x = 3;
short y = 100;
x++; // после выполнения x становится равным 4.
y—; // после выполнения y становится равным 99.

1
2
3
4

intx=3;

shorty=100;

x++;// после выполнения x становится равным 4.

y—;// после выполнения y становится равным 99.

Префиксные унарные операции ставятся перед операндом:

Унарный плюс (обозначает положительные числа, хотя числа положительными будут и без него)
+
Унарный минус (обозначает отрицательные числа)
—
Логическое НЕ (инвертирует значение логического типа, превращая
true в
false и наоборот)
!
Префиксный инкремент (увеличивает значение на 1)
++
Префиксный декремент (уменьшает значение на 1)
—

Примеры:

Java

int x1 = +10; // положительная десятка
int x2 = -x1; // -10

boolean b1 = true
boolean b2 = !b1; // false

++x1; // теперь x1 равен 11.
—x2; // теперь x2 равен -11

1
2
3
4
5
6
7
8

intx1=+10;// положительная десятка

intx2=-x1;// -10

booleanb1=true

booleanb2=!b1;// false

++x1;// теперь x1 равен 11.

—x2;// теперь x2 равен -11

Отличие постфиксного и префиксного инкремента и декремента

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

Пример:

Main.java

Java

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

int y1 = ++x1;
int y2 = —x2;

// Вывод для префиксных операций
System.out.println(«\nPrefix ++, — test»);
System.out.println(«x1=» + x1 + «; y1=» + y1);
System.out.println(«x2=» + x2 + «; y2=» + y2);

// Возвращаем исходные значения
x1 = 100;
x2 = 145;

int z1 = x1—;
int z2 = x2++;

// Вывод для постфиксных операций
System.out.println(«\nPostfix ++, — test»);
System.out.println(«x1=» + x1 + «; z1=» + z1);
System.out.println(«x2=» + x2 + «; z2=» + z2);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

classMain{

publicstaticvoidmain(Stringargs){

intx1=100;

intx2=145;

inty1=++x1;

inty2=—x2;

// Вывод для префиксных операций

System.out.println(«\nPrefix ++, — test»);

System.out.println(«x1=»+x1+»; y1=»+y1);

System.out.println(«x2=»+x2+»; y2=»+y2);

// Возвращаем исходные значения

x1=100;

x2=145;

intz1=x1—;

intz2=x2++;

// Вывод для постфиксных операций

System.out.println(«\nPostfix ++, — test»);

System.out.println(«x1=»+x1+»; z1=»+z1);

System.out.println(«x2=»+x2+»; z2=»+z2);

}

Не помню, описывал ли я это, но две косые черты
// означают комментарий. Компилятор игнорирует любой текст, находящийся правее
//, что позволяет записать какое-нибудь пояснение для будущего читателя программы. Строки
System.out.println выводят текст в консоль.

Этот пример выводит в консоль следующее:

Prefix ++, — test
x1=101; y1=101
x2=144; y2=144

Postfix ++, — test
x1=99; z1=100
x2=146; z2=145

1
2
3
4
5
6
7

Prefix ++, — test
x1=101; y1=101
x2=144; y2=144

Postfix ++, — test
x1=99; z1=100
x2=146; z2=145

Как видно из примера
y1 и
y2 стали равны значениям
x1 и
x2, которые получились после осуществления операций инкремента и декремента соответственно, а
z1 и
z2 стали равны значениям
x1 и
x2, которые были до операций инкремента и декремента.

По ссылке или по значению

У нас есть класс Cat

Попробуем, используя этот класс, передать объект Cat в метод и посмотреть, что получится:

Вызовем созданные методы и увидим, как работают объекты:

Я уже однажды расписывал операции в Java

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

Операция взятия остатка % в Java работает не только с целыми числами, но и с числами с плавающей точкой.

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

Это равенство действует даже в том случае, если левый операнд будет наименьшим отрицательным числом для своего типа, а операнд в правой части будет равен -1 (тогда результатом будет 0).

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

Если в правой части операции взятия остатка для целочисленных операндов в Java стоит 0, то результатом будет ArithmeticException .

Примеры работы операции взятия остатка для целочисленных операндов (выполнено в JShell):

Как я уже говорил, в Java операция взятия остатка % работает и с числами с плавающей точкой ( float и double ). Согласно спецификации языка Java операция взятия остатка для чисел с плавающей точкой работает не так, как это принято в IEEE 754, но если очень нужно то можно использовать метод Math . IEEEremainder .

В Java операция взятия остатка % работает согласно следующим правилам:

Если один из операндов равен NaN, то результат операции будет NaN.
Если результат не NaN, то знаком результата будет знак операнда в левой части.
Если операнд в левой части Infinity, или операнд в правой части равен нулю, или выполняются оба условия, то результат будет равен операнду в левой части.
Если операнд в левой части конечен, а операнд в правой части Infinity, то результат будет равен операнду в левой части.
Если операнд в левой части равен нулю, а операнд в правой части конечен, то результат будет равен операнду в левой части.
Во всех остальных случаях результат r взятия остатка от операнда n при делении на d определяется по математической формуле r = n — (d × q), где q будет целым числом, которое отрицательно только в случае, если n / d отрицательно, и положительно, если n / d положительно, и его размер максимально возможный, но не превышающий отношение n и d. Пример: 0,5 ÷ 0,3 = 1,6, тогда q будет положительным, так как 1,6 положительно, а наибольший размер, не превышающий 1,6 будет 1, то q = 1, а значит r = 0,5 — (0,3 × 1) = 0,2.

Операция взятия остатка для чисел с плавающей точкой никогда не приводит к возникновению Exception-ов.

Примеры операции взятия остатка для чисел с плавающей точкой:

В уроке 8 мы затронули логические операторы, они нам были необходимы для формирования логического выражения в условиях if. Этот урок будет посвящен математике в Java, и поэтому мы рассмотрим подробнее арифметические операторы и частично возможности класса Math.

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

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

Логическое И
&& и Логическое ИЛИ
|| ведут себя вполне ожидаемо для логического И или логического ИЛИ:

Java

boolean b1 = true && true; //true
boolean b2 = true && false; //false
boolean b3 = true || false; // true
boolean b4 = false || false; //false

System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);

1
2
3
4
5
6
7
8
9

booleanb1=true&&true;//true

booleanb2=true&&false;//false

booleanb3=true||false;// true

booleanb4=false||false;//false

System.out.println(b1);

System.out.println(b2);

System.out.println(b3);

System.out.println(b4);

Логическое И
&& вычисляет свой правый операнд только в том случае, если левый равен
true. Если левый операнд равен
false, то сразу возвращается
false. Логическое ИЛИ
|| вычисляет правый операнд только в том случае, если левый равен
false. Если левый операнд равен
true, то сразу возвращается
true. Эти два правила сокращения вычислений позволяют сразу откинуть последующие вычисления, если результат всего выражения уже известен. Это можно использовать для проверки на
null перед проверкой результата какого-либо метода объекта (будет описано в дальнейшем):

Java

if (obj != null && obj.method1()) { // obj.method1() будет вызывать только
// если проверка obj!= null вернула true.
}

1
2
3

if(obj!=null&&obj.method1()){// obj.method1() будет вызывать только

// если проверка obj!= null вернула true.

}