Тип double — вещественные числа

Causes of Error Code 0xc0000001

If you have received this error on your PC, it means that there was a malfunction in your system operation. Common reasons include incorrect or failed installation or uninstallation of software that may have left invalid entries in your Windows registry, consequences of a virus or malware attack, improper system shutdown due to a power failure or another factor, someone with little technical knowledge accidentally deleting a necessary system file or registry entry, as well as a number of other causes. The immediate cause of the “Error Code: 0xc0000001” error is a failure to correctly run one of its normal operations by a system or application component.

Переменные

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

int x; // объявлена переменная под именем x
int y; // объявлена переменная под именем y

Как следует из названия, переменные могут меняться (точнее их значения). Проведём аналогию с кошачьим приютом. Котов привозят в приют, потом добрые люди забирают котов из него. Получается, что коты постоянно меняются, а приют остаётся.

Переменные могут быть двух видов

• примитивные типы: int, float, double, char и другие, которые представляют собой числа, символы
• объекты, которые представляют классы

Список переменных примитивных типов рассматривается в следующей статье.

Переменной можно присвоить начальное значение (инициализировать) через знак равенства и указанием значения. Указываемое значение должно подходить типу, который вы указали для переменной. Для объявления нескольких переменных одного типа можно использовать запятые:

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

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

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

Переменные создаются при входе в их область видимости и уничтожаются при выходе из неё. Иными словами, переменная утратит своё значение сразу после выхода из области видимости. Поэтому, переменные, которые объявлены внутри метода, не будут хранить свои значения между обращениями к этому методу.

Если объявление переменной содержит инициализацию, то инициализация будет повторяться при каждом вхождении в блок, в котором она объявлена. Допустим, у нас есть блок:

При каждом вхождении в цикл переменной присваивается снова и снова значение 42. И хотя потом переменной присваивается значение 54, оно теряется при повторном вхождении в блок.

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

Основные арифметические операции

В следующей таблице перечислены основные арифметические операции, применяемые в языке Java:

Рассмотрим некоторые правила работы с арифметическими операциями:

• Выражения вычисляются слева направо, если не добавлены круглые скобки или одни операции имеют более высокий приоритет.
• Операции *, /, и % имеют более высокий приоритет чем + и -.

Пример 1. Арифметические операции над целочисленными значениями

Например, в этом коде, переменные a
и b
будут иметь разные значения:

Public class BasicIntMath {
public static void main(String args) {
int a = 4 + 5 — 2 * 3;
int b = 4 + (5 — 2) * 3;
System.out.println(«a = » + a);
System.out.println(«b = » + b);
}
}

Результат выполнения:

A = 3
b = 13

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

Пример 2. Унарные операции сложения и вычитания

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

Пример 3. Деление целочисленных чисел

Результат выполнения этой программы:

Операнды арифметических операций должны иметь числовой тип. Арифметические операции нельзя выполнять над логическими типами данных, но допускается над типами данных char
, поскольку в Java этот тип, по существу, является разновидностью типа int
.

Результат выполнения:

N
111
22

Пример 5. Арифметические операции над переменными типа char

Результат выполнения:

Оператор деления по модулю — обозначается символом %. Этот оператор возвращает остаток от деления первого числа на второй. При делении целого числа результатом будет тоже целое число.

Java Integer Math

Математические операции, выполняемые с целочисленными типами Java (byte, short, int и long), ведут себя немного иначе, чем обычные математические операции. Поскольку целочисленные типы не могут содержать дроби, в каждом вычислении с одним или несколькими целочисленными типами все дроби в результате обрезаются. Посмотрите на это математическое выражение:

int result = 100 / 8;

Результат этого деления будет 12,5, но так как два числа являются целыми числами, фракция .5 обрезается. Результат, следовательно, всего 12.

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

С плавающей точкой Math

Java содержит два типа данных с плавающей точкой: float и double. Они могут содержать дроби в числах. Если нужны дробные выражения в математических выражениях, вы должны использовать один из этих типов данных. Вот пример математического выражения с плавающей точкой:

double result = 100 / 8;

Несмотря на то, что переменная результата теперь имеет тип с плавающей запятой (double), конечный результат по-прежнему равен 12 вместо 12,5. Причина в том, что оба значения в математическом выражении (100 и 8) оба являются целыми числами. Таким образом, результат деления одного на другое сначала преобразуется в целое число (12), а затем присваивается переменной результата.

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

double no1 = 100;
double no2 = 8;

double result = no1 / no2;

Теперь переменная результата будет иметь значение 12,5.

В Java есть способ заставить все числа в расчете быть переменными с плавающей точкой. Вы ставите числа с большой буквы F или D. Вот пример:

double result = 100D / 8D;

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

На самом деле вы также можете сделать число длинным, добавив суффикс числа к верхнему регистру L, но long по-прежнему является целочисленным типом, поэтому он не будет сохранять дробные части в вычислениях.

Точность с плавающей точкой

Типы данных с плавающей точкой не являются точными на 100%. Вы можете столкнуться с ситуациями, когда числа со многими дробями не складываются с ожидаемым числом. Если вычисление с плавающей запятой приводит к числу с большим количеством дробей, чем может обработать число с плавающей запятой или двойное число, дроби могут быть обрезаны. Конечно, заданная точность может быть более чем достаточной для многих типов вычислений, но имейте в виду, что дроби могут фактически быть отсечены.

Посмотрите:

double resultDbl3 = 0D;
System.out.println("resultDbl3 = " + resultDbl3);

for(int i=0; i<100; i++){
    resultDbl3 += 0.01D;
}
System.out.println("resultDbl3 = " + resultDbl3);

Вывод выводится при выполнении этого кода с Java 8:

resultDbl3 = 0.0
resultDbl3 = 1.0000000000000007

Первый оператор System.out.println() правильно печатает значение 0.0, которое является начальным значением переменной resultDbl3.

Однако второй оператор System.out.println() выводит несколько странный результат. Добавление значения 0,01 к 0 всего 100 раз должно привести к значению 1,0, верно? Но каким-то образом окончательный результат 1.0000000000000007. Как видите, что-то не так во фракциях.

Обычно неточность с плавающей запятой незначительна, но все же важно знать об этом

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

Операция «=» позволяет присвоить значение переменной:

Java

int x = 3;
long l1 = 10_000_000_000L;
float f1 = 1.3f;
double weight = 81.34;
byte b1 = 100;
short sh1 = -10000;
char ch1 = 60000;

1 2 3 4 5 6 7

intx=3; longl1=10_000_000_000L; floatf1=1.3f; doubleweight=81.34; byteb1=100; shortsh1=-10000; charch1=60000;

КОНСТАНТНЫЕ значения до
int  можно присвоить без приведения типа к переменным меньшего размера (например
short  в
byte), если значение помещается в эту переменную.

Вы можете присвоить переменной, имеющей больший тип, значение меньшего типа, например переменной типа
double  можно присвоить значение
int, но не наоборот (но можно использовать приведение типа, если очень нужно).

Примеры:

Java

double d1 = 2; // Это можно
int x = 2.3; // так нельзя. Будет ошибка компиляции.

byte b1 = 100; //Это можно, так как литерал 100 гарантировано
// поместится в byte.

byte b2 = 10000; //Нельзя. Ошибка компиляции.

int n = 100;
byte b3 = n; //А вот так тоже нельзя, так как
// переменная n имеет тип int.

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

doubled1=2;// Это можно intx=2.3;// так нельзя. Будет ошибка компиляции. byteb1=100;//Это можно, так как литерал 100 гарантировано // поместится в byte. byteb2=10000;//Нельзя. Ошибка компиляции. intn=100; byteb3=n;//А вот так тоже нельзя, так как // переменная n имеет тип int.

Операция присваивания возвращает значение, которое присвоила, поэтому можно присваивать значение сразу нескольким переменным по цепочке:

Java

int x;
int y;
int z = x = y = 10; // y, x и z будет присвоено 10.

1 2 3

intx; inty; intz=x=y=10;// y, x и z будет присвоено 10.

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

Логический операндtruefalse

• — логический операнд, его значение равно false
• — логический операнд, значение которого, очевидно, true
• — тоже может быть логическим операндом, как и Boolean a
• — не является логическим операндом, это просто переменная типа
• также не является логическим операндом. Это строка, текстовое значение которой — .

• Логическое отрицание, оно же или инверсия. В Java обозначается символом “” перед операндом. Применяется к одному операнду.
• Логическое и, оно же или конъюнкция. Обозначается символом “” между двумя операндами, к которым применяется.
• Логическое или в Java, оно же — , оно же — дизъюнкция. В Java обозначается символом “” между двумя операндами.
• Исключающее или, , строгая дизъюнкция. В Java обозначается символом “” между двумя операндами.
• В Java к логическим операторам можно отнести условное или, обозначаемое как , а также условное и — .

Примечание:Внимание!

Оператор Java	Имя	Тип	Краткое описание	Пример
	Логическое “не” (отрицание)	Унарный	означает “не x”. Возвращает true если операнд является false. Возвращает false если операнд является true.	Тогда
	Логическое И (, умножение)	Бинарный	Возвращает true если оба операнда равны true.	тогда
	Логическое ИЛИ (, сложение)	Бинарный	Возвращает true если хотя бы один из операндов равен true.	тогда
	Логическое исключающее ИЛИ ()	Бинарный	Возвращает true, если один и только один из операндов равен true. Возвращает false, если оба операнда равны true или false. По сути, возвращает true, если операнды — разные.	тогда
	Условное И (сокращённое логическое И)	Бинарный	То же самое, что и , но если операнд, находящийся слева от является false, данный оператор возвращает false без проверки второго операнда.
	Условное ИЛИ (сокращённое логическое ИЛИ)	Бинарный	То же самое, что и , но если оператор слева является true, оператор возвращает true без проверки второго операнда.

Логические операции в курсе JavaRush Без логических операций никуда не деться, и в курсе JavaRush они появляются с первых уровней, вместе с условиями и типом данных boolean. Пользоваться методами математической логики программисты приучаются постепенно. Для более уверенных манипуляций с логическими конструкциями требуется определённая сноровка и понимание некоторых процессов. Так что подробнее и уже на совсем другом уровне к этим операциям подходят в конце квеста Multithreading, когда большинство студентов уже не слишком отвлекается непосредственно на синтаксис и конструкции, а старается вникать в суть задачи.

Планы команды IntelliJ Platform на 2020 год

Сегодня мы хотели бы рассказать о некоторых из текущих проектов команды IntelliJ Platform, которые затронут IntelliJ IDEA и другие IDE на базе нашей платформы. Результаты этих проектов будут выпускаться в течение следующего года; некоторые из них попадут уже в релиз 2020.1, который выйдет весной. Проекты, о которых мы хотели бы рассказать, касаются двух больших областей: производительности и поддержки современных сценариев разработки.

Скорость индексации

Индексация на данный момент — одно из самых проблемных мест с производительностью наших IDE. Мы планируем подойти к ее решению с нескольких направлений.
Во-первых, мы планируем поддержать готовые фрагменты индекса. Теперь вместо того, чтобы каждая копия IntelliJ IDEA заново индексировала класс java.lang.String, мы сможем предоставить для скачивания готовый фрагмент индекса для JDK, который можно будет переиспользовать без дополнительных затрат CPU. Помимо JDK, мы изучаем возможность предоставлять готовые фрагменты индекса для библиотек из Maven Central, а также для интерпретаторов и пакетов в других IDE. Мы также хотели бы позволять командам и организациям использовать готовые фрагменты индекса для кода своих проектов, но у нас пока нет на этот счет конкретных планов.

Объявление и инициализация переменных

В общем случае при объявлении переменной в C#, вначале указывается тип данных переменной, затем ее имя:

int nVal;
string strVal;

Задание значения переменной можно произвести в момент инициализации:

int radius = 10;
string name = "John";

либо после инициализаций:

string name;
name = "John";

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

int notInitedVal;
Console.Write(notInitedVal);

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

Ключевое слово new

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

class Rectangle
{
    public double Width = 0;
    public double Height = 0;
}

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

Создадим переменную класса Rectangle

Rectangle rect = new Rectangle();
Console.WriteLine($"Rectangle Width={rect.Width}, Height={rect.Height}");

Переменные типа int, double и т.п. также можно проинициализировать с помощью ключевого слова new, в этом случае будет присвоено значение по умолчанию:

int newInitedValue = new int();
Console.WriteLine("Default int value: " + newInitedValue);

Ключевое слово var. Неявная типизация

При объявлении переменной вместо явного задания типа можно поставить ключевое слово var. В этом случае будет использована система вывода типов для определения типа переменной по ее значению.

int v1 = 12345;
var v2 = 12345;

Console.WriteLine($"Type of v1: {v1.GetType()}\nType of v2: {v2.GetType()}");

При работе с var необходимо помнить следующее:

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

Static

• Модификатор Static используется для создания чего-то в единственном экземпляре. Например, когда мы хотим создать переменную или объект, доступные для всех объектов класса.
• Static необходим для передачи информации по всем объектам.
• Static подходит для переменных, методов и блоков.
•  или переменные принадлежат классу, а не объекту.
• Статичный метод или переменная инициализируются один раз перед переменной экземпляра.
• Статичный метод или переменная могут вызываться напрямую из имени класса. Пример: <className>.<variableName>
• Статичный метод имеет доступ только к статичным данным.
• Статичный метод не может ссылаться на this или super.
• Статичный метод может вызывать только другие статичные методы.
• main () — это статичный метод. Он должен быть доступен приложению до создания экземпляров.
• Конструктор не бывает статичным, потому как компилятор считает его методом. Кроме того, конструктор нужен для инициализации нового объекта, а static выполняет совершенно противоположную функцию.
• Статичная переменная загружается первой. После нее идет статичный блок. И очередность здесь важна. Статичные методы загружаются в конце.

· Иерархия следующая:

3 String Pool

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

Во-первых, строки, заданные в коде, нужно все-таки где-то хранить. Код — это команды, а данные (тем более такие большие как строки) нужно хранить в памяти отдельно от кода. В коде фигурируют только ссылки на объекты-строки.

Во-вторых, все одинаковые литералы можно хранить в памяти только один раз. Так оно и работает. Когда код вашего класса загружается Java-машиной, все строковые литералы добавляются в , если их там еще нет. Если уже есть, просто используется ссылка на строку из .

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

Как это примерно работает:

Код	Работа с StringPoll

Именно поэтому переменные и будут хранить одинаковые ссылки.

Метод

Ну и самое интересное: вы можете программно добавить любую строку в . Для этого нужно просто вызвать метод у -переменной.

Метод добавит строку в , если ее еще там нет, и вернет ссылку на строку из .

Код	Примечание

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

Запрещенные темы для публикаций

Работа с типом doubleWork with the double type

Числовой тип представляет число с плавающей запятой двойной точности.The numeric type represents a double-precision floating point number. Эти термины могут быть новыми для вас.Those terms may be new to you. Число с плавающей запятой можно использовать для представления нецелых чисел, которые могут быть очень большими или малыми.A floating point number is useful to represent non-integral numbers that may be very large or small in magnitude. Число двойной точности — это относительный термин, описывающий количество двоичных разрядов, используемых для хранения значения.Double-precision is a relative term that describes the number of binary digits used to store the value. Числа двойной точности имеют в два раза больше двоичных символов по сравнению с числами одиночной точности.Double precision numbers have twice the number of binary digits as single-precision. На современных компьютерах числа двойной точности используются чаще, чем одиночной.On modern computers, it’s more common to use double precision than single precision numbers. Числа одиночной точности объявляются с помощью ключевого слова .Single precision numbers are declared using the keyword.
Рассмотрим их.Let’s explore. Добавьте следующий код и просмотрите результат:Add the following code and see the result:

Обратите внимание, что ответ включает десятичную долю частного.Notice that the answer includes the decimal portion of the quotient. Попробуйте более сложное выражение с типом double:Try a slightly more complicated expression with doubles:. Диапазон значений типа double гораздо больше, чем диапазон значений целых чисел.The range of a double value is much greater than integer values

Добавьте следующий фрагмент после написанного кода:Try the following code below what you’ve written so far:

Диапазон значений типа double гораздо больше, чем диапазон значений целых чисел.The range of a double value is much greater than integer values. Добавьте следующий фрагмент после написанного кода:Try the following code below what you’ve written so far:

Значения выводятся в экспоненциальном представлении.These values are printed out in scientific notation. Число слева от символа является значащим.The number to the left of the is the significand. Число справа — это показатель степени, который равен 10.The number to the right is the exponent, as a power of 10.

Так же, как десятичные числа в математике, значения double в C# могут содержать ошибки округления.Just like decimal numbers in math, doubles in C# can have rounding errors. Выполните этот код:Try this code:

Вы знаете, что периодическая десятичная дробь не равняется .You know that repeating isn’t exactly the same as .

ЗадачаChallenge

Выполните другие вычисления с большими числами, малыми числами, умножением и делением с помощью типа .Try other calculations with large numbers, small numbers, multiplication, and division using the type. Попробуйте выполнить более сложные вычисления.Try more complicated calculations.

После того как вы решите сложную задачу, поместите написанный код в новый метод.After you’ve spent some time with the challenge, take the code you’ve written and place it in a new method. Присвойте этому методу имя .Name that new method .

Нам доверяют

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

Последнее обновление: 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

НазадВперед

Приоритет оператора Java Math

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

Математические операторы * и / для умножения и деления имеют приоритет над операторами + и -. Это означает, что умножения и деления вычисляются перед сложением и вычитанием в математических выражениях. В случае наличия нескольких операторов * и / они будут рассчитаны слева направо. Посмотрите на это математическое выражение:

int result = 100 * 100 / 5 + 200 * 3 / 2;

Сначала выполняются умножения и деления. Есть две группы из трех умножений и делений. Каждая группа выполняется слева направо:

100 * 100 = 10000;
10000 / 5 = 2000;

200 * 3 = 600;
600 / 2 = 300;

После вычисления умножения и деления математическое выражение выглядит так:

int result = 2000 + 600;

Теперь сложения и вычитания выполняются. Таким образом, значение, присвоенное переменной результата, равно 2000 + 600 = 2600.

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

int result = 100 * 100 /(5 + 200) * 3 / 2;

Значение 100 все еще умножается на 100 (= 10 000), но теперь оно делится на 5 + 200 (= 205) вместо 5. После этого деления результат умножается на 3, а затем делится на 2. Результат выполнения 72 (округление вычислений влияет на результат).