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

Поиск на других ресурсах:

1. Какие группы операций поддерживаются в Java?

Язык программирования Java поддерживает большой набор операций. Операции используются в выражениях.

Все операции делятся на 5 групп:

арифметические операции (+, —, *, / и прочие);
поразрядные логические операции (~, &, | и прочие);
логические операции (&, |, &&, || и прочие);
операции отношения (==, !=, >, < и прочие);
дополнительные операции для особых случаев.

⇑

2. Какие особенности использования арифметических операций?

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

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

Арифметические операции можно выполнять также над типом char.

Запрещается выполнять арифметические операции над логическими типами данных (boolean).

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

Операция       Описание
------------------------------------------------
   +           Сложение (а также унарный плюс)
   -           Вычитание (а также унарный минус)
   *           Умножение
   /           Деление
   %           Остаток от деления
   ++          Инкремент(прирост на 1)
   --          Декремент (прирост на 1)
   +=          Сложение с присваиванием
   -=          Вычитание с присваиванием
   *=          Умножение с присваиванием
   /=          Деление с присваиванием
   %=          Остаток от деления с присваиванием

⇑

3. Пример использования арифметических операций +, –, *, /

// арифметические операции '+', '-', '*', '/'
// целочисленные типы
int a,b;
long l;
a = 8;
b = -5;

l = a + b; // l = 3
l = a - b; // l = 13
l = a * b; // l = -40
l = a / b; // l = -1 - деление нацело

// вещественные типы
float f1, f2;
double d;

f1 = 3.5f;
f2 = 10.0f;
d = f1 + f2; // d = 13.5
d = f1 - f2; // d = -6.5
d = f1 * f2; // d = 35.0
d = f1 / f2; // d = 0.3499999940395355

// целочисленные и вещественные типы
a = 5;
f1 = 3.2f;
d = a * f1; // d = 16.0
d = a + f1; // d = 8.199999809265137
d = a - f1; // d = 1.7999999523162842
d = a / f1; // d = 1.5625

// тип char
char c = 'A';
c = (char)(c + 1); // c = 'B'
int code;
code = (int)(c + 1); // code = 67

⇑

4. Пример использования операции % остатка от деления

Операция % возвращает остаток от деления. Эту операцию можно применять:

к целочисленным типам данных (byte, short, int, long);
к типам данных с плавающей запятой (float, double).

Так, например, если поделить 8 на 5, то остаток от деления будет равен 3.

// % - остаток от деления
// целочисленные типы
byte b;
b = 8 % 5; // b = 3
b = 8 % 4; // b = 0

int a;
a = 15;
b = (byte)(8 % a); // b = 8

// вещественные типы
float f1, f2;
double d;

f1 = 3.5f;
f2 = 10.0f;
d = f1 % f2; // d = 3.5

f2 = 0.5f;
d = f1 % f2; // d = 0.0

f2 = 1.2f;
d = f1 % f2; // d = 1.1

// целочисленные и вещественные типы
int x = 5;
float ff = 3.5f;
double dd;
dd = x % ff; // dd = 1.5

⇑

5. Пример применения операций инкремента ++ и декремента — —

Операция инкремента ‘++‘ увеличивает значение операнда на 1.

Операция декремента ‘—‘ уменьшает значение операнда на 1.

// инкремент '++', декремент '--'
// целочисленные типы
long x = 9;
x++; // x = 10

x = -15;
x--; // x = -16

// вещественные типы
float f;

f = 2.3f;
f++; // f = 3.3

f = -3.85f;
f--; // f = -4.85

Операцию инкремента

a++;

можно заменить

a = a + 1;

Также операцию декремента

a--;

можно заменить

a = a - 1;

⇑

6. Какое отличие между префиксной и постфиксной формой применения операций инкремента (++) и декремента (––)

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

В префиксной форме (++a или —a) последовательность выполнения операций следующая:

увеличивается (уменьшается) значение операнда a на 1;
результирующее значение операнда a используется в выражении.

В постфиксной форме (a++ или a—) последовательность выполнения операций следующая:

предшествующее значение операнда a используется в выражении;
увеличивается (уменьшается) значение операнда a на 1.

Пример.

// инкремент '++', декремент '--'
// целочисленные типы
int a, b;
a = -6;
b = a++; // b = -6; a = -5

a = -6;
b = ++a; // b = -5; a = -5

a = 3;
b = a--; // b = 3; a = 2

a = 3;
b = --a; // b = 2; a = 2

// вещественные типы
float f;
double d;
f = 5.7f;
d = ++f; // d = 6.7; f = 6.7

В данном примере строка

b = ++a;

означает, что:

сначала увеличивается значение операнда a;
потом результирующее значение присваивается переменной b.

Строка

b = a++;

означает, что:

сначала значение a присваивается переменной b;
затем значение a увеличивается на 1.

⇑

7. Примеры применения составных арифметических операций с присваиванием +=, -=, *=, /=, %=

Составные арифметические операции с присваиванием имеют 2 преимущества:

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

Общий вид составной операции с присваиванием:

переменная операция = выражение;

Такая операция заменяет стандартную форму присваивания:

переменная = переменная операция выражение;

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

// целочисленные типы
int a;

a = 7;
a += 8; // a = a + 8 = 15

a = -3;
a -=5; // a = a - 5 = -3 - 5 = -8

a = 10;
a *= 3; // a = 30

a = 20;
a /= 5; // a = 4

a = 30;
a %= 7; // a = 30 % 7 = 2

// вещественные типы
float f;

f = 3.5f;
f += 2*f; // f = f + 2*3.5 = 10.5

f = -8.0f;
f -= f;  // f = f - f = 0.0

f = 6.5f;
f %= 2; // f = 0.5

BestProg

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