Объявляем переменные,
вычисляем выражения
Операторы +=, -=, *=,/=, ++, --

// Объявим по одной переменной для каждого вида расходов
// Слева от равно пишем double - значит у нас будет дробное число
// transp - имя переменной, мы его выбрали сами
// Справа от равно - начальное значение
double transp = 100;   // на транспорт за один день тратим порядка 100 рублей
double food = 500;      // на еду за один заход в магазин в среднем 500 рублей
double dress = 2000; // на одежду - 2000

//Начальное значение переменной result вычислим по выражению:
double result = transp*365 + food*2*4*12 + dress*5;

// То есть 365 раз за год потратились на транспорт, 
// еду покупали 2 раза в неделю, а недель 4 в месяце, а месяцев 12, 
// одежду купили 5 раз в год. 
// Теперь переменная result хранит сумму затрат за год - можно ее распечатать, 
// сравнить с другими переменными или использовать в дальнейших расчетах. 
// Удобно, что теперь мы можем менять значения исходных данных, 
// и смотреть, как это отразится на итоговом результате.

int x = 10;

int x = 10;
x = 200; //изменить значение икс - забыть 10, и запомнить 200
//слева int не указан, значит мы используем уже объявленную переменную

int x = 100;
int x = 300; 
// ошибка - указав int, мы говорим "объявить новую x", но переменная x уже объявлена

// Создадим другую переменную с именем y
int y = 100;
// Объявим ее еще раз с другим типом
double y = 200.5; // ошибка - переменная y уже была раньше объявлена.
// Теперь, когда мы указали новый тип, компилятор просто не может определиться,
// что же имелось в виду, y - целое, или y - дробное. Вы можете получить ошибку 
// ambiguous name, то есть многозначное имя. 

package javaapplication1;
public class JavaApplication1 {
public static void main(String[] args) {
//вызовем функцию println
  System.out.println ("Щас будем вычислять!");
// Объявим переменную x целого типа, равную 10
  int x = 10;
// Объявим переменную y целого типа, равную 30
  int y = 30;
// Объявим переменную z, равную выражению:
  int z = x + y /2;
// Распечатаем значение z – это будет 25
  System.out.println (z);
// Изменим z снова, пусть оно будет теперь x/2
  z = x / 2;
// Выведем на экран новое значение z – это будет 5
  System.out.println (z);

// Можно объявить несколько переменных в одной строчке
  int a = 10, b = 20;
/* В принципе можно объявить переменную без начального значения, 
но Java ударит вас по рукам, если вы позже не присвоите ей значение. 
Лучше так не делать, потому что от переменных без начального значения пользы никакой,
а навредить они могут сильно – если вдруг Java не заметит, что вы её используете, 
то вы получите непредсказуемое поведение программы, 
каждый раз разное – эту ошибку очень сложно отловить, 
иногда на её поиск уходят недели. */
  int w; // Лучше не надо, поверьте..
  w = 5;
// Объявим переменную дробного типа double
  double some = 0.5;
// Изменим значение переменной some на новое
  some = 1.5;
// Сделаем some равной y
  some = y;
// Объявим символ с равным коду буквы b
  char c = ‘b’;
/* Здесь можно писать только одну букву или цифру в одинарных кавычках. 
Символы нельзя складывать, зато из них можно делать строки и тексты – 
мы займемся этим на следующих уроках*/

// Объявим дробное d, равное 2.5
  double d = 2.5;
/* Используем саму переменную, чтобы например, увеличить ее на 5: */
  d = d + 5;       
// теперь d равно 7.5, старое значение забыто
 }   
/* В конце переменные, объявленные в main, удаляются - 
так происходит всегда по достижении конца блока фигурных скобок, 
внутри которого они были объявлены */
}
/* По сути переменная – это число, записанное в ячейке памяти компьютера. 
Объявить переменную – значит назвать эту ячейку именем. 
Имя может быть одной буквой, а может быть и словом. 
Вы можете поменять число, сидящее в ячейке, 
или использовать его для вычисления других чисел. 
Это очень удобно, иначе вам пришлось бы указывать «вон то число», 
а потом «вот это число», чтобы сделать любые вычисления. 
Так писали программы в 80ых годах прошлого века – 
это было настолько неудобно, что элементарный калькулятор приходилось писать месяцами. 
Теперь, заводя переменные, мы пишем его за несколько минут. */

int x = 10;
// Увеличим x на 10
x = x + 10;
// Ту же фразу можно записать короче с оператором +=
x += 10;

double y = 12;
double z = 3;
// Поделим y на 3 и запишем новое значение в y
y /= z;
// Умножим на 4, затем на (z-2)
y *= 4;
y *= z-2;
/* Все это допустимые операции, их удобно делать с операторами +=, -=, *=, /=          */

int x = 10;

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

x ++; // теперь x равен 12

x --; // теперь x снова 11

int a = 10; // зададим a и b равным 10
int b = 10;
        
// a++ означает в выражении использовать старое значение a, но в потом a увеличить
int y = 5 + a++; // итого будет 5+10
// ++b означает уже в выражении увеличить b
int z = 5 + ++b; // итого будет 5 + 11
        
System.out.println (a);
System.out.println (b);
System.out.println (y);
System.out.println (z);
        
/* Вывод программы:
11
11
15
16
*/

// вариант с использованием x ++ 
// постфиксная запись, как бы "увеличить x после" выражения
int x = 10; 
int y = 5 + x++;
// будет эквивалентно следующему:
int x = 10; 
int y = 5 + x; // в выражении старое значение
x += 1; // уже после выражения мы увеличим x

// а теперь то же самое с использование x-- 
// префиксная запись, как бы "увеличить перед" выражением
int x = 10; 
int y = 5 + ++x;
// будет эквивалентно следующему:
int x = 10; 
x += 1; // перед выражением мы увеличим x
int y = 5 + x; // в выражении новое увеличенное значение

// Начинающим обучение можно лишний раз не думать об разнице x++, ++x
// Просто не пишите их прямо в выражения, и считайте, что это просто "увеличить на 1"
// Но если где-то встретите, то будете готовы :)

double x =  10 + 5 * 2 - 3; // будет конечно 10+10-3, то есть 17

double y = (10 + 5) * 2 - 3; // теперь есть скобки , поэтому 15*2 - 3, то есть 27

double z = 100 / 4 * 2 + 5; 
// при равнозначном приоритете компилятор читает слева направо:
// получится 100/4 - это 25, умножить на 2 - это 50, и добавить 5 - в итоге z=55

// Очень советую поэкспериментировать в коде с такими выражениями. 
// Усложняйте их постепенно, используйте старые значения переменной в новом выражении. 
// Несколько полезных примеров:

z = z*z; // получается, возвести z в квадрат,
// поскольку мы взяли старое значение, умножили его само на себя и записали в z.
// Аналогично можно возвести в куб и вообще в любую степень:
x = x*x*x ; // возвели x в куб.

// Также можно получить обратную к исходной величину:
x = 1 / x; // но помните, что если бы x был int, а не double, 
// то тут часто получался бы чистый ноль, 
// т.к. при делении целых дробные части отбрасываются.


// Теперь пример на несколько скобок
x = 10;
x = (x + 10) / 2 - 5 * (x-2); // будет 20 / 2 - 5 * 8, то есть -30.

// А также вложенные скобки:
x = 10;
x = (x + 5*(x-1)  ) * 2 + 1; // будет (10 + 5 * 9) * 2 + 1 = 55 * 2 + 1 = 111.

package javaapplication1;
public class JavaApplication1 {
public static void main(String[] args) {
  int x = 100;
  x = x*10/2 + x;
  System.out.println (x);

  double y = x - 5.5;

  System.out.println (y);
 }   
}