Archives: Java Lessons

В прошлых уроках мы уже сталкивались со строками, когда передавали текст в кавычках "" в функцию вывода на консоль — например: System.out.println("строка").

Строка — это набор любых одиночных символов, например 'g', '2', '-', обьединенных вместе.

Ранее мы изучали тип данных char, который хранит один символ. Так вот, строка состоит из последовательности символов типа char.

Например, можно объединить символы, которые мы привели выше, и получится строка "g2-". Как видно, строка всегда записывается в двойных кавычках, в отличие от одиночных кавычек у символов char.

Приведем пример строк в программе:

class Test { public static void main(String []args) { //Строки можно хранить в переменной типа String String b = “Some text info!”; //Выведем строку только теперь не напрямую как раньше, //а из переменной b. System.out.println(b); } };

Вывод:

---

Склеивание (конкатенация) строк

Пример конкатенации:

class Test { public static void main(String []args) { String b = “Some”; String c = ” text info!”; String d = b+c; //выводим объединенный текст переменных a и b System.out.println(d); } }

Вывод:

---

Обход символов строки с помощью цикла

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

Количество символов в строке можно узнать с помощью функции length().

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

Пример обхода строки:

class Test { public static void main(String []args) { String b = “Some text info!”; for(int i=0; i < b.length(); i++){ System.out.println(b.charAt(i)); } } }

Вывод:

---

Другие полезные функции у строк

Например, функция equals() используется для сравнения строк. Она возвращает true, если строки полностью совпадают.

Или, например, функция replace() которая позволяет заменить символы или подстроки в строке.

Пример использования этих функций:

class Test { public static void main(String []args) { String b = “Some text info!”; //Заменим все буквы t в строке выше на букву G. //Для этого используем функцию replace. //Первый аргумент, который передается в функцию //это символ, который нужно заменить в строке, //второй аргумент это символ, который встанет на место //символа, который мы заменяем. System.out.println(b.replace(‘t’,’G’)); //То есть на консоль выведется Some GexG info! //Важное уточнение, что сама переменная b все еще //содержит строку “Some text info!” не измененной. //Функция replace работает так, что она КОПИРУЕТ //содержимое String переменной и делает изменения //над КОПИЕЙ, а не самим содержимым строки b. String c = “Some text info!”; //Проверим с помощью equals одинаковы ли строки b и c. if(b.equals(c)){ //если строки одинаковы выводим сообщение об этом System.out.println(“b and c are equal strings!”); } } };

Вывод:

В этом уроке мы познакомимся с массивами в Java: разберём их концепцию, научимся с ними взаимодействовать и узнаем, какие типы массивов бывают.

В прошлых уроках у нас была переменная int a=31 хранящая одно число 31.

Такая переменная называется массивом.

Объявляется массив так:

[] значат, что это массив и в нем будет храниться много значений (значений типа int в данном случае).

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

Ключевым словом new мы выделяем память под массив, который может вмещать максимум 5 элементов.

После этого можно записывать в эту память числа.

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

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

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

---

Взаимодействие с массивом

Итак рассмотрим как мы можем взаимодействовать с массивом.

Ниже в примере программы создается массив b, который содержит 5 числовых значений.

Каждое из пяти значений имеет свой порядковый номер в массиве:

56 – имеет номер 0, 3 – имеет номер 1, 7 – имеет номер 2, 63 – имеет номер 3, 13 – имеет номер 4. Очевидно, что номера элементам массива выдаются по порядку, то есть первому элементу в массиве номер ноль, второму номер 1, третьему элементу номер 2 и т.д.

Поясним на примере:

class Test { public static void main(String []args) { int[] b = {56, 3, 7, 63, 13}; // По индексу мы можем взаимодействовать // с элементами массива. // Например, ниже мы записываем // в элемент массива с индексом 1 число 33. // Индекс указывается в квадратных скобках. // Теперь вместо 3 теперь будет 33. b[1] = 33; // Можно обратиться к элементу по индексу // чтобы его использовать каким-то образом. // Например, вывести на консоль как ниже. System.out.println(b[1]); } }

Вывод:

---

Обход массива циклом

Любой массив имеет внутри себя переменную length в которой храниться количество элементов массива. Это можно использовать для обхода элементов циклом.

Поясним на примере:

class Test { public static void main(String []args) { int[] b = {56, 3, 7, 63, 13}; //В данном случае b.length равно 5, //так как в массиве пять элементов. //Условие цикла как видим, такое, что пока i //меньше длины массива (то есть пяти) //цикл for продолжает свое выполнение. for(int i=0; i < b.length; i++) { //Каждую итерацию цикла i увеличивается на 1, //и эту i мы помещаем в квадратные скобки в качестве индекса //для извлечения каждого элемента массива по индексу //на каждой итерации. //То есть на первой итерации на консоль выводится //значение элемента b[0], на второй итерации значение //элемента b[1] и т.д. до b[4] System.out.println(b[i]); } } };

Вывод:

Как видим, можно легко пройтись по элементам массива и совершать с каждым какие-то действия на каждой итерации. Например, выводить на консоль каждый элемент, как в приведенном примере.

---

Обход массива циклом for-each

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

Называется он for-each.

В примере ниже цикл foreach начиная с первого элемента массива b поочереди берет элементы и помещает их в singleArrayElement

class Test { public static void main(String []args) { int[] b = {56, 3, 7, 63, 13}; for(int singleArrayElement : b){ System.out.println(singleArrayElement); } } }

Вывод:

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

---

Двумерные массивы

Представьте одномерный массив, в котором каждый элемент — это полноценный одномерный массив чисел, такой же, как мы рассматривали выше.

То есть это массив массивов чисел, и он называется двумерным массивом.

Ниже приведён пример двумерного массива. Он объявляется с помощью [][]. Как видно, через запятую перечислены массивы чисел — каждый из них является отдельным элементом основного массива.

int[][] b = { {56, 3, 63, 13}, {3,67,2}, {5,5,3,7,9} };

Пример: строка кода ниже достает из массива b число 2. Мы обращаемся ко второму подмасиву, к третьему элементу этого подмассива.

Полный пример:

class Test { public static void main(String []args) { // Ниже пример двумерного массива. // Как видим, через запятую перечислены массивы чисел. int[][] b = { {56, 3, 63, 13}, {3, 67, 2}, {5, 5, 3, 7, 9} }; // Выведем третий элемент во втором подмассиве. System.out.println(b[1][2]); } }

Вывод:

---

Обход двумерного массива циклом

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

Для простоты воспользуемся for-each. Ниже показано, как с помощью вложенных циклов пройтись по всем числам в двумерном массиве и вывести их на консоль.

Пример программы:

class Test { public static void main(String []args) { int[][] b = { {56, 3, 63, 13}, {3, 67, 2}, {5, 5, 3, 7, 9} }; System.out.println(b[1][2]); // Внешний foreach по очереди записывает в single2DSubArray // один из подмассивов двумерного массива b. Таким образом // single2DSubArray перезаписываеться новым подмассивом каждую итерацию. for(int [] single2DSubArray : b){ // Внутренний foreach ниже перебирает числа из текущего подмассива, // который внешним foreach был записан в переменную single2DSubArray. for(int singleArrayNumber : single2DSubArray){ // Через запятую выводим числа подмассива в single2DSubArray System.out.print(singleArrayNumber + “, “); } // После обработки каждого подмассива внутренним for-each // происходит переход на новую строку с помощью \n. // Это позволяет визуально отделить выводимые подмассивы // друг от друга при выводе в консоль. System.out.println(“\n”); } } }

Вывод:

В данном уроке рассмотрим ключевые слова break и continue.

Поясним на примере:

class Test { public static void main(String []args) { int a=31; for(int i=0;i<10;i++){ // Каждую итерацию цикла от a отнимается единица // и если переменная a на какой-либо итерации станет равна 25, if (a==25) { // то цикл завершает свою работу с помощью ключевого слова break. break; } System.out.println(a); a--; } } };

Вывод:

Как видим произошло всего 6 итераций вместо 10. Очевидно что цикл for остановился досрочно, то есть і не дошло до 10. Цикл был остановлен с помощью break когда переменная а стала равна 25.

---

Ключевое слово continue

Пример программы:

class Test { public static void main(String []args) { int a=31; for(int i=0; i<10; i++) { System.out.println(a); // Каждую итерацию цикла от a отнимается // единица, и если переменная a на // какой-либо итерации станет равна 25, if (a==25) { // то досрочно останавливаем эту итерацию цикла // и сразу происходит переход к следующей, то есть // код после if (в данном случае это a--;) // выполнен не будет. continue; } a--; } } }

Вывод:

Как видно из вывода, на седьмой итерации переменная a становится равной 25. Начиная с этого момента и до конца цикла (то есть пока i не станет равным 10), условие a == 25 продолжает выполняться, из-за чего срабатывает continue, и a-- больше не выполняется. Поэтому на всех оставшихся итерациях значение a остаётся равным 25, что также видно в выводе.

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

Для начала рассмотрим цикл while на простом примере:

class Test { public static void main(String []args) { int A=31, B=15; //while означает “ПОКА”. //ПОКА A не равно B, выполняется код внутри фигурных скобок. while(A!=B){ //Одно повторение цикла, называется итерацией цикла. //Можно сказать, что одна итерация цикла //это одно выполнение двух строчек кода ниже. System.out.println(A); //вывод значения А каждую итерацию. A--; //каждую итерацию цикла от А отнимается 1 } //Пока выражение в скобочках рядом с while не вернет ложь //код в {} будет продолжать выполняться. } };

Вывод:

---

Цикл for

Цикл for используеться чаще всего поскольку с помощью него условия выполнения цикла можно задать в очень копактной и удобной форме.

В программе ниже видно, что в круглых скобках после ключевого слова for находятся три выражения, разделённые точками с запятой:

Поясним каждое из этих выражений.

Пример программы:

class Test { public static void main(String []args) { int a=31; for(int i=0;i<10;i++){ a--; System.out.print(a+" "); } } }

Вывод:

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

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

---

Цикл do…while

Цикл do...while почти не отличается от обычного while, за исключением одного важного момента: условие проверяется в конце, а не в начале. Это означает, что тело цикла выполнится хотя бы один раз, независимо от условия.

В этом примере программы как раз можно увидеть что условие проверяеться в конце:

class Test { public static void main(String []args) { int a=31, b=15; do { System.out.print(a+” “); a--; } while(a!=b); } }

Вывод:

Таким образом в отличии от просто while в цикле do…while сначала выполняется код в {}, а потом проверка условия.

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

Чаще всего их используют в условных операторах. Например в if...else.

Поясним на примере.

class Test { public static void main(String []args) { int a=31, b=15; //if означает “ЕСЛИ”. //Если проговорить код ниже то будет: //”ЕСЛИ а больше чем b то выполняется код в {} после if”. if(a>b) { System.out.println(“a>b returned true”); } //else означает “ИНАЧЕ”. //Если проговорить код ниже то будет: //”ИНАЧЕ выполняется код в {} после else”. //Имеется ввиду ИНАЧЕ от того что было //в круглых скобочках у if. //То есть то что в фигурных скобочках после else //выполняется если выражение a>b вернуло false, //если же a>b вернуло true и был выполнен код //в фигурных скобочках у if то код в фигурных //скобочках у else, очевидно, выполнен не будет. else { System.out.println(“a>b returned false”); } //Выполниться то что в фигурных скобочках //у if так как a>b возвращает true. //То есть, как видим, можно писать блоки кода, //которые выполняются только по какому-то условию. } };

Вывод:

В примере if...else оператора ниже, выполниться то, что в фигурных скобочках после else, так как выражение a<b возвращает ложь.

class Test { public static void main(String []args) { int a = 31, b = 15; if (a < b) { System.out.println("a < b returned true"); } else { System.out.println("a < b returned false"); } } };

Вывод:

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

class Test { public static void main(String []args) { int a = 31, b = 15; if (a < b) { System.out.println("a < b returned true"); } } };

Вывод:

Также есть else if (...) {...}. Его можно писать много раз для дополнительных проверок.

Пример программы:

class Test { public static void main(String []args) { int a=31, b=15; // Если код в {} после if(a < b) не выполнялся, // то есть a < b возвращает false, if(a < b){ System.out.println("a < b returned true"); } // то выполняется проверка условия в else if ниже // и если a==b возвращает true, то выполняется код // в {} после else if(a==b) и все проверки далее // совершаться не будут, то есть произойдет переход к коду // после проверок, то есть к строчке: // System.out.println("The end of the program"); // Если же a==b возвращает false else if(a==b){ System.out.println("a < b returned false, but a==b " + "returned true"); } // то выполняется проверка условия в else if ниже // и если a>b возвращает true, то выполняется код // в {} после else if(a > b) и все проверки далее // совершаться не будут, то есть произойдет переход к коду // после проверок, то есть к строчке: // System.out.println(“The end of the program”); // Если же a > b возвращает false else if(a > b){ System.out.println(“a < b returned false, a==b " + "returned false, but a > b returned true”); } // то выполняется код в {} после else. else{ System.out.println(“a < b returned false, a==b returned false" + " so lets return something in else block"); } System.out.println("The end of the program"); // Программа выполнит то, // что в фигурных скобках у else if(a>b), // так как a > b возвращает true. } };

Вывод:

Как уже было замечено, если бы, например, a==b возвращал true в программе выше, то все другие проверки else if после else if(a==b) не совершались бы и блок else тоже не выполнился бы.

В этом смысл else if. Если бы вместо всех else if были использованы просто if, и при этом условие a == b оказалось бы истинным, то код в скобочках {} этого условия бы выполнился, но программа дальше бы продолжила проверки условий в if-ах ниже этого условия.

---

Условный оператор switch case

Также часто вместо if…else используют switch case.

Давайте для начала приведем if else версию, а потом ее switch case аналог, который делает то же самое.

Пример программы:

class Test { public static void main(String []args) { int a=31, b=15; //если a+b равняется 35 if(a+b==35) { //то выполняется то что здесь System.out.println(“a+b equals to 35”); } //если a+b равняется 46 else if(a+b==46) { //то выполняется то что здесь System.out.println(“a+b equals to 46”); } //если a+b равняется 42 else if(a+b==42) { //то выполняется то что здесь System.out.println(“a+b equals to 42”); } //если все условия выше оказались false else { //то выполняется то что здесь System.out.println(“lets return somethong ” + “in else block”); } } };

Вывод:

Ниже switch case версия, которая выполняет то же самое, что if версия выше.

Поочередно проверяются числа рядом с case-ами на предмет равенства результату выражения в скобочках рядом со switch и если в программе ниже, например, число 42 окажется равным результату выражения a+b, то выполниться код между case 42: и break;.

Пример программы:

class Test { public static void main(String []args) { int a=31, b=15; switch (a+b) { case 35: //если a+b равняется 35 System.out.println(“a+b equals to 35”); break; case 46: System.out.println(“a+b equals to 46”); break; case 42: System.out.println(“a+b equals to 42”); break; default: //default аналог else System.out.println(“lets return somethong in default block”); } } };

Вывод:

Конструкция switch-case может быть менее громоздкой по сравнению с if-else в некоторых ситуациях. Она особенно удобна, когда в программе предполагается множество ветвлений вида else if (...). В таких случаях switch-case может быть предпочтительнее и с точки зрения производительности: компилятор может сгенерировать так называемую jump table, что ускоряет выбор нужного варианта.

В Java воспользоваться оператором “И” можно используя символы "&&", оператором “ИЛИ” используя "||" и оператором “НЕ” используя "!".

Логические операторы “И” и “ИЛИ” позволяют соединять несколько условий в одном выражении. То есть можно вставить логический оператор между двумя выражениями с опреатором сравнения, например между 6<3 и 2<4, и тогда получиться новое выражение уже с логическим опретором которое тоже будет возвращать true или false

Давайте проговорим это выражение как делали в прошлых уроках – “6 меньше чем 3 И 2 меньше чем 4”. Верно ли такое утверждение? Нет. Значит результатом выражения будет false. Так как утверждение, что 6 меньше чем 3 ложно. Чтобы выражение с логическим оператором “&&” вернуло true нужно, чтобы И то, что стоит справа от логического оператора вернуло true, И то, что стоит слева от него вернуло true.

6<3 || 2<4 уже вернет true. Так как если проговорить, уже будет – “6 меньше чем 3 ИЛИ 2 меньше чем 4”. То есть, чтобы выражение с логическим оператором “||” вернуло true, нужно чтобы ИЛИ то, что стоит справа от логического оператора вернуло true, ИЛИ то, что стоит слева от него вернуло true.

Логический оператор отрицания “НЕ” в отличии от предидущих двух логических операторов не используеться между двумя выражениями, а применяеться к одному единственному выражению.

Например, !(6<3) вернет true. Это выражение нужно понимать, как обратный результат к выражению 6<3. То есть это НЕ (6 меньше чем 3). Оператор “!” просто оборачивает результат выражения на противоположный. Выражение 6<3 возвращает false, а обратное к false – это true, поэтому !(6<3) возвращает true.

Программа с логическими операторами:

class Test { public static void main(String []args) { // записываем в boolean переменную // результат выражения 6<3 && 2<4 boolean a = 6<3 && 2<4; // выведет false System.out.println(a); // выведет true System.out.println(6<3 || 2<4); // выведет true System.out.println(!(6<3)); } }

Вывод:

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

Знак > — это оператор “меньше чем”. То есть если проговорить это выражение, то будет “шесть меньше чем три”.

Вы скажете: «Это же неправда, шесть больше трёх!» — и вы будете правы. В Java результат такого сравнения будет false (то есть «ложь»).

И этот результат можно сохранить в boolean переменную. Помним, что boolean хранит либо true (правда), либо false (ложь).

Также есть и другие операторы сравнения:

• больше чем – “>”
• равняется – “==”
• не равняется – “!=”
• больше или равно – “>=”
• меньше или равно – “<=”

Пример программы:

class Test { public static void main(String []args) { //записываем в boolean переменную результат выражения 6<3 boolean a = 6 < 3; //выведет false System.out.println(a); a = 6 > 3; //выведет true System.out.println(a); a = 6 == 3; //выведет false так как 6 не равен 3 System.out.println(a); a = 6 != 3; //выведет true так как 6 не равен 3 System.out.println(a); a = 6 >= 3; //выведет true так как 6 больше или равно 3 System.out.println(a); a = 6 <= 3; //выведет false так как 6 больше 3 System.out.println(a); } }

Вывод:

Есть пять типов операторов: операторы присвоения, арифметические операторы, операторы сравнения, логические операторы и условные операторы.

С одним оператором присвоения мы уже познакомились – это знак равенства.

Как можно догадаться, операторы присвоения нужны для присвоения чего-то чему-то. Присвоение пятерки переменной А в данном случае.

Остальные операторы присвоения рассмотрим после арифметических.

Арифметические операторы нужны для выполнения простейших арифметических операций:

• ‘+’ – сложение
• ‘-‘ – отнимание
• ‘*’ – умножение
• ‘/’ – деление
• ‘%’ – остаток от деления

Пример использования арифметических операторов:

import java.util.Scanner; class Test { public static void main(String []args) { //создадим две целочисленные переменные //и сразу добавим в них значения int A = 31, B = 15; //запишем их сумму в новую переменную C int C = A + B; //и выведем результат сложения в консоль System.out.println(V); //перезапишем в C теперь разницу A и B и выведем C = A – B; System.out.println(C); //то же самое с остальными операциями C = A * B; System.out.println(C); C = A / B; System.out.println(C); //можно вывести напрямую, например, остаток от деления System.out.println(A % B); } }

Можно увидеть результаты вычислений:

---

Склеивание текста

Также с помощью оператора сложения + можно склеивать текст.

import java.util.Scanner; class Test { public static void main(String []args) { //склеим “Some text” и ” some another text” //чтобы вывело “Some text some another text” System.out.println(“Some text” + ” some another text”); //также можно текст склеивать с числовыми значениями int A = 31, B = 15; int C = A + B; System.out.println(“Variable A + B = ” + C + “. That`s cool”); //в результате получится текст: //”Variable A + B = 46. That`s cool” } }

В выводе можно увидеть, что оператор сложения успешно склеил “Some text “ и “some another text” и склеенное в итоге было выведено на консоль. Также оператор сложения успешно склеил число 46 из переменной C с кусками текста в один единый текст.

---

Добавление числа к переменной

Если переменная A содержит какое-либо значение и нам нужно сложить его с другим значением и поместить получившуюся сумму в эту же переменную A, то можно это сделать в одну строчку такой конструкцией:

import java.util.Scanner; class Test { public static void main(String []args) { int A = 31; // складываем содержимое A // с другим числом и помещаем в A. A = A + 10; // будет 41 System.out.println(A); } }

Вывод:

Для того чтобы выполнить данную операцию в еще более сокращенной форме используется оператор присвоения +=.

import java.util.Scanner; class Test { public static void main(String []args) { int A=31; // складываем содержимое A // с другим числом и помещаем в A. A+=10; // будет 41 System.out.println(A); } }

Вывод будет такой же.

Такие операторы присвоения есть и для всех остальных базовых арифметических операций: -=, *=, /=, %=.

---

Инкремент и декремент

Также важно упомянуть оператор инкремента ++ и декремента --.

То же самое с декрементом.

import java.util.Scanner; class Test { public static void main(String []args) { int a = 31; // Инкремент a++; // будет 32 System.out.println(a); // Декремент a--; // будет 31 System.out.println(a); } }

Вывод:

---

Пре-инкремент и пре-декремент

До этого мы рассматривали пост-инкремент A++ и пост-декремент A--.

Продемонстрируем разницу между ними.

class Test { public static void main(String []args) { int A=31; // Выполнение строчки кода ниже происходит // в такой последовательности, что сначала // происходит вывод, то есть срабатывание // функции println, а потом к переменной // а прибавляется единица. То есть в результате // выполнения строчки кода ниже на консоль будет // выведено 31. Это пост-инкремент. System.out.println(A++); // После выполнения верхней строчки кода // переменная A уже теперь содержит 32. // Можно это проверить. Для этого выведем // содержимое A еще раз. System.out.println(A); // Сейчас переменная A содержит значение 32. // Теперь используем пре-инкремент. // Последовательность выполнения строчки // кода ниже обратна предыдущему случаю, то есть // сначала происходит прибавление единицы к переменной A, // а потом вывод переменной A на консоль. // То есть строчка кода ниже выведет на консоль 33. System.out.println(++A); // Пре-декремент и пост-декремент // работают таким же образом. } }

Вывод:

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

Однострочный комментарий начинаеться с двойного слеша – //.

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

import java.util.Scanner; class Test { public static void main(String []args) { // здесь запрашиваеться ввод числа // и происходит его вывод в консоль. Scanner input = new Scanner(System.in); int a = input.nextInt(); System.out.println(a); input.close(); } };

---

Многострочный комментарий

Также комментарии можно писать вот так: /* Какой-то комментарий */.

Это многострочный комментарий.

• /* – открывает комментарий
• */ – закрывает комментарий

Один однострочный комментарий занимает только одну строку. Один же многострочный комментарий может занимать много строк. Комментарий внутри /* */ можно распределить на много строк. Ниже можно увидеть пример одного многострочного комментария.

import java.util.Scanner; class Test { public static void main(String []args) { /* здесь запрашиваеться ввод числа и происходит его вывод в консоль. */ Scanner input = new Scanner(System.in); int a = input.nextInt(); System.out.println(a); input.close(); } };

Для ввода значения в программу используется класс Scanner.

Класс этот находиться в java библиотеке util и чтобы его использовать в программе, его нужно импортировать в программу вот так:

После этого в программе необходимо создать объект этого класса (пока не заморачиваемая, что такое объект) вот так:

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

Функция nextInt(), вызываемая через объект Scanner, позволяет запросить у пользователя ввод целого числа и сразу сохранить его, например, в переменную:

Для ввода в программу других типов данных существуют другие функции – getDouble для ввода числа с плавающей, getLine для ввода любого текста.

---

Использование Scanner в программе

Программа ниже с помощью метода nextInt() запрашивает у пользователя ввод целого числа, сохраняет его в переменную, а затем выводит это значение на консоль.

import java.util.Scanner; class Test { public static void main(String []args) { Scanner input = new Scanner(System.in); int a = input.nextInt(); System.out.println(a); input.close(); } };

Вот так в консоли будет выглядеть ввод пятерки и ее вывод:

Первое 5 это то, что вводиться в консоль с клавиатуры. Второе 5 это то, что выводит System.out.println.