Функциональные интерфейсы и лямбда-выражения в Java
Что это такое, зачем нужно и как работает.
Вы наверняка знакомы с ситуацией, когда в разных частях программы должен выполняться один и тот же код, а различие лишь в данных, которые он будет обрабатывать. И тогда кусок кода не дублируют, а поступают хитрее — создают метод. И этот метод вызывают в нужных местах.
Передача простых параметров в виде примитивов или объектов труда обычно не составляет. Но порой в метод требуется передавать не просто переменную, а исполняемый код.
Например, нам нужен метод, который работает с элементами массива, причём только с теми, что соответствуют некоторому условию. А само условие во время написания метода мы можем не знать (или оно будет меняться).
Как поступить? Передавать реализующий условие код с помощью параметра метода! Да, в Java начиная с восьмой версии можно подобное делать. И сейчас вы узнаете как.
Хлебом не корми — дай кому-нибудь про Java рассказать.
Пример
Напишем методы, возвращающие сумму и произведение двух чисел:
А теперь объединим их в один — processTwoNumbers. Он будет принимать два параметра-числа и код, который их обрабатывает.
private int processTwoNumbers ( int a, int b, [сюда передаётся код])
Для выполнения метода sum третий параметр примет в качестве аргумента действие a+b, а для выполнения метода mult — a*b.
Обратите внимание, что третьим аргументом может быть передан не любой код, а только тот, который принимает на вход два параметра заданного типа (у нас int) и возвращает переменную нужного типа ( int).
Значит, надо как-то сообщить об этом компилятору — запретить будущим разработчикам передавать неподходящий код (вроде a+b+c).
Поможет в этом сигнатура метода. Она станет третьим параметром в нашем методе processTwoNumbers:
private int processTwoNumbers ( int a, int b, [сигнатура метода])
Но как записать третий параметр, чтобы сигнатура самого метода processTwoNumbers не разрослась до нечитабельности? Этот вопрос разработчики Java решили изящно. Они придумали функциональные интерфейсы.
Что такое функциональный интерфейс
Функциональный интерфейс — это интерфейс, который содержит ровно один абстрактный метод, то есть описание метода без тела. Статические методы и методы по умолчанию при этом не в счёт, их в функциональном интерфейсе может быть сколько угодно.
Когда параметром метода является функциональный интерфейс, при вызове этого метода одним из аргументов должен быть блок кода.
Передаваемый блок кода должен удовлетворять следующему условию: его сигнатура должна совпадать с сигнатурой единственного абстрактного метода функционального интерфейса.
Звучит непросто, поясним на примере:
Важно. В Java есть несколько готовых функциональных интерфейсов с разным числом и типами входных-выходных параметров. (Как раз из таких ToIntBiFunction выше.) А если мы создаём новый функциональный интерфейс, то важно не забыть аннотацию @FunctionalInterface. Увидев её, компилятор проверит, что интерфейс и правда является функциональным.
Функциональный интерфейс ToIntBiFunction подходит к тому примеру, с которого мы начинали. Это значит, что мы можем передать в него аргументом код, который:
Кусочек ToIntBiFunction говорит: передавай сюда метод с такой же сигнатурой, как у метода внутри меня.
Чтобы внутри метода processTwoNumbers выполнить переданный код, нужно вызвать метод из функционального интерфейса:
Вот мы и добрались до лямбда-выражений.
Что такое лямбда-выражения
Это компактный синтаксис, заимствованный из λ-исчисления, для передачи кода в качестве параметра в другой код.
По сути, это анонимный (без имени) класс или метод. Так как всё в Java (за исключением примитивных типов) — это объекты, лямбды тоже должны быть связаны с конкретным объектным типом. Как вы догадались, он называется функциональным интерфейсом.
То есть лямбда-выражение не выполняется само по себе, а нужно для реализации метода, который определён в функциональном интерфейсе.
Не будь лямбд, вызывать метод processTwoNumbers каждый раз приходилось бы так:
Примечание. biFunction в примере создана с использованием анонимных классов. Без этого нам пришлось бы создавать класс, реализующий интерфейс ToIntBiFunction, и объявлять в этом классе метод applyAsInt. А с анонимным классом мы всё это сделали на лету.
В примере выше всё, кроме одной строчки, избыточно. За содержательную часть (логику работы) отвечает только одно выражение return a + b, а всё остальное — техническая шелуха. И её пришлось написать многовато, даже чтобы просто передать методу код сложения двух чисел.
Здесь и вступают в игру лямбды. С ними можно сократить создание biFunction всего до десяти символов!
А наша лямбда будет такой:
И всё! Этот блок из 10 символов можно передавать как аргумент методу, ожидающему функциональный интерфейс в качестве параметра. Причём чаще всего обходятся без промежуточной переменной — передают напрямую лямбду:
Компилятор проверит, что лямбда подходит функциональному интерфейсу — принимает нужное число параметров нужного типа. Напомню, в нашем примере задействован функциональный интерфейс ToIntBiFunction. Сигнатура его единственного абстрактного метода содержит два параметра ( Integer a, Integer b).
Например, такой вот вызов метода не скомпилируется, потому что передан всего один параметр:
Лямбды записывают по-разному. Мы рассмотрели только один вариант.
Где применяют лямбды?
Много где. Довольно частый случай — обход элементов в цикле:
Ещё лямбды работают в компараторах при сортировке. Допустим, нужно отсортировать коллекцию по последней букве каждого слова:
Редко обходятся без лямбд при работе с коллекциями вместе со Stream API. В следующем примере фильтруем стрим по значению ( filter), меняем каждый элемент ( map) и собираем в список ( collect):
Подытожим
Функциональные интерфейсы в Java 8 избавили разработчиков от чудовищно громоздкого синтаксиса с анонимными классами (когда требовалось передавать некую функциональность в метод) и позволили использовать компактные лямбда-выражения и ссылки на методы.
Сперва синтаксическим сахаром были функциональные интерфейсы, они позволили оперировать блоком кода, который выполняется когда нужно, но реализации были слишком громоздкими. А с лямбдами функциональные интерфейсы стали записываться короче. Так что лямбды — не просто синтаксический сахар, а синтаксический сахар синтаксического сахара.
Теперь на Java можно писать программы в стиле функциональных языков программирования (это когда программа записывается как последовательное применение функций к некоторым значениям и другим функциям, а не как сложная структура из циклов, условных операторов и перекладывания значений туда-сюда). Удивительно, как легко превратить массивные структуры кода в изящные цепочки вызовов, и всё это благодаря лямбдам и функциональным интерфейсам.
Пришел, увидел, обобщил: погружаемся в Java Generics
Java Generics — это одно из самых значительных изменений за всю историю языка Java. «Дженерики», доступные с Java 5, сделали использование Java Collection Framework проще, удобнее и безопаснее. Ошибки, связанные с некорректным использованием типов, теперь обнаруживаются на этапе компиляции. Да и сам язык Java стал еще безопаснее. Несмотря на кажущуюся простоту обобщенных типов, многие разработчики сталкиваются с трудностями при их использовании. В этом посте я расскажу об особенностях работы с Java Generics, чтобы этих трудностей у вас было поменьше. Пригодится, если вы не гуру в дженериках, и поможет избежать много трудностей при погружении в тему.
Работа с коллекциями
Предположим, банку нужно подсчитать сумму сбережений на счетах клиентов. До появления «дженериков» метод вычисления суммы выглядел так:
С появлением Generics необходимость в проверке и приведении типа отпала:
Во второй строчке проверки необходимость тоже отпадала. Если потребуется, приведение типов ( casting ) будет сделано на этапе компиляции.
Принцип подстановки
Тип
Подтип
Number
Integer
List
ArrayList
Collection
List
Iterable
Collection
Примеры отношения тип/подтип
Вот пример использования принципа подстановки в Java:
Ковариантность, контравариантность и инвариантность
Но если мы попытаемся изменить содержимое массива через переменную arr и запишем туда число 42, то получим ArrayStoreException на этапе выполнения программы, поскольку 42 является не строкой, а числом. В этом недостаток ковариантности массивов Java: мы не можем выполнить проверки на этапе компиляции, и что-то может сломаться уже в рантайме.
«Дженерики» инвариантны. Приведем пример:
Wildcards
Всегда ли Generics инварианты? Нет. Приведу примеры:
Это ковариантность. List — подтип List
extends B — символ подстановки с указанием верхней границы super B — символ подстановки с указанием нижней границы где B — представляет собой границу
2. Почему нельзя получить элемент из списка ниже?
The Get and Put Principle или PECS (Producer Extends Consumer Super)
Особенность wildcard с верхней и нижней границей дает дополнительные фичи, связанные с безопасным использованием типов. Из одного типа переменных можно только читать, в другой — только вписывать (исключением является возможность записать null для extends и прочитать Object для super ). Чтобы было легче запомнить, когда какой wildcard использовать, существует принцип PECS — Producer Extends Consumer Super.
и Raw типы
Если мы опустим указание типа, например, как здесь:
Если мы попытаемся вызвать параметризованный метода у Raw типа, то компилятор выдаст нам предупреждение «Unchecked call». Если мы попытаемся выполнить присваивание ссылки на параметризованный тип Raw типу, то компилятор выдаст предупреждение «Unchecked assignment». Игнорирование этих предупреждений, как мы увидим позже, может привести к ошибкам во время выполнения нашего приложения.
Wildcard Capture
Попробуем теперь реализовать метод, выполняющий перестановку элементов списка в обратном порядке.
Более подробно о Wildcard Capture можно прочитать здесь и здесь.
Вывод
Переменные типа
Вот еще пример из класса Enum:
Multiple bounds (множественные ограничения)
Вывод
Переменная типа может быть ограничена только сверху одним или несколькими типами. В случае множественного ограничения левая граница (первое ограничение) используется в процессе затирания (Type Erasure).
Type Erasure
На скриншоте ниже два примера программы:
Разница между ними в том, что слева происходит compile-time error, а справа все компилируется без ошибок. Почему?
Reifiable типы
Почему информация об одних типах доступна, а о других нет? Дело в том, что из-за процесса затирания типов компилятором информация о некоторых типах может быть потеряна. Если она потерялась, то такой тип будет уже не reifiable. То есть она во время выполнения недоступна. Если доступна – соответственно, reifiable.
Решение не делать все обобщенные типы доступными во время выполнения — это одно из наиболее важных и противоречивых проектных решений в системе типов Java. Так сделали, в первую очередь, для совместимости с существующим кодом. За миграционную совместимость пришлось платить — полная доступность системы обобщенных типов во время выполнения невозможна.
И еще одна задачка. Почему в примере ниже нельзя создать параметризованный Exception?
Каждое catch выражение в try-catch проверяет тип полученного исключения во время выполнения программы (что равносильно instanceof), соответственно, тип должен быть Reifiable. Поэтому Throwable и его подтипы не могут быть параметризованы.
Unchecked Warnings
Компиляция нашего приложения может выдать так называемый Unchecked Warning — предупреждение о том, что компилятор не смог корректно определить уровень безопасности использования наших типов. Это не ошибка, а предупреждение, так что его можно пропустить. Но желательно все-так исправить, чтобы избежать проблем в будущем.
Heap Pollution
Как мы упомянули ранее, присваивание ссылки на Raw тип переменной параметризованного типа, приводит к предупреждению «Unchecked assignment». Если мы проигнорируем его, то возможна ситуация под названием » Heap Pollution » (загрязнение кучи). Вот пример:
В строке (1) компилятор предупреждает об «Unchecked assignment».
Рассмотрим еще один пример:
Java разрешает выполнить присваивание в строке (1). Это необходимо для обеспечения обратной совместимости. Но если мы попытаемся выполнить метод add в строке (2), то получим предупреждение Unchecked call — компилятор предупреждает нас о возможной ошибке. В самом деле, мы же пытаемся в список строк добавить целое число.
Reflection
Хотя при компиляции параметризованные типы подвергаются процедуре стирания (type erasure), кое-какую информацию мы можем получить с помощью Reflection.
С появлением Generics класс java.lang.Class стал параметризованным. Рассмотрим вот этот код:
Вывод
Если информация о типе доступна во время выполнения программы, то такой тип называется Reifiable. К Reifiable типам относятся: примитивные типы, непараметризованные типы, параметризованные типы с неограниченным символом подстановки, Raw типы и массивы, элементы которых являются reifiable.
Игнорирование Unchecked Warnings может привести к «загрязнению кучи» и ошибкам во время выполнения программы.
Reflection не позволяет получить информацию о типе объекта, если он не Reifiable. Но Reflection позволяет получить информацию о типе возвращаемого методом значения, о типе аргументов метода и о типе полей класса.
Type Inference
Термин можно перевести как «Вывод типа». Это возможность компилятора определять (выводить) тип из контекста. Вот пример кода:
С появлением даймонд-оператора в Java 7 мы можем не указывать тип у ArrayList :
Предположим у нас есть вот такой класс, который описывает связный список:
Результат обобщенного метода List.nil() может быть выведен из правой части:
Механизм выбора типа компилятором показывает, что аргумент типа для вызова List.nil() действительно String — это работает в JDK 7, все хорошо.
Выглядит разумно, что компилятор также должен иметь возможность вывести тип, когда результат такого вызова обобщенного метода передается другому методу в качестве аргумента, например:
В JDK 7 мы получили бы compile-time error. А в JDK 8 скомпилируется. Это и есть первая часть JEP-101, его первая цель — вывод типа в позиции аргумента. Единственная возможность осуществить это в версиях до JDK 8 — использовать явный аргумент типа при вызове обобщенного метода:
Вторая часть JEP-101 говорит о том, что неплохо бы выводить тип в цепочке вызовов обобщенных методов, например:
Но данная задача не решена до сих пор, и вряд ли в ближайшее время появится такая функция. Возможно, в будущих версиях JDK необходимость в этом исчезнет, но пока нужно указывать аргументы вручную:
После выхода JEP 101 на StackOverflow появилось множество вопросов по теме. Программисты спрашивают, почему код, который выполнялся на 7-й версии, на 8-й выполняется иначе – или вообще не компилируется? Вот пример такого кода:
Посмотрим на байт-код после компиляции на JDK1.8:
А теперь байт-код после компиляции на JDK1.7 – то есть на Java 7:
Чтобы избежать таких проблем, Oracle выпустил руководство по переходу с JDK1.7 на JDK 1.8 в котором описаны проблемы, которые могут возникнуть при переходе на новую версию Java, и то, как эти проблемы можно решить.
Например если вы хотите, чтобы в коде выше после компиляции на Java 8 все работало так же, как и на Java 7, сделайте приведение типа вручную:
Заключение
На этом мой рассказ о Java Generics подходит к концу. Вот другие источники, которые помогут вам в освоении темы:
☕ Основы Java за 30 минут: самоучитель для начинающих
История языка и предпосылки к лидерству
Почему Java так популярен? Во-первых это старый язык по меркам сферы ИТ. Ему уже более 25 лет. За это время было написано огромное количество приложений и библиотек, сформировано, наверное, самое многочисленное комьюнити программистов, которое поможет найти ответ на любой вопрос. Во-вторых java создавался с прицелом на высокую надежность: в то время доминировали языки C и C++, которые обладали высоким порогом входа – нужно было внимательно следить за за каждой строчкой. Легко можно было выстрелить себе в ногу, неправильно использовав множественное наследование, не почистив правильно память и т.д.
Все это позволило сделать Java в свое время самым надежным языком на рынке, поэтому многие компании выбрали его в качестве основного и не прогадали.
Одной из киллер-фич был подход к исполнению кода. Он не компилировался напрямую в бинарники. Компилятор создавал на основе исходного кода байт-код, который уже в свою очередь с помощью специального приложения – JAVA машины исполнялся на компьютере. Такой подход давал ряд существенных преимуществ: программист мог запустить один и тот же код по разными операционными системами, процессорами вообще без каких-либо изменений!
Второе важное преимущество – с каждой новой версией Java-машина получала новые возможности, которые позволяли оптимизировать код на лету. Один и тот же код с каждой новой версией выполнялся все быстрее и быстрее вообще без вмешательства программистов!
Недавно java перешла на новый релизный цикл – каждая новая версия выходит через полгода. Это позволяет быстрее доставлять новые возможности в язык и практически полностью сократить отставание языка от других jvm языков.
Возможно, сейчас многие из преимуществ непонятны, но изучая java вы поймете, насколько они замечательные и как Java в свое время определила развитие ИТ.
После того как мы скачали все и запустили редактор, приступим к изучению.
Объекты и методы в java
У нас есть автомобиль, у него много характеристик. Мы абстрагируемся от них, нас интересует только два параметра: текущая скорость и максимальная скорость. В мире объектно-ориентированного программирования этот подход так и называется – абстракция. Какое поведение мы ожидаем от автомобиля? Всего два – начать движение и остановиться. Напишем этот код на java в файле с именем Car.java:
Здесь мы описали шаблон будущего объекта – класс. У него есть две переменные состояния – speed и maxSpeed, а также две функции, которые описывают поведение объекта.
Теперь приложение нужно запустить, для этого Java надо подсказать, где находится точка входа в него. Для этого существует особое соглашение – нужно добавить в описание любого объекта метод:
Именно, тот код, который мы в нем укажем и начнет выполняться.
Выполним теперь в консоли следующие команды:
Либо, что в разы проще, просто нажимаем зеленую стрелочку около метода и редакторе:
Наше приложение запустилось, но ничего не произошло, потому что мы не добавили никакой логики в метод. Добавим простой вывод на консоль текста:
Результат выполнения виден на консоли.
Отмечу, что каждый файл может содержать только один публичный класс. То есть ключевое слово public вместе со словом class.
Имя файла должно совпадать с именем класса, включая регистр, и иметь расширение .java. Ключевое слово static, говорит компилятору о том, что данный метод/переменная принадлежит именно шаблону объекта, то есть классу, а не конкретному объекту.
Пока не будем особо на это заострять внимание.
Пакеты в java
Стоит отметить, что часто в программах классы называют одинаково, поэтому была предложена идея их раскладывать по папкам, чтобы не было конфликта имен. Папка, в которой находится класс указывается в самом верху файла:
Создатели предложили называть эти папки как доменные имена в интернете, чтобы точно разграничить их, но это не обязательно, вы можете называть их как захотите.
Это так же позволяет легко импортировать чужие классы в свой код:
В нашем пакете нет определения класса Random, поэтому я воспользовался ключевым словом import, чтобы его добавить в нашу программу. Теперь я могу с ним работать. Используя ключевое слово new я создаю на основе класса объект random, который могу использовать в дальнейшем коде. Далее у объекта я вызываю метод, nextInt который описывает следующее поведение объекта: объект возвращает из метода натуральное число, которое произвольно каким-то образом у себя генерирует. Мы не знаем как именно это происходит – мы знаем только то, что в результате вызова этого метода мы получим какое-то целое число типа int. В объектно ориентированном программировании этот прием называется инкапсуляцией – когда объект внутри себя, основываясь на своем состоянии генерирует некий результат, при этом пользователь данного метода не знает как это работает под капотом.
Продолжим далее разбираться с кодом, который был представлен выше. Начнем с самого простого. Если мы хотим добавить какое-то пояснение к коду, мы можем вставить в любую строчку два косых слеша и весь текст после них будет отброшен при компиляции программы, но при просмотре исходного кода он виден.
Создание объектов
В коде у нас была следующая строка:
Здесь мы с помощью ключевого слова new создаем новый объект из его шаблона. Мы указываем, что в своем коде мы будем использовать имя random для обращения к этому объекту. В последней строке мы вызываем метод nextInt который приводит к тому, что в нашу программу возвращается какое-то число, после чего это же число мы передаем в метод println который уже выводит его на экран.
Попробуем для создать класс нашего автомобиля и задать ему поведение:
Запустите код и посмотрите, что будет выведено на консоль.
Теперь вернемся к нашим переменным состояния объекта.
Примитивные типы в java
Компьютеры работают в основном с числами, поэтому были придуманы несколько ключевых слов, которые обозначают разные типы данных, по другому их называют примитивные типы данных:
Ключевое слово
Тип
Пример
boolean
true или false (8-bit число)
true
byte
8-bit число
123
short
16-bit число
123
int
32-bit число
123
long
64-bit число
123L
float
32-bit число
123.0f
double
64-bit число
123.0
char
16-bit число
‘a’
Так как компьютеры развивались постепенно, то на разных этапах своей жизни они могли хранить число, которое не выше разряда процессора, на котором они работают.
Конструкторы объектов
Теперь мы хотим, чтобы наше поведение зависело и от внутреннего состояния объекта. Для этого его надо как-то задать. Посмотрим как это можно сделать.
Мы добавили в наш код специальный код – конструктор. Он позволяет инициализировать объект перед тем как начать им пользоваться. При этом при создании объекта в методе main я добавил два натуральных числа, которые соответственно инициализировали состояние объекта. В конструкторе мы можем указать любую логику, которую необходимо выполнить при создании объекта.
Если вы запустите приложение, то увидите, что кроме строк на экран выводятся и числа – как раз те, которые мы передали в конструкторе. Теперь наш объект инициализирован – у него есть какое-то внутреннее состояние.
Ссылки vs примитивные типы
Теперь рассмотрим ключевое различие между ссылками на объект, которые мы использовали для работой с объектами и примитивными типами. Для ссылок мы можем написать так:
Мы приравняли наш указатель на объект к ключевому слову null, которое говорит виртуальной машине, что по данному указателю уже нельзя обращаться к объекту, то есть вызов myCar.start(); приведет к ошибке. Что произойдет с нашим объектом, который мы создали? В виртуальной машине java запускается сборщик мусора, который обнаружит, что данный объект живет без какой либо ссылки и удалит его из памяти – то есть сотрет его в оперативной памяти.
Но подобное не работает с примитивными типами:
Подобный код вызовет ошибку.
Также стоит отметить, что строки также являются классами, но при этом для них в языке сделаны существенные изменения.
Строки описываются классом String. Посмотрим какие исключения для них есть:
Это единственный класс, который мы можем создать без оператора new.
Кроме того, строки можно складывать друг с другом или другими примитивными типами, но не вычитать, делить и т.п.:
Добавьте данные строчки в наш код и вы увидите, что все прекрасно работает. Но повторюсь, что подобное исключение сделано только для одного класса – String, потом что строки очень часто используются.
Операторы в java
Раз мы упомянули операторы, давайте посмотрим какие предлагает java.
Унарный оператор – это оператор, для работы которого требуется только один операнд, или переменная, часто выполняют простые операции.
Далее мы перейдем к операторам, принимающим два аргумента, которые называются бинарными операторами. Бинарные операторы являются самыми распространенными операторами в языке Java. Ранее мы уже познакомились с оператором сложения для строк.
Они могут использоваться для выполнения математических операций над переменными, создания логических выражений и выполнения базовых присваиваний переменных.
Оператор
Описание
Пример
+
Cложение
var i = 5; var k = 6; System.out.println(i + k)
—
Вычитание
var i = 5; var k = 6; System.out.println(i – k)
*
Умножение
var i = 5; var k = 6; System.out.println(i * k)
/
Деление
var i = 5; var k = 6; System.out.println(i / k)
%
Взятие по модулю
var i = 15; var k = 6; System.out.println(i % k)
Если мы пишем сложное математическое выражение, то лучше пользоваться скобками:
Завершить секцию с операторами я хотел бы таблицей с условными операторами, результат работы которых true либо false:
Оператор
Описание
Пример
==
Сравнение на равенство
var i = 5; var k = 6; System.out.println(i == k)
либо >=
Больше, больше либо равно
var i = 5; var k = 6; System.out.println(i >= k)
&&
Логическое и. В обоих частях должно быть true, чтобы оператор вернул true
System.out.println(true && true)
||
Логическое и. Хотя бы в одной части должно быть true, чтобы оператор вернул true
System.out.println(false || true)
Мы познакомились с самыми популярными операторами в java, настало время их использовать.
Мы хотим, чтобы наш автомобиль мог менять свое поведение, а именно изменять текущую скорость, которую мы задали при его создании.
Добавим новый метод, который будет это делать:
Но мы не хотим, чтобы кто-то, кто пользуется нашим классом мог устанавливать скорость выше максимальной.
Условные выражения
Для того, чтобы наложить какие-либо ограничения на переменную, нам необходимо провести проверку, для этого нам понадобиться использовать условное выражение if:
В круглых скобках мы помещаем условие, которое должно вернуть либо true либо false, а в фигурных мы добавляем тот код, который будет выполнен если условие правдиво.
Так же, если условие вернуло false мы можем добавить с помощью ключевого слова else еще один блок кода, который выполняем в таком случае:
Циклы
Что делать, если мы хотим повторять какой-то блок кода много раз? Если вместо if написать while у нас получится самый простой цикл, который будет выполняться до тех пор пока выражение в круглых скобках истинно или не произойдет прерывания цикла с помощью ключевого слова break, либо пока программа не завершиться, например из другого потока. Выглядеть это будет так:
В данном случае, мы создаем некую примитивную переменную i изначально равную 0. В цикле у нас есть условие того, что она меньше 10, если это не так, то код в фигурных скобках выполняться не будет. В них же мы увеличиваем значение i на единицу, если бы мы этого не делали, то выполнялся бы цикл вечно. Запустите программу и посмотрите, что будет выведено на экран и сколько раз.
Для того, чтобы отделить те логику работы цикла от нашего кода был создан цикл for.
В круглых скобках у нас создается счетчик, передается условие цикла и рецепт, что делать со счетчиком на каждой итерации. Согласитесь, так код выглядит более компактно и логика управления циклом не перемешивается с нашей логикой.
если не передать никаких условий, то получится бесконечный цикл:
Выйти из него никак нельзя, только прервав работу приложения с помощью средств операционной системы. Мы можем прервать его работу с помощью ключевого слова break:
Сообщение будет выведено на консоль и на этом месте цикл остановится.
Массивы и коллекции
В своем проекте мы создали только один автомобиль, давайте теперь создадим несколько и поместим их в какое-то хранилище.
В примере выше мы создали два автомобиля, потом создали массив из указателей на объекты класса Car размером 2 и положили в него указатели на наши объекты. Как видно, отсчет ячеек массива начинается с 0. После чего мы использовали специальную модификацию цикла for для массивов и коллекций, который позволяет пройтись по всем элементам и совершить с ними какую-то логику.
То есть теперь у нас есть объект, который может хранить в себе несколько указателей на другие объекты, но работать с массивами не удобно. Нужно знать заранее точный размер и в какие ячейки, что нужно записывать. Поэтому сейчас самый востребованный метод хранения данных – коллекции.
Перепишем наш код с помощью коллекций:
Как вы можете видеть, код не сильно изменился, но пропали эти неуклюжие записи указателей в конкретные ячейки. Теперь все сохраняется автоматически.
Для объявления коллекции мы написали так:
Что это значит? Здесь мы говорим, что будем использовать коллекцию на основе массива и что в нашей коллекции будут лежать объекты типа Car.
Самое важное, что мы не задали размер нашей коллекции. Так как она позволяет добавлять в себя любое число элементов, которые могут поместиться в оперативной памяти вашего компьютера.
Коллекция типа HashSet (множество) не позволит положить в себя два одинаковых значения, сравните выводы:
А потом замените первую строку
Кроме списка так же популярна коллекция Map, она позволяет присваивать объектам ключи и потом получать эти объекты по уникальному ключу:
Я указал строку в качестве ключа – очень частая практика. И положил в коллекцию два своих объекта. Потом я по ключу достал свой объект и вызвал его метод.
Могу сказать, что коллекции – это то, чем вы будете пользоваться всегда в своей работе, поэтому их надо знать. Здесь я рассказал лишь о трех из них, которые используются в 99% случаев, при том не рассказав какие дополнительные методы они несут в себе.
Исключения
Чтобы произошло, если бы я написал свой запрос так:
То на консоли увидел бы следующее:
Возникла исключительная ситуация и программа прервала свою работу. Так как метод get вернул null о котором мы говорили ранее. Соответственно у нас не было объекта на котором мы могли бы вызвать метод. Для предотвращения таких ситуаций был придумал блок try/catch. Посмотрим как он помог бы решить нашу проблему:
После try я в фигурных скобках пишу код, в качестве которого не уверен. В блоке круглых скобок catch я указываю какого типа ошибки могут возникнуть. Ошибки также являются в java объектами. Соответственно в фигурных скобках я указываю ту логику, которая будет выполнена при возникновении исключительной ситуации.
