Типы данных в Java
Приведение типов
Коварное деление нацело

float a = 2.0f; 
/* 2.0f – буква f в конце указывает, что 2.0 понимается как float,
иначе 2.0 будет воспринято как double и Java выдаст ошибку, 
потому что, может быть, указанное число не влезает в количество цифр float */
double b = 2.0;
// по умолчанию любая дробь – это double, поэтому типы double b и 2.0 совпадают,
// и присваивание пройдёт без ошибок.

boolean res = true; // переменная res хранит "правду" - true
res = false; // теперь res хранит "ложь" - false

int x = 10;

res = x > 20; // 10 меньше 20, поэтому сравнение x больше 20 дает ложь

double a = 2.2;
// привести дробное a к целому b
int b = (int) a;
// скобки слева от имени переменной или от какого-либо числового выражения
// обозначают "привести это выражение к новому типу, указанному в скобках".

// привести точное выражение double к менее точному float
double a = 2.2
float x = (float) a*10;

int x = 1/3; 
// Будет ровно ноль! Дробная часть отбрасывается в int.
// Когда мы пишем числа без десятичной точки, то они сразу считаются как int
// 10 - это int
// 10.2 - это double

// сразу разберем нюансы:
int y = 10.2; // ошибка - справа дробное число 10.2 double, нужно явно привести тип к int
int z = (int) 10.2; // так правильно, дробная часть 0.2 будет отброшена

double u = 100; // сначала вычисляется выражение, здесь это просто число 100 - целое
// но чтобы приравнять дробное u к целому 100, делается неявное приведение типа.
// Поэтому u как была объявлена дробной double, так и останется ей навсегда.

int x = (1/3) * 15000000; 
//Будет снова ноль! Дробная часть отбрасывается в int еще при расчете 1/3

/*
 К слову, если в выражении есть double, то операции с ним уже будут идти как с дробным
 числом, то есть int на double - это double. Но важно учесть, что компилятор вычисляет 
 выражение слева направо, и если было int на int пока он еще не дошел до дробного числа, 
 то эта часть пройдет в целых числах.
 Например:
*/
int y = (1/3) * 15000000.0 ; // справа сначала 1/3 будет 0, на что ни умножай. 
// при этом мы помножили на дробное double, поэтому int на double будет double
// и компилятор скажет - ошибка, ведь чтобы int присвоить к double нужно явно привести тип:
int z = (int) ((1/3) * 15000000.0); // теперь ошибки нет, но z по-прежнему равно нулю

int u = (int) ((1.0/3) * 15000000); // теперь правильно 1.0/3 это одна треть, а не ноль,
// поскольку 1.0 - дробное и стоит в начале выражения, так что и все остальные 
// операции будут с дробными числами. 
// Снова явно приводим к int, хотим приравнять int u к double.

int a = 15000000 / 3; // мы сразу получим нужные 5 миллионов, вообще без дробных чисел

int b = (int) ( (1/3.0) * 15000000 ); 
// 3.0 – это дробное, тогда и 1/3.0 – это треть, а не ноль.
// Благодаря скобкам уже после расчета всего выражения 5 млн будет приведено к целым, 
// но оно и так целое, так что мы все посчитали точно.

int с = (int) (1.0/3) * 15000000; // будет опять чистый ноль, 
// так как сначала треть приведется к целому типу и обнулится - при равных приоритетах 
// без дополнительных скобок выражение вычисляется слева направо, то есть (int) раньше.

int d = (1.0/3) * 15000000; // ошибка компиляции, справа дробное, слева целое - 
// компилятор боится потерять точность без разрешения программиста.

int x = 1; 
int y = 3;
double z = 15000000 * x / y; // сначала вычисляется выражение с его собственным типом
// а сейчас в выражении целое x делится на целое y и получается машинный ноль.
// то что слева стоит double не поможет - уже вычисленное выражение равно нулю.

double x = 1; 
double y = 3;
double z = 15000000 * x / y; // деление x на y будет одна треть, потому что x и y - дробные.

char symbol = 'a';
        
System.out.println (symbol);
        
int code = (int) symbol;
        
System.out.println (code);