Подробности о примитивных типах.

1. Логический тип boolean.

 Может принимать только два значения «true» и «false». По сути это 1 и 0. В другие типы, например в тип int не конвертируется.

Обычно булевский тип возникает в результате выполнения операций сравенения, которых в java шесть штук:

 <          меньше

>          больше

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

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

= =      равно

! =       не равно

 Пример:

 boolean a = 1 < 5;

              System.out.println("а="+a);

 На экране будет напечатано:

-------------------

a = true

 Над булевскими типами можно проводить логические операции

 !           отрицание ( логическое НЕ)

&&      логическое И

||          логическое ИЛИ (дизъюнкция)

^          исключающее ИЛИ 

2. Целочисленные типы.

 В java все челочисленные типы имеют фиксированную размерность, не зависящую от платформы выполнения и определенный диапазон значений (см. таблицу).

Целочисленные типы можно записывать в разных форматах.

 int dec = 100;   (десятичный формат)

int oct =  0123;  (восьмеричный формат, префикс - 0)

int hex =  0xFA;  (шестнадцатеричный формат, префикс – 0х)

int bin  =  0b11001101  (двоичный формат, префикс – 0b)

long bignumb  =  10_000_000_000L  (формат записи Long, постфикс L)

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

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

 int  ostatok =  a % b;

 а также унарные – увеличение на 1 или уменьшение на 1.

 int b = b--;

int a = a++; 

 (Обратите внимание, если будет записано так: ++а, то унарный оператор вернет значение а, и только после этого увеличит а на единицу. Если а++, то вначале увеличит, потом вернет увеличенное значение).

 Используетеся также сокращенная запись выражений, например,

 A = A + В;  эквивалентно записи А +=  В;

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

 byte a = 127;

byte b = 1;

         a = a + b;

 А вот такой же по сути код, ошибки не вызовет:

 byte a = 127;

         a = a++;

 Вместо этого значение a станет отрицательным и будет уменьшено на единицу.

То есть, код будет делать совсем не то, что от него ожидают.

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

 Над операндами типа int можно производить побитовые логические операции:

 int  ne = ^a;     (логическое отрицание или инверсия битов)

int and = a & b;  (логическое И)

int or = a | b;               (логическое ИЛИ)

int xor  =  a  ^ b;         (логическое XOR)

int shift_right  =  a >> b;   (арифметический сдвиг вправо на b число битов)

int  shift_left  =  a << b;         (арифметический сдвиг вправо на b бит)

 Для логических операций также применим сокращенный способ записи, аналогично арифметическим операциям:

  a &= b;  эквивалентно  a = a & b;

 

1. Целочисленный тип char.

 Этот тип стоит рассмотреть отдельно. С одной стороны он относится к целочисленным типам и к нему применимы все те же арифметические и логические операции, что и ко всем другим арифметическим типам. С другой стороны, тип char используется в основном для хранения одиночных символов. Это могут быть любые символы Unicode, а могут быть и спецсимволы, предверяемые в записи обратным слешем. Примеры:

 char  a = ‘a’;

car  perevod_stroki  =  ‘\n’;

char  tabulator  =  ‘\t’;

char  back_slash  =  ‘\\’;

char  simbol_unicode  =  ‘\u02F6’;

 

2. Вещественные типы float и double.

 В памяти java – машины вещественное число представляется в виде совокупности

 (знак +/-) mantissa * 2 ^ е

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

Переменные вещественного типа могут иметь различные формы записи:

 double  a  =  1.2345               (простая форма записи)

double exp_a  =  12.345e-3   (экспоненциальная форма)

float  a  =  123.45f                 (явное указание типа float)

double  a  =  1.234d               (явное указание типа double)

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

Арифметика вещественных чисел реализованная в java имеет набор особых операций, связанных с бесконечностями, которые в java считаются обычными числами и допускают выполнение математических операций над ними.

Например:

  (+/-)1.0/0.0  =  (+/-) ∞

 ∞ + 1 = ∞

 1/∞ = 0

 Кроме того, деление 0/0 = специальному значению nan

 double  nan  =  0.0/0.0;

 nan – это специальное числовое значение «не определено». Получается  в следующих случаях:

 double  nan  =  0.0/0.0;

 double  nan  =  +∞ - ∞;

 double  nan  =  0 * ∞;

 Любые арифметические операции с участием nan дают nan.

А самое интересное здесь то, что nan не равен самому себе

 nan  !=  nan

 То есть, если в какой-либо переменной «a» в результате вычислений по вашему мнению, должно содержаться значение 0, не удивляйтесь, если при сравнении этой переменной с 0 вы получите значение «false». То есть:

 double  a  = 0.0/0.0;

boolean  b  = (a = = 0);   (false!!!)

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

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

Функции ограничения точности, как и многие другие математические константы и функции содержатся в классе Math.  

Если есть необходимость работать с большими числами, состоящими из произвольного количества цифр, в пакете java.math представлены классы BigInteger и BigDecimal

Для преобразования обычного числа в число с произвольной точностью (называемое большим числом) вызывается статический метод valueOf():

 BigInteger bigIntegerA = BigInteger.valueOf(32);

При работе с большими числами типа BigInteger вместо использования привычных математических операций  + или * и т.п. следует использовать специальные методы add() (сложение), multiply() (умножение), divide() (деление) и т.д.

BigInteger bigIntegerA = BigInteger.valueOf(32);

BigInteger bigItBigIntegerB = bigIntegerA.add(bigIntegerA);

BigInteger bigIntegerC = bigIntegerA.multiply(bigIntegerA);