Напишите программу которая присваивает трем переменным значения 100 200 и 300 java
Сегодня мы изучим класс ArrayList . Это первый класс из так называемых коллекций. Коллекции в Java — настолько обширная и полезная вещь, что ей посвящен целый квест на JavaRush.
Чтобы полностью понять, как устроены коллекции и все нюансы их работы, нужно сначала изучить ООП, интерфейсы, наследование, азы многопоточности и многое другое.
Поэтому сегодня мы просто познакомимся с самой простой коллекцией. Зато на достаточно глубоком уровне, чтобы вы понимали, как ей пользоваться и как она работает. Итак, встречайте: коллекция ArrayList .
Предыстория
Начну с небольшой предыстории. Программистам очень не нравилось одно свойство массива — его размер нельзя изменять. Что делать, если нужно сохранить в массиве ещё три элемента, а свободное место только одно?
Единственным решением проблемы нехватки места в массиве было создание массива очень большого размера, чтобы все элементы туда точно поместились. Но это часто приводило к нерациональному расходу памяти. Если обычно в массиве хранилось два-три элемента, но был хотя бы мизерный шанс, что там их будет 100, приходилось создавать массив на 100 элементов.
И что же придумали программисты? Они написали класс ArrayList (массив-список), который выполнял ту же работу, что и Array (массив), но мог изменять свой размер.
Класс ArrayList
Само название ArrayList происходит из двух слов: Array + List. Array — это массив, а List — список.
Внутри каждого объекта типа ArrayList хранится обычный массив элементов. Когда вы считываете элементы из ArrayList , он считывает их со своего внутреннего массива. Когда записываете — записывает их во внутренний массив.
У класса ArrayList отсутствуют все недостатки, которые есть у массивов. Он умеет:
- Хранить элементы определенного типа
- Динамически менять размер списка
- Добавлять элементы в конец списка
- Вставлять элементы в начало и середину списка
- Удалять элементы из любого места списка
2. Создание объекта ArrayList
Чтобы создать объект класса ArrayList , нужно написать код типа:
Где ArrayList — это тип/класс коллекции, Тип — это тип элементов, которые хранит коллекция ArrayList , а имя — это имя переменной типа ArrayList .
Тип у переменной имя составной — состоит аж из двух типов: сначала указывается тип коллекции, а в треугольных скобках указывается тип элементов, которые эта коллекция хранит.
Код | Описание |
---|---|
Список целых чисел | |
Список строк | |
Список вещественных чисел |
Коллекции, в отличие от массивов, не могут хранить примитивные типы: только типы-классы . Поэтому если вам нужна коллекция с типом int , используйте вместо него тип-обертку — Integer .
3. Операции с ArrayList
Изначально длина только что созданного списка равна нулю: он содержит 0 элементов. Если в список добавить один элемент, его длина увеличится на 1. Если удалить добавленный элемент, опять уменьшится до нуля.
Более подробно можно узнать о методах класса ArrayList из таблицы:
Методы | Описание |
---|---|
Добавляет в список переданный элемент | |
Добавляет элемент в определенное место списка. | |
Возвращает элемент, который находится под номером index | |
Меняет значение элемента с номером index на value | |
Удаляет элемент под номером index . Возвращает удаленный элемент. | |
Удаляет элемент: нужно передать сам элемент в список. Если таких элементов несколько, будет удален первый из них. | |
Очищает список — удаляет все элементы из списка. | |
Проверяет, содержится ли в списке элемент value . | |
Проверяет, пустой список или нет. Равна ли длина списка нулю. | |
Возвращает размер списка — количество элементов списка. | |
Возвращает массив, содержащий те же элементы, что и список. Массив нужно передать в метод. |
Данные методы позволяют делать со списком практически все возможные операции: менять элементы местами, добавлять элементы, удалять элементы. Можно даже очистить список одной командой или преобразовать список в массив.
Рассмотрим сначала простую задачу вычисления площади круга. Как написать программу для решения этой проблемы?
Алгоритм
Написание программы включает в себя разработку алгоритмов и перевод алгоритмов в инструкции программирования или код. Алгоритм описывает, как проблема решается путем перечисления действий, которые необходимо предпринять, и порядка их выполнения. Алгоритмы могут помочь программисту распланировать программу, прежде чем писать ее на языке программирования.
Псевдокод
Алгоритмы могут быть описаны в естественных языках или в псевдокоде (естественный язык, смешанный с некоторым программным кодом). Алгоритм вычисления площади круга можно описать следующим образом:
1. Прочитать радиус круга.
2. Вычислить площадь используя следующую формулу:
площадь = радиус * радиус * π
3. Показать результаты.
Совет: всегда полезно описать свою программу (или ее основную проблему) в виде алгоритма перед началом кодирования.
Когда вы кодите, то есть, когда вы пишете программу, вы переводите алгоритм в программу. Вы уже знаете, что каждая Java программа начинается с определения класса, в котором за ключевым словом class следует имя класса. Предположим, что вы выбрали ComputeArea как имя класса. Схема программы будет выглядеть так:
Как вы знаете, каждая программа Java должна иметь основной (main) метод, в котором начинается выполнение программы. Следовательно, программа расширяется следующим образом:
Программе необходимо прочитать радиус, введенный пользователем с клавиатуры. Это поднимает два важных вопроса:
- Чтение радиуса.
- Сохранение радиуса в программе.
Сначала рассмотрим второй вопрос. Чтобы сохранить радиус, программе нужно объявить символ, который называется переменной. Переменная представляет значение, хранящееся в памяти компьютера.
Вместо использования x и y в качестве имен переменных выбирайте описательные имена: в этом случае radius для радиуса и area для площади. Чтобы компилятор знал, чем являются radius и area, укажите их типы данных. Это тип данных, хранящихся в переменной, будь то целое, действительное число или что-то еще. Это называется объявлением переменных. Java предоставляет простые типы данных для представления целых чисел, действительных чисел, символов и булевых типов. Эти типы известны как примитивные типы данных или фундаментальные типы.
Реальные числа (т. е. числа с десятичной точкой) представлены с использованием метода, известного в компьютерах как плавающая точка. Таким образом, реальные числа также называются числами с плавающей точкой. В Java вы можете использовать ключевое слово double для объявления переменной с плавающей запятой. Объявите radius и area как double. Следовательно, программа может быть расширена следующим образом:
Программа объявляет переменные radius и area. Зарезервированное слово double указывает, что radius и area являются значениями, которые хранятся на компьютере с плавающей запятой.
Первый шаг – предложить пользователю обозначить радиус круга. Вскоре вы узнаете, как запрашивать у пользователя информацию. Пока, чтобы узнать, как работают переменные, вы можете назначить фиксированное значение радиусу (переменной radius) в программе при написании кода; позже вы измените программу, чтобы запросить у пользователя это значение.
Второй шаг – посчитать площадь и присвоить результат выражения radius * radius * 3.14159 переменной area.
На последнем этапе программа отобразит значение area на консоли с помощью метода System.out.println.
В результате полная программа имеет вид:
Программа показывает площадь круга:
Листинг в NetBeans (с номерами строк):
Переменные, такие как radius и area, соответствуют местам памяти. Каждая переменная имеет имя, тип, размер и значение. Строка под номером 5 объявляет, что radius может хранить значение double. Значение не определено, пока вы его неназначили. Строка 9 назначает 20 в переменную radius. Аналогично, строка 6 объявляет переменную area, а строка 12 присваивает значение area. В следующей таблице показано значение в памяти для radius и area при выполнении программы. Каждая строка в таблице показывает значения переменных после выполнения оператора в соответствующей строке в программе. Этот метод рассмотрения работы программы называется трассировкой программы. Программы трассировки полезны для понимания того, как работают программы, и они являются полезными инструментами для поиска ошибок в программах.
Объединение строк
Знак плюс (+) имеет два значение: одно – это сложение, а второе – это конкатенация (объединение) строк. Знак плюса (+) в строках 15-16 называется оператором конкатенации строк. Он соединяет две строки в одну.
Объединение строк с числами
Если строка соединяется с числом, то число конвертируется (преобразовывается) в строку и объединяется с другой строкой. Следовательно, знак плюс (+) в строках 15-16 конкатенирует строки в одну более длинную строку, которая отображается в выводе. Строки и объединение строк будет рассмотрено в одной из последующих глав.
Внимание: в исходном коде строка не может быть разбита на несколько строк. Следовательно, следующая инструкция приведёт к ошибке компиляции:
Для исправления этой ошибки, разбейте строку на две отдельные подстроки и используйте оператор конкатенации (+) для их объединения:
Переменная в Java, как в принципе и в любом другом языке программирования - это "контейнер", в котором содержится некое значение. Причём, это значение должно принадлежать к определённому типу данных. По мере исполнения программы это значение может изменяться. Переменные используются практически во всех программах. Соответственно, мы будем их использовать во всех наших уроках.
Данные, содержащиеся в переменных, должны быть определённого типа. Программист должен всегда это учитывать при работе с переменными.
Итак, наиболее распространённые типы данных:
- int - Целое число в диапазоне от –2 147 483 648 до 2 147 483 647. Например, 15.
- String - Текстовый тип данных - любое количество символов в Юникоде. Например, "мой текст". Обращаю внимание на важный момент. Текст в Java всегда помещается в двойные кавычки " ".
- float - вещественное число с плавающей точкой. В отличие от типа int значения типа float - не только целые. Пример 2.3457f. Особенностью данного типа является то, что данные этого типа имеют суффикс f. Десятичные дроби пишутся через точку, не запятую.
- char - Одиночный символ в Юникоде. Например 'a' или 'z'. Данные типа char выделяются в отличие от String одинарными кавычками ' '.
- boolean - Значения переменных типа boolean могут быть только true или false.
Стоит также обратить внимание на то, что тип данных String пишется с большой буквы, остальные типы данных - с маленькой. Это следует просто запомнить.
Есть и другие типы данных, например byte, short, long, double для работы с числами. Нужный тип данных используется в зависимости от задачи, которая ставится перед программистом. Переменные разных типов используют (занимают) разное количество памяти.
Итак, рассмотрим, как нам создать переменную. В программировании создание переменных называется объявлением. Объявляются переменные очень просто. Пишем тип данных и затем через пробел имя переменной. Например,
Такой командой мы объявили переменную типа int с именем chislo. После объявления переменной всегда ставится точка с запятой.
Такой командой мы объявили переменную типа String с именем moiText.
Присвоение имён переменных осуществляется по следующим основным правилам:
- Имя переменной может начинаться только с латинской буквы, знака нижнего подчёркивания _, или со знака $. Последующие символы должны быть также латинскими буквами, цифрами, знаками _ либо знаками $
- Нельзя называть переменные ключевыми словами Java, например, типами данных int, String, char и прочими, которые будут использоваться в дальнейшем
- Имя переменной не может содержать пробелы
- Имена переменных чувствительны к регистру. Поэтому Text и text - это разные переменные. Также Chislo и chislo это разные переменные
- Желательно присваивать имена переменным таким образом, чтобы было понятно, что эта переменная должна в себе содержать
- Обычно у программистов принято имена однословных переменных писать с маленькой буквы. Многословные переменные обычно начинаются с маленькой буквы, последующие слова начинаются с большой буквы. Например vremyaGoda или moiText
- Также у программистов принято использовать в качестве имен переменных английский слова. Не русские слова английскими буквами, а именно английские слова.
В дальнейшем я в своём курсе буду писать русские слова английскими буквами для Вашего удобства. Но ещё раз акцентирую внимание, что такой подход не принят у программистов.
Итак, после объявления переменной можно присвоить ей начальное значение. Делается это с помощью оператора присвоения = Например,
После присвоения переменной значения ставится точка с запятой.
При этом есть 2 варианта.
1. Можно сначала объявить переменную, а потом присвоить ей значение. Например,
2. А можно сразу объявить переменную и присвоить ей значение:
String moiText = "Привет!";
Теперь на практике посмотрим, как правильно объявлять переменные, как присваивать им значения и изменять их.
Объявим новую программу с именем Peremennaya
Внутри фигурных скобок класса Peremennaya объявим главный метод main
public static void main (String[] args)
Внутри фигурных скобок метода main объявим 2 переменные - одну строкового типа String, другую целочисленную типа int и присвоим им начальные значения:
String moiText = "Привет!";
Затем напишем команды, которые выведут на экран значения наших переменных.
Этот урок получился большим, с большим количеством информации. Но я не могу не рассказать обо всех особенностях цикла for, эта информация всё равно пригодится. Особенно удобно, когда она собрана в одном месте, как шпаргалка. Пусть даже и не вся информация сразу в голове отложится. В наших уроках мы скорее всего будем использовать минимум возможностей цикла for. По крайней мере в ближайших. Это всё-таки курс для "чайников".
Вообще что такое цикл?
Цикл - это часть кода, блок команд, который выполняется с определённой периодичностью снова и снова до тех пор, пока соблюдается определённое условие. Как только условие перестаёт соблюдаться, цикл завершается и программа переходит к выполнению следующих команд.
Та часть кода, которая повторяется, называется телом цикла . Одно выполнение тела цикла называется итерацией .
Существуют несколько вариантов циклов. В текущем уроке мы рассмотрим цикл for.
Синтаксис у него следующий
for ( начальное значение ; проверочное выражение ; оператор счётчика )
код для выполнения на каждой итерации
Как это работает.
1. Присваиваем начальное значение переменной-счётчику. Объявить её можно прямо здесь в круглых скобках. Обычно это целочисленная переменная.
2. Определяемся с проверочным выражением . Пока значение выражение будет true, т.е. пока оно верно, код для выполнения будет исполняться снова и снова.
Другими словами, в начале каждой итерации проверочное выражение проверяется на значение true или false.
Если значение true, то исполняется код, расположенный в фигурных скобках.
Как только значение перестаёт быть true и становится false, цикл немедленно завершает свою работу, код в фигурных скобках не выполняется и программа выходит из цикла за пределы фигурных скобок.
3. Оператор счётчика изменяет текущее значение переменной-счётчика по заданному нами правилу.
Теперь на конкретном примере.
Допустим, стоит задача вывести на экран числа от 1 до 10. Каждую цифру с новой строки.
Можно эту задачу решить с помощью только оператора вывода текста на экран следующими командами:
Это конечно классно, когда чисел 10. А если их 100? А если 1000? Есть подозрение, что код программы будет несколько громоздким.
Есть более простое и элегантное решение - использовать цикл.
Для решения нашей конкретной задачи код будет следующим
Давайте подробно разберём эту конструкцию, как она работает.
Программа входит в цикл.
int i = 1 - объявляем переменную-счётчик i и присваиваем ей начальное значение 1.
В результате выполнения тела цикла на экран с помощью оператора вывода текста будет выведено значение переменной i. На первой итерации оно равно 1. Значит, на экран будет выведено значение 1.
Тело цикла выполнилось, теперь пора выполниться оператору счётчика i++. В нашем случае оператор счётчика (инкремент) увеличил значение переменной-счётчика i на 1.
После выполнения цикла значение переменной-счётчика стало равно 2.
Всё. Первая итерация цикла выполнена. Переходим ко второй итерации.
На второй итерации переменной-счётчику уже не будет присваиваться начального значения. Оно было присвоено на входе в цикл.
Сразу осуществляется проверка проверочного условия. На второй итерации значение переменной-счётчика i равно 2. Условие i
В результате выполнения тела цикла на экран будет выведено значение переменной-счётчика i, которое на второй итерации равно 2.
Тело цикла выполнилось, соответственно, опять пора выполниться оператору счётчика i++. После его выполнения значение переменной i увеличилось на 1 и стало равно 3.
Всё. Вторая итерация полностью выполнена. Переходим к третьей.
В результате его выполнения на экран будет выведено значение переменной i, которое на третьей итерации равно 3.
Далее сработает оператор счётчика i++ и значение переменной i станет равно 4.
И так далее. Пока проверочное условие верно тело цикла будет выполняться снова и снова.
Рассмотрим 10-ю итерацию.
По результату выполнения 9-й итерации, проследив закономерность, мы можем сделать вывод, что значение переменной-счётчика будет равно 10.
Итак, начинаем 10-ю итерацию.
Выполняем 10-ю итерацию.
После выполнения тела цикла в очередной раз сработает оператор счётчика и значение переменной i ещё раз будет увеличено на 1 и станет равно 11.
Далее после проверки на истинность проверочного условия 11
Всё, что было рассмотрено выше - это стандартный вариант использования цикла for. В большинстве примеров мы будем использовать его именно так.
Всё, что изложено ниже, лучше прочитать. Как минимум чтобы знать подводные камни и особенности использования цикла for.
Итак, какие есть особенности.
1. Есть возможность дальше использовать переменную i и её значение. После последней 10-й итерации её значение стало равно 11. Его и можно использовать в случае необходимости.
2. Оператор счётчика необязательно должен быть инкрементом или декрементом.
Могут быть такие конструкции:
Вместо инкремента i = i + 1;
Это будет выглядеть так
for ( int i = 1; i
Результат будет таким же.
Или аналог декремента for ( int i = 1; i
И необязательно должна быть единица, и можно использовать не только плюс и минус.
for ( int i = 1; i
for ( int i = 1; i
3. Начинающие программисты часто допускают одну из двух или обе ошибки сразу. Заключаются они в следующем.
- Цикл повторяется на одну итерацию больше или на одну итерацию меньше, чем изначально задумывалось. Как правило это происходит из-за использования некорректного оператора сравнения. Например, нужно использовать
Самый простой пример - это выше рассмотренный. Хотим вывести на экран числа от 1 до 10. Правильный код
for ( int i = 1; i
А часто можно перепутать и написать так:
for ( int i = 1; i < 10 ; i++)
Что же будет, если написать так? После 9-й итерации значение i станет равно 10. После этого вроде бы должна выполниться 10-я итерация, но нет. Проверочное условие станет ложным. 10 < 10 это ложь (на всякий случай 10=10 это правда :) ). И 10-я итерация, выполнения которой мы ждём, не выполнится.
- Программист пытается использовать значение переменной-счётчика, которое по факту больше или меньше на единицу, чем необходимо. Например, после завершения цикла.
Опять же возьмём предыдущий пример. Вроде бы кажется, что раз на экран выводятся значения от 1 до 10, значит, после 10-й итерации значение i должно быть равно 10. Но нет. После выполнения 10-й итерации значение i увеличится на 1 и станет равно 11.
В одном из источников эту тенденцию назвали "ошибка неучтённой единицы".
3. В цикле можно пропускать одно или несколько выражений. В частности:
3.1. Переменная-счётчик может быть объявлена в самом цикле или до цикла.
Можно написать так
3.2. Переменной-счётчику может быть присвоено начальное значение до цикла. А в объявлении цикла можно присвоение начального значения пропустить
Результат выполнения будет таким же.
3.3. Можно не указывать оператор счётчика в скобках, а можно его указать в теле цикла.
Но если он не указан в скобках, он обязательно должен быть указан в теле цикла.
Если его не указать, то условие никогда не станет ложным. И цикл станет бесконечным .
4. Бесконечный цикл.
Код цикла должен быть составлен таким образом, чтобы в какой-то определённый момент значение проверочного выражения стало false. Иначе цикл станет так называемым бесконечным.
for (int i = 2; i != 0 ; i++)
System.out.println("Значение i = " + i);
Давайте подробно разберём этот пример.
Дальше выполняем проверку условия, что i не равно 0. Условие верно, значит тело цикла выполнится.
Выполняем тело цикла. Первая итерация.
Присваиваем переменной i значение 1. Да, да. Именно переменной-счётчику присваиваем новое значение.
Выводим это значение на экран в виде текста с помощью оператора вывода текста. Будет выведено
Значение i = 1
Дальше выполняется оператор счётчика. После его выполнения переменной счётчику будет присвоено значение 2 оператором инкремента.
Всё первая итерация выполнена. Переходим ко второй итерации.
Осуществляем проверку условия. Значение переменной i у нас теперь равно 2. Проверочное условие i != 0 выполняется, значит выполнится вторая итерация.
Переменной i присваиваем значение 1 командой i = 1;
Выводим на экран текст
Значение i = 1
Снова выполнится оператор счётчика. Инкрементом значение счётчика будет увеличено на 1. Снова значение i станет равно 2.
Вторая итерация завершена.
Можно проследить некую закономерность. Первая и вторая итерация - одинаковые. Если мы посмотрим третью, четвертую, пятую итерацию и так далее, то увидим, что выполняются одни и те же действия. Переменной-счётчику присваиваются одни и те же значения. При этом проверочное условие всегда верно. И мы видим, что сколько бы раз не выполнялась эта последовательность действий, проверочное условие всегда будет верно. Соответственно, программа не выйдет из цикла, т.е. зациклится и будет выполняться до тех пор, пока не будет завершена вручную. Мы получили бесконечный цикл.
Другой вариант бесконечного цикла - про который упоминалось в пункте 3.3. - если не указать оператор счётчика в скобках и не указать его в теле цикла. Ещё раз пример
Так делать правильно! А так неправильно:
Как в таком случае сработает цикл?
Или ещё вариант как сделать бесконечный цикл - такой:
Тело цикла (любое)
оставить пустыми области для ввода начального значения, проверочного условия и оператора счётчика.
В большинстве случаев бесконечный цикл - это логическая ошибка, недоработка человека, который пишет код. Нужно всегда следить за тем, чтобы в какой-то момент проверочное условие стало ложным.
5. Вложенные циклы
Иногда задача стоит так, что решить её можно с помощью цикла, вложенного в другой цикл. Например, такие конструкции удобно использовать при работе с массивами данных, которые будут рассмотрены в ближайших уроках.
Как это работает.
Пример конструкции с вложенным циклом
System.out.println("Номер итерации внешнего цикла - " + a);
System.out.println(" Номер итерации внутреннего цикла - " + b);
Здесь цикл с переменной a называется внешним циклом, цикл с переменной b - внутренний (вложенный) цикл.
Эта конструкция будет работать следующим образом.
Программа входит во внешний цикл. Переменной a присваивается начальное значение a = 1. Выполняется проверка проверочного выражения a
Сначала идёт оператор вывода текста на экран. В результате его выполнения на экран будет выведено
Номер итерации внешнего цикла - 1
Думаю, понятно, почему именно такой текст.
Идём по телу внешнего цикла дальше. После оператора вывода текста идёт вложенный цикл. Начинаем выполнять его.
Программа входит во внутренний цикл. Переменной b присваивается начальное значение b = 1. Выполняется проверка проверочного выражения b
Поскольку b на первой итерации внутреннего цикла равно единице, на экран будет выведено
Номер итерации внутреннего цикла - 1
Всё. Первая итерация внутреннего цикла выполнена. После неё оператором инкремента b++ значение переменной b будет увеличено на единицу. И станет равно 2.
Номер итерации внутреннего цикла - 2
Всё. Вторая итерация внутреннего цикла выполнена. После неё оператором инкремента b++ значение переменной b будет увеличено на единицу. И станет равно 3.
Номер итерации внутреннего цикла - 3
Вспоминаем, что же у нас происходит с внешним циклом. У нас во внешнем цикле было 2 действия - вывести текст на экран, мы его вывели (Номер итерации внешнего цикла - 1) и выполнить внутренний цикл. Оба этих действия мы выполнили, соответственно, первая итерация внешнего цикла завершена. После её выполнения оператором инкремента a++ значение переменной a будет увеличено на 1 и станет равно 2.
Начинаем вторую итерацию внешнего цикла. Выполняем проверку проверочного выражения. a
Вторая итерация внешнего цикла начинается с выполнения оператора вывода текста на экран. Будет выведено:
Номер итерации внешнего цикла - 2
т.к. значение переменной a на второй итерации равно 2.
Затем после оператора вывода текста идёт цикл. Внутренний. Приступаем к его выполнению.
Опять переменной b присваивается начальное значение 1. Выполняем проверку проверочного выражения b
Поскольку b на первой итерации внутреннего цикла равно единице, на экран будет выведено
Номер итерации внутреннего цикла - 1
Всё. Первая итерация внутреннего цикла выполнена. После неё оператором инкремента b++ значение переменной b будет увеличено на единицу. И станет равно 2.
Далее аналогично тому, как были выполнены вторая и третья итерации внутреннего цикла на первой итерации внешнего цикла, будут выполнены вторая и третья итерация внутреннего цикла на второй итерации внешнего цикла.
Итак, теперь вкратце. Как сработает вся конструкция.
1. Первая итерация внешнего цикла.
Вывод на экран текста "Номер итерации внешнего цикла - 1"
1.1. Первая итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 1"
1.2. Вторая итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 2"
1.3. Третья итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 3"
2. Вторая итерация внешнего цикла.
Вывод на экран текста "Номер итерации внешнего цикла - 2"
2.1. Первая итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 1"
2.2. Вторая итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 2"
2.3. Третья итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 3"
3. Третья итерация внешнего цикла.
Вывод на экран текста "Номер итерации внешнего цикла - 3"
3.1. Первая итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 1"
3.2. Вторая итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 2"
3.3. Третья итерация внутреннего цикла
Вывод на экран текста "Номер итерации внутреннего цикла - 3"
6. В цикле for можно объявить и использовать как одну переменную, так и несколько.
for (int a = 1, b = 5; a != b; a++, b--)
System.out.println("a = " + a + ", b = " + b);
Обращаю внимание на вариант объявления переменных и присваивания им начальных значений - через запятую. Так тоже можно.
И операторы счётчика также можно перечислить через запятую.
Как сработает этот код.
Переменным a и b будут присвоены начальные значения.
На первой итерации цикла на экран будет выведено
После выполнения тела цикла выполнятся операторы счётчика. Значение переменной a будет увеличено на 1 оператором инкремента и станет равно 2. Значение переменной b будет уменьшено на 1 оператором декремента и станет равно 4.
Затем выполнится проверка проверочного выражения. Значение переменной a не равно значению переменной b. Выражение верно. Значит, выполнится вторая итерация. После выполнения тела цикла на экран будет выведено
Далее сработают операторы счётчика. Оператором инкремента значение переменной a увеличится на 1 и станет равно 3. Значение переменной b оператором декремента будет уменьшено на 1 и также станет равно 3.
Теперь внимание! Проверочное выражение 3 != 3 станет ложным, соответственно, в третий раз тело цикла не выполнится. Вроде бы кажется, что на экран должно быть выведено a = 3, b = 3. Но нет, этого не произойдёт, т.к. проверочное выражение ложно. Вспоминаем про описанную выше "ошибку неучтённой единицы".
7. Работу цикла можно прервать преждевременно при выполнении определённого условия с помощью ключевого слова break
Пример такой конструкции. В начале урока мы создали такой цикл
for ( int i = 1; i
Он последовательно выводит на экран значения переменной i. От 1 до 10.
Можно прервать выполнение цикла, например, при значении переменной i, равном 5. Тогда конструкция будет следующей:
for ( int i = 1; i
System.out.println("Выход из цикла при значении i = " + i);
Результатом выполнения такого кода будет вывод на экран чисел от 1 до 5 (с 1-й по 5-ю итерацию). Затем по мере исполнения 5-й итерации программа дойдёт до исполнения оператора if. Когда условие в скобках будет истинным (при значении i, равном 5) выполнится код в фигурных скобках. Сначала выполнится оператор вывода на экран текста, на экран будет выведено "Выход из цикла при значении i = 5". Затем будет исполнен оператор break, т.е. будет осуществлен выход из цикла. Затем итерации с 6-ой по 10-ю не будут исполнены независимо от истинности проверочного выражения.
Причём, в данном случае мы сначала вывели значение переменной i (равное 5) на экран, и только после этого прервали цикл. А можно не выводить значение i на экран, а сразу прервать цикл. Тогда код будет выглядеть так
for ( int i = 1; i
System.out.println("Выход из цикла при значении i = " + i);
Как сделать правильно, по первому или второму варианту - зависит от поставленной задачи.
8. Можно прервать не весь цикл, как в примере в предыдущем пункте 7, а одну итерацию цикла с помощью ключевого слова continue.
Если рассматривать тот же пример, то конструкция будет следующей
for ( int i = 1; i
System.out.println("Прерываем итерацию при значении i = " + i);
В данном случае на экран будут последовательно выведены значения переменной i от 1 до 4. Затем вместо 5 будет выведен текст "Прерываем итерацию при значении i = 5". Т.е. выполнение 5-й итерации будет прервано, число 5 не будет выведено на экран. Затем цикл продолжит своё выполнение с 6-й итерации и на экран будут последовательно выведены числа от 6 до 10.
Причём, если бы мы не стали выводить текст "Прерываем итерацию при значении i = 5" на экран, то 5-я итерация прервалась бы сразу. Тогда бы на экран были выведены цифры с 1 по 4, а затем с 6 по 10.
Итак, с теорией всё. Переходим к практике. Посмотрим, как выполнятся примеры из текущего урока.
Для понимания языка Java, очень важно понимать его синтаксис. Один из его ключевых, фундаментальных кирпичиков — это переменные.
Что такое переменная в Java
Переменная в Java — это контейнер, в котором может храниться некоторое значение данных для дальнейшего использования в программе. По сути переменная — это минимальная неделимая единица Java-приложения. Переменные в Java бывают двух видов: предназначенные для для маленьких данных (примитивные переменные) и для более сложных, тяжёлых (ссылочные переменные). Сегодня мы рассмотрим первый случай, когда переменные хранят именно само значение данных. Такие переменные называют примитивными.
Объявление переменных в Java
Давайте рассмотрим такой пример: Разберем, что мы видим: int — тип переменной, описывающий целые числа, находящиеся в промежутке -2147483648 до 2147483647 x — имя переменной (нам же нужно их отличать между собой, верно?) = знак присваивания какой-то переменной, какого-то значения 9 — её непосредственной значение ; конец данной команды А теперь соберём всё вместе: мы задаём, что переменная типа int , с именем x имеет значение 9 . Данный пример имеет сокращенную форму записи, полная выглядит так: В первой строке мы видим объявление переменной с присвоением ей имени, то есть этим мы говорим JVM выделить место под переменную int (4 байта) и задать ей имя x . Во второй мы задаём ей значение 9 . До этого у нее было значение, установленное по умолчанию, а именно — 0 . Стоит сказать пару слов об именовании переменных. Как правило они пишутся в нижнем верблюжьем стиле. То есть, например, если у нас есть переменная, описывающая количество людей (count of people), подходящее для неё имя будет: В этом названии первое слово начинается со строчной (маленькой) буквы, а каждое следующее — с заглавной (большой). Это делается для удобства чтения таких имен, так как обычно имена переменных состоят из более чем одного слова.
Переопределение переменных
Вернёмся к нашему примеру с объявлением переменной: Если мы однажды положили в переменную какое-то значение, это не значит, что во время выполнения программы переменная x всегда будет иметь значение 9 . Мы можем её перезаписать: Всё почти так же, но мы уже не добавляем тип ( int ), ведь он прописан при объявлении переменной (объявлении о её существовании). Далее мы только ее переиспользуем, как к примеру здесь мы видим ее перезапись (задаём нашей переменной новое значение, затирая старое). Предположим, что у нас ещё появилась переменная: И задав: x = y; Старое значение переменной x будет удалено, перезаписавшись копией значения y , а именно — 7 . Также можно задать значение какой-то другой переменной, увеличенное на нужное нам число: Так как у нас переменная y была равна 7, в результате x будет равен 12. Более интересна возможность выполнить данные действия: Что мы здесь видим? Переменной x задается значение, равное прошлому, увеличенному на 6, то есть это будет: 12 + 6 = 18. Эту же запись можно сократить, опустив x :
Виды переменных
- переменные объекта;
- локальные переменные;
- переменные класса.
Переменные объекта
Переменные объявляются в классе, но при этом не в методе, конструкторе или блоке. Чтобы вызвать эту переменную, нам нужно для начала создать объект: Переменные создаются лишь после того, как будет создан объект (то есть после создания объекта с помощью new ). В объекте внутренние переменные всегда видимы для всех методов, конструктора или чего-либо внутри этого же объекта. Как говорилось выше, у переменных объекта существуют значения по умолчанию. Для числа значение по умолчанию — равно 0, для логических (boolean) — false, для ссылок на объект — null.
Локальные переменные
Данные переменные объявляются в методах, конструкторах или блоках. Локальные переменные существуют только в вызванном блоке кода, при окончании которого они удаляются из памяти. Они видимы лишь в пределах объявленного метода, конструктора или блока. То есть использовать переменную, например, в другом методе нельзя. Модификаторы доступа нельзя использовать для локальных переменных. Какой в них смысл, если дальше границ метода переменную не видно? Данный вид переменных создается, когда метод (или конструктор, или блок) вызывается и уничтожается после завершения.
Переменные класса
Данный вид переменных ещё называют статическими. Они объявляются со словом-модификатором static , но за пределами метода, конструктора или блока. Вызываем нашу переменную: Где Dog — это имя класса, к которому прикреплена переменная. Значение по умолчанию такое же, как и у переменных объекта. Для чисел по умолчанию это 0, для boolean — false; для ссылок на объект — null. Статическая переменная всегда одна, независимо от того, сколько объектов создано из класса, ведь она крепится только к классу. Переменные класса создаются при запуске программы и уничтожаются, когда выполнение программы завершено. Статические переменные в Java часто используются, когда объявляются как константы. О них поговорим подробнее.
Что такое константы в Java
Читайте также: