Программирование в Java 2

// Ввод с консоли

Для считывания данных который ввел пользователь нужно использовать технологию Scanner.

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

import java.util.Scanner;

При помощи этой строчки импортируется, все не обходимое для работы со сканером.

Далее внутри метода нужно создать объект сканнера (про объекты поговорим позже)

Scanner Имя = new Scanner(System.in);

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

Scanner in = new Scanner(System.in);

Теперь давайте попробуем считать и записать данные в переменную

String input = in.nextLine();

В переменную input запишется строка, которую введет пользователь.

(конструкция не совсем понятная, позже вы детально поймете, каждый символ, а пока просто запомните)

Чтобы разобраться как работает ввод данных, попробуйте считать данные и вывести на экран.

Напишем не большую программу, спросим имя и поздороваемся.

Вот исходный код:

Также вы можете разобрать код в онлайн редакторе.

Для начала мы импортируем сканер (1 строчка)
Внутри main, создаем объект сканера для доступа к методу nextLine(), который обеспечивает считывание вводных данных (5 строчка)
Просим ввести имя (7 строчка)
Создаем переменную типа string и записываем в нее считанные данные, которые ввел пользователь (на этом моменте программа остановится и не продолжится, пока пользователь не введет данные) (8 строчка)
И выводим Hello и через пробел имя (которое мы считали) (10 строчка)

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

На 8-ой строчке мы создали переменную и присвоили ей in.nextLine(); при помощи объекта через точку можно подключатся к его методам(функциям), если вы работаете в IDE, то после того как вы набрали in. должно высветится подсказка с возможными методами, давайте их разбирать:

Для работы со строками можно использовать два метода

next();
nextLine();

Оба метода считывают строчку, но next() - считает до первого пробела (ввод не остановится если вы поставите пробел, но считается все до первого пробела), а
nextLine() - считывает вместе с пробелами.

Можно записать только в переменную типа string

С остальными типами логика проста, метод будет начинаться с next, а дальше с большой буквы тип данных (слитно). Надеюсь вы понимаете, что если вы считываете данные какого-то типа и хотите ее записать в переменную, она должна быть такого же типа.

Вот методы для int и double

nextInt();
nextDouble();

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

nextByte();
nextShort();
nextLong();
nextFloat();
nextBoolean();

// Арифметические Операции (Выражения)

В программирование очень большая часть состоит из вычислений и выражений.

Выражение - это процесс выполнения каких-либо операций над данными.
Например сложение, вычитание, умножение.

Для выполнения операции нужен оператор. Многие из них вам будут очень хорошо знакомы из математики.

Операторы

Оператор сложения +
вычисляет результат сложения двух значений

Оператор вычитания -
вычисляет результат вычитания одного значения из другого

Оператор умножения *
вычисляет результат умножение одного значения на другое

Оператор деления /
вычисляет результат деление одного значение на другое

Оператор деления по модулю %
вычисляет остаток от деления одного значения на другое

Напомню, что такое остаток при делении. Делим 3 на 2 - на цело делится 1 раз и остается еще 1 - это и есть остаток от деления.

С первыми тремя операторами все не так сложно.

Пример:

System.out.println(2 + 2); // Выведет 4
System.out.println(2 - 2); // Выведет 0
System.out.println(2 * 2); // Выведет 4

С делением не все так гладко

Пример:

Если мы делим на цело, то все нормально

System.out.println(10 / 5); // Выведет 2

А если нет, то появляется проблема

System.out.println(7 / 5); // Выведет 1

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

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

System.out.println(7 / 5); // 2

Напишу еще пару примеров

3  % 3   // 0
10 % 5   // 0
5  % 3   // 2
20 % 3   // 2

Приоритет выполнения действий

Все работает как в математике - сначала умножение и деление (добавим сюда еще и деление по модулю), потом сложение и вычитание.

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

Еще про операторы

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

Операторы делятся по признаку количеству данных над которыми выполняется операция.

Те операторы, которые мы уже рассмотрели называются Бинарным (двойными), так как выполняют вычисление только у двух значений.

Если вам не понятно, почему они работают только с двумя значениями, объясню подробнее.
Есть вот такое выражение 1 + 2 + 3 и вроде как тут три разных значения, о каких двух вообще может идти речь?
Дело в том, что в выражении стоит два оператора сложения - соответсвенно операция выполняется два раза - следовательно, если операторы бинарные - значит у нас 4 значения, внезапно появилось еще одно значение, давайте разберем этот пример по этаппно:

Для начала выполняется 1 + 2, ровно 3
А дальше 3 + 3, вот откуда берется еще одно значение, после вычисления выражения - это больше не выражение, а самостоятельное значение и мы можем с ним работать как и с любыми другими значениями.

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

Давайте с ними знакомится.

Унарный минус -
делает выражение отрицательным (если унарный минус были использован к отрицательному значению - будет положительное и наоборот)

Очень страшное слово (это программирование, привыкайте)
Инкремент (на самом деле ничего сложного, нет) ++
увеличивает значение на 1

И еще одно страшное слово (вы ведь понимаете, что тут не будет ничего сложного?)
Декремент --
вычитает от значение 1

Инкремент и декремент бывает двух видов:
Постфиксный - оператор будет стоят после значения

int a;
a++;

int a;
a--;

Префиксный - оператор будет стоять после значения

int a = 0;
++a;

int a = 0;
--a;

Теперь давайте разбираться на примере

Начнем с префиксного

int a = 0; // создаем переменную со значением 0.
++a; // инкрементируем переменную.
System.out.println(a); // выведется 1.

Переменная a просто увеличилась на 1.

Мы можем инкрементировать внутри конструкции вывода

int a = 0;
System.out.println(++a); // Выведется 1.

Если бы мы использовали декремент, переменная уменьшилась на 1.

Теперь разберемся с постфиксным, он работает немного по другому.

int a = 0;
System.out.println(a++); // Вывод 0.

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

int a = 0;
System.out.println(a++); // Вывод 0.
System.out.println(a);   // Теперь вывод 1.

Вот еще пример

int a = 0;
System.out.println(a++);   // Вывод 0.
System.out.println(a++);   // Теперь вывод 1.
System.out.println(a++);   // Теперь вывод 2.
System.out.println(a++);   // Теперь вывод 3.
System.out.println(a);     // Теперь вывод 4.
System.out.println(a);     // Теперь вывод 4.

Немного позже мы будем очень активно применять операторы инкремента и декремента.

И последний вид операторов Тернарный он всего один и познакомимся с ним позже.

Также операторы по разному работают с разными типами данных, например если используется + с числовыми типами - это оператор сложения, а если со string, то это оператор слияния строк.
Все выше перечисленные примеры, будут работать только если в унарных операторах используется какое-либо значение числового типа данных (double, int), и если в бинарных операторах используются только числовые типы и два значения одного типа данных.

// Остальные числовые типы данных

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

Целые, аналогичные int, но с другим возможным диапазоном значений.

// Карточка с целыми

И еще один тип для не целых (дробных)

// Карточка с float

// Преобразование типов данных

Преобразование типа данных - это процесса преобразование одного типа данных в другой.

К примеру:

byte a = 1;
int b = a;

Переменная b расширила диапазон значений переменной a без потери данных.
По сути значение переменной a положили в другую переменную с большим диапазоном значений.

Преобразование без потери данных можно по данной схеме

byte -> short -> int -> long

byte  a = 0;
short b = a;
int   c = b;
long  d = c;

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

Вот пример:

int  a = 1;
byte b = 2;

System.out.println(a + b);

Этот код работает так:

Сначала идет проверка, имеют ли один тип два значения
Если да, то числа складываются (тип данных остается прежний)
Если нет, то данные преобразуются к общему типу

Общий тип - будет тот тип, который хранит больший диапазон значений (соответсвенно занимает больше места)

При преобразовании byte и int - общим типом будет - int
Значит значение типа byte - преобразуется в int (а судя из того, что написана выше - если преобразовать меньший тип к большему - потери данных не будет).

В итоге значение будет ровно 3 типа int.

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

Пример:

int a = 128;
byte b = a;

При такой записи компилятор сообщить об ошибке, нельзя автоматически преобразовать в int в byte. Значит нужно преобразовывать явно.

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

int a = 128;
byte b = (byte)a;

System.out.println(b);

Теперь все преобразовалось, но тип данных byte - не может хранить числа больше 127, а в примере записывается 128. Вы удивитесь, но вывод будет равен -128 (минимальное возможно значение типа byte). На вопрос почему именно это число, нужно отвечать отдельной статьей, об этом позже.

Это и был пример явного преобразования с возможной потеряй данных (в данном случае с потерей данных).

Ранее встретился случай, что при делении обрезалась не целая часть, теперь давайте решать эту проблему.

System.out.println(5 / 2);

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

Для решения это проблемы есть несколько вариантов:

Установить одно(или два) из значений тип данных double, чтобы при делении все преобразовалось в double.

System.out.println(5.0 / 2);

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

Преобразовать одно(или два) из значений в double.

System.out.println((double)5 / 2);

В данном случае мы преобразовали значение 5 в double, теперь оно будет иметь вид 5.0

Теперь деление будет работать правильно, выведет 2.5

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

System.out.println((double)(5 / 2));

Вывод будет 2.0, так как сначала вычисляется выражение, и далее значение преобразуется в double.

Есть еще некоторые способы преобразования, продолжим позже.

//Резюме