Всем привет,
Если вы разработчик Java, который заблудился в поезде релизов Java, не паникуйте! Большинство разработчиков Java не смогли должным образом следовать ему после версии 8. В этой статье я объясню, почему Java начала меняться так быстро, какая версия внесла какие существенные изменения и как оставаться в курсе.
Долгосрочная поддержка (LTS)
Старые разработчики Java знают, что Oracle выпускает новую основную версию Java каждые 3-4 года. Чтобы адаптироваться к стремительно меняющемуся миру программного обеспечения, они решили перейти на более гибкий подход, выпуская новую версию каждые шесть месяцев. Они также начали собирать отзывы о некоторых новых функциях, публикуя их как предварительные версии. Первой гибкой версией была Java 9, выпущенная в сентябре 2017 года. Шесть месяцев спустя Java 10 стала новым требованием для некоторых кадровых агентств, а затем ей последовала Java 11. с аналогичным интервалом выпуска.
Oracle сообщила, что для Java 11 эта версия будет иметь длительную поддержку (LTS). Это означает, что Oracle будет предоставлять поддержку и обновления до 2026 года. Это принесло рынку некоторое облегчение. С другой стороны, Oracle продолжит поддерживать Java 8 до 2030 года из-за своей огромной доли рынка. Когда вы думаете о некоторых устаревших кодах, которые по-прежнему используют Java 7 и ниже, я считаю, что это правильный выбор для поддержки Java 8 на более длительный срок.
Ко времени написания этой статьи Java 15 только что вышла на рынок с большим количеством функций. Однако из таблицы видно, что следующей версией LTS будет Java 17, запланированная на сентябрь 2021 года. Фактически это составляет 3 года между двумя последними версиями LTS, что на самом деле дает разработчикам достаточно времени для изучения и миграции.
Jakarta EE - это новый Java EE
Java EE (Enterprise Edition) также все еще поддерживается Eclipse Foundation под новым именем Jakarta EE. Для тех, кто не знаком с деталями Java EE, это платформа, которая предоставляет API и среду выполнения для создания и запуска крупномасштабных, многоуровневых, масштабируемых, надежных и безопасных сетевых приложений, как поясняется Oracle .
Если у вас есть опыт работы с такой средой, как Spring MVC / Spring Boot, то спецификации Jakarta EE могут показаться вам знакомыми. Основное отличие состоит в том, что Jakarta EE - это в основном спецификации высокого уровня, и их реализации различаются. Например, GlassFish, JBoss и WebSphere - это разные реализации сервера приложений на основе Jakarta EE. Это также одна из причин, по которой компании держатся подальше от Jakarta EE.
Основные изменения в каждой версии
Каждая версия Java вносит некоторые существенные изменения и некоторые незначительные изменения в язык. Список может быть довольно длинным, но есть некоторые особенности, которые, я считаю, должен знать каждый разработчик Java. Ниже вы можете найти, в какой версии были внесены серьезные изменения, чтобы вы могли решить, хотите ли вы их принять или нет.
Java 9
Java 9 выпущена в сентябре 2017 года, и, несмотря на несколько изменений, три из них являются наиболее важными. Полный список изменений вы можете найти здесь.
1. Модульность
Наиболее значительным изменением в Java 9 стала модульная система, получившая название Jigsaw Project.
Модуль - это группа кода, имеющая общие функции. Как видно из названия, модульность делит Java на модули для обеспечения теневого копирования, уменьшения конфликтов версий, добавления дополнительной инкапсуляции, большей безопасности, большей производительности и настраиваемых JDK среды выполнения с меньшим размером.
Чтобы создать новый модуль, вам понадобится module-info.java файл в вашем src.main.java каталоге. Внутри вы можете определить требования к вашему модулю.
Пример показывает, что модуль должен быть ограничен использованием только вышеуказанных пакетов, кроме java.base. После создания вы можете экспортировать его в другой модуль, чтобы использовать его. Я бы посоветовал создать фиктивный проект с 2–3 модулями и поэкспериментировать, чтобы лучше понять его.
2. Частные методы в интерфейсах
Следующая функция Java 9 позволяет писать частные и частные статические методы в интерфейсах, чтобы избежать избыточного кода.
Чтобы продемонстрировать это, я создам пример из реальной жизни и использую «денежный перевод». Во-первых, нам нужно создать наш интерфейс и класс обслуживания.
Это простой пример. Как видно выше, в интерфейсе private void errorImplementation(String name) есть частный метод. Он вызывается методами интерфейса по умолчанию с разными именами ошибок.
Если реализация для метода интерфейса по умолчанию опущена, возникает исключение. Метод private инкапсулирует исключения внутри интерфейса.
Мы выполняем наш тест, и результаты следующие:
Когда вы вызываете метод transfer(), у которого есть реализация, вы видите, что он работает успешно. Однако, когда он пытается выполнить метод viewMoneyTransfer(), он генерирует исключение из метода частного интерфейса.
3. Новая функция REPL (JShell)
Oracle разработала новый инструмент REPL под названием JShell. REPL означает чтение-оценка-печать-цикл. Как следует из названия, он используется, чтобы помочь разработчикам запускать команды, создавать переменные, классы, методы и быстро их тестировать.
Вы можете запустить его, набрав jshell в командной строке, и сразу же начать писать код.
Как видно выше, вы можете создать метод и вызвать его, не назначая его переменной, и вам также не нужно использовать точку с запятой. Более того, вы можете переопределить переменные, задав им новые типы. Он идеально подходит для исследовательского программирования.
Java 10
Java 10 выпущена на шесть месяцев позже, чем Java 9 в марте 2018 года, и внесла два значительных изменения. С остальными изменениями вы можете ознакомиться здесь.
1. Oracle JDK против Open JDK
Чтобы быть более удобным для разработчиков, сообщество Oracle и Java начало продвигать двоичные файлы OpenJDK в качестве основного JDK в будущем. Однако, если вы хотите получить актуальный Oracle JDK и расширенную поддержку более старых версий LTS, таких как 8 и 11, вам необходимо подписаться на Oracle.
2. Вывод типа локальной переменной
В Java 10 появилось ключевое слово var, которое существует во многих других языках для неявной типизации. Неявная типизация означает, что вы можете назначить ему любой тип объекта. Однако в Java вы не можете изменить тип переменной после ее определения. Это делает Java по-прежнему статическим языком.
Основное преимущество использования ключевого слова var - уменьшить многословие языка. Вы можете избежать длинных имен объектов или дважды писать одни и те же возвращаемые типы / имена классов.
На первый взгляд, вы можете задать следующий вопрос: «В чем разница между var и Object?». Ответ; var ключевое слово означает, что вы хотите, чтобы компилятор определил тип.
Использование ключевого слова Object переводит ваш объект в соответствие с типом Object . Это означает, что даже если вы можете использовать общие методы класса Object, вы не можете использовать методы, специфичные для вашего класса. Это создаст ошибку времени компиляции.
Java 11
Java 11, как часть цикла новых выпусков, выпущена на шесть месяцев позже, чем Java 10 в сентябре 2018 года. Она внесла два критических изменения и также является последней версией LTS до Java 17. Вы можете прочитать полный список изменений здесь.
1. Больше никаких javac
Начиная с Java 11, вам больше не нужно использовать javac для компиляции файлов Java. Вместо этого вы можете просто запустить java ,, и он скомпилирует и запустит файлы!
2. Синтаксис локальной переменной для лямбда-параметров
Единственным изменением языка в Java 11 была поддержка нового ключевого слова var в качестве параметров Lambda.
Преимущество такого использования проявляется в сцене, особенно когда вы хотите выполнить проверку аннотации.
Java 12
Java 12 выпущена в марте 2019 года и внесла одно существенное улучшение ключевого слова switch в предварительную версию. Полный список изменений доступен здесь.
1. Переключитесь на «переключение выражений» (предварительный просмотр).
Разработчики Java обычно ненавидят операторы switch из-за их уродливого синтаксиса и опасных откатов. В Java 12 появилась предварительная версия для более чистого способа написания операторов с новыми выражениями переключения.
До Java 12 операторы switch могли вызывать некрасивые блоки кода. Это изменилось с появлением новых операторов стиля стрелки и выражений переключателя.
Как вы можете видеть выше, вы можете присвоить результат новой переменной для дальнейшего использования, и код выглядит намного чище и короче.
Java 13
Java 13 выпущена в сентябре 2019 года и принесла два основных улучшения предварительной версии. Полный список изменений можно найти в здесь.
1. Текстовые блоки (предварительный просмотр)
Новая функция предварительного просмотра текстовых блоков позволила разработчикам легче читать многострочные тексты. Он использует три кавычки, похожие на Python и Groovy:
2. Улучшения Switch Expressions: yield (предварительная версия)
Предварительный просмотр выражений переключения также улучшен, и теперь вы можете напрямую возвращать значение с помощью ключевого слова yield. Это также было возможно раньше, например, какbreak "Monday";, но чтобы уменьшить путаницу и улучшить читаемость, опция разрыва со значением опущена. (Обратите внимание, что ключевое слово break все еще используется для операторов.) Чтобы лучше различать оператор и выражение, ключевое слово yield вводится как альтернатива синтаксису стрелки.
Java 14
Java 14 выпущена в марте 2020 года и принесла пять основных улучшений. Полный список изменений можно найти в здесь.
1. Стандартные выражения Switch Express
Выражения переключения, которые были представлены в качестве предварительной версии в Java 12 и были улучшены в 13, стали стандартом языка.
2. Улучшение NullPointerExceptions
NullPointerExceptions довольно сложно отследить. Java 14 делает шаг вперед и делает их более значимыми. Приведем пример.
Если бы мы запустили первый блок кода до Java 14, мы могли бы получить указанную выше ошибку, не давая подробностей о том, что не так, кроме имени класса и номера строки. Сообщение значительно улучшено в 14;
Помимо имени класса и номера строки, мы также можем видеть, какие параметры или вызов метода вызывают NPE. Это очень полезно для отладки.
3. Записи (предварительный просмотр)
Одна из предварительных функций JDK 14 - это записи. Это реализовано для уменьшения многословности языка. Лучше пояснить это на примере;
Как вы можете видеть выше, у нас есть простой метод Person, который содержит закрытые поля final, все конструкторы args, методы получения, equals, toString и hashCode. Приведенный выше код содержит 37 строк. С новым ключевым словом record приведенное выше сокращается до одной строки;
Он точно такой же, как и первый блок кода. Более того, вы можете настроить инициализацию конструктора;
Вы можете поэкспериментировать с этим, включив функции предварительного просмотра JDK 14.
4. Сопоставление с образцом для instanceof (предварительная версия)
Еще один предварительный просмотр - ключевое слово instanceof. Теперь мы можем дать имя переменной во время условных проверок. Он улучшен, чтобы уменьшить количество дополнительных отливок. Чтобы привести пример;
Он был изменен сверху на;
Как видите, есть два изменения. Во-первых, нам не нужно преобразовывать obj в String, а во-вторых, условие if охватывает само instanceof ключевое слово. Первый блок кода не вызывает ошибку, если obj имеет значение NULL. Для этого нам понадобится еще else в первом блоке, что сделает его еще более подробным. С другой стороны, второй также охватывает случай null и выдает исключение, если obj равно null.
5. Сборщик мусора Z (ZGC) (экспериментальный)
Наконец, старый сборщик мусора получил экспериментальное обновление с Java 14. По материалам OpenJDK Wiki:
По своей сути ZGC является параллельным сборщиком мусора, что означает, что вся тяжелая работа выполняется, пока потоки Java продолжают выполняться. Это значительно ограничивает влияние сборки мусора на время отклика вашего приложения.
Это снижает влияние сборщика мусора на производительность вашего приложения за счет его одновременного запуска. Это введено в качестве экспериментальной функции и может использоваться путем добавления следующих флагов JVM; -XX:+UnlockExperimentalVMOptions и -XX:+UseZGC как в Windows, так и в macOS.
Java 15
Java 15 была выпущена недавно, 15 сентября 2020 года, и принесла четыре основных улучшения. Вы можете сослаться на них здесь, чтобы ознакомиться с полным списком изменений.
1. Текстовые блоки в стандартной комплектации
Текстовые блоки, представленные в качестве предварительной версии в Java 13, стали стандартом языка.
2. Запечатанные классы (предварительная версия)
Запечатанные классы - это очарование объектно-ориентированного программирования на Java. sealed и non-sealed - два ключевых слова, которые представлены в качестве предварительного просмотра в Java 15.
Ключевое слово sealed создает контракт с классом или интерфейсом, чтобы указать, какие подклассы могут их расширять или реализовывать.
Короче говоря, ключевое слово non-sealed разрывает этот контракт и позволяет подклассам продолжать расширять их.
Я считаю, что это намного проще объяснить на примере. Предположим, у нас есть интерфейс с именем Drivable, который является sealed интерфейсом, который разрешает только Vehicle класс.
Интерфейс Drivable имеет один метод, называемый accelerate(). Предположим, что Vehicle класс - это abstract, но также non-sealed;
Это означает, что контракт разорван, и любой класс может расширить Vehicle. Если бы мы не хотели разрывать контракт, нам следовало бы определить Vehicle класс как final или также sealed.
Как видите, теперь другой класс, Car, может свободно расширяться Vehicle.
Однако класс Horse, который пытается реализовать интерфейс Drivable, не может сделать это, потому что это не разрешено интерфейсом sealed Drivable.
Вот также диаграмма, чтобы лучше понять это:
3. Алгоритм цифровой подписи по кривой Эдвардса (EdDSA)
В Java 15 также есть возможность создать пару ключей и подписать ее с помощью современной криптографической EdDSA. Некоторые библиотеки уже предоставляют эту функцию, но теперь это основная функция самой Java.
4. Скрытые классы
Наконец, в Java 15 есть функция под названием скрытые классы. Чтобы дать краткое объяснение, эти классы предназначены для использования создателями фреймворка на уровне байт-кода через отражение, чтобы предотвратить использование, не связанное с фреймворком, другими классы. Однако это сложная тема, которая, как мне кажется, выходит за рамки стандартного разработчика. Для получения дополнительной информации вы можете обратиться к документации JDK.
Java 16 и будущее
Java 16 и более поздние версии будут по-прежнему выпускаться каждые шесть месяцев. Java 16 появится в марте 2021 года, а Java 17, которая станет следующей версией LTS, будет выпущена в сентябре 2021 года. Согласно плану, в версии 17 все экспериментальные и предварительные функции между JDK 11 и JDK 17 станут стандартами. .
Итак, почему мир Java придерживается версии 8?
На это есть более чем однозначный ответ. Первая причина заключается в том, что большинство функций в настоящее время находятся в предварительной версии. Версии между версиями LTS предназначены как для улучшения языка, так и для предварительного просмотра некоторых функций. Таким образом, делая его немного экспериментальным, а не готовым к производству.
Вторая причина в том, что небольшим компаниям легче обновлять версии. Однако в крупных корпорациях для увеличения версии требуется множество разрешений на безопасность и соответствие требованиям. Если вы также учитываете интеграцию, которая может завершиться неудачей с одной версией, процесс миграции может занять несколько месяцев.
Третья и последняя причина - это фреймворки и библиотеки. Такие фреймворки, как Spring, и библиотеки, такие как Lombok и т. Д., Часто используются, особенно веб-разработчиками, и в основном решают более широкие проблемы. Например, я мог бы по-прежнему использовать Ломбок вместо записей. Несмотря на то, что он относительно более подробный, Lombok дает большую гибкость по отношению к различным типам классов, которые можно реализовать.
Должен ли я перейти на Java 15?
Если вы не заинтересованы в использовании одной из новых функций; вам следует придерживаться Java 11 или обновиться до нее, если вы используете более раннюю версию. Вы можете следить за изменениями и экспериментировать с ними до следующего сентября, когда выйдет Java 17, и обновите ее, когда она будет здесь. Конечно, увеличение версий по одной также может быть полезно для предотвращения неожиданных ошибок, особенно если у вас сложная архитектура. Обновление сразу шести версий обычно доставляет больше проблем. Однако обновление до Java 11 зависит от вас.
Заключение
Для Oracle переход к гибкому подходу был смелым шагом, но я считаю, что это был правильный шаг. Они могут собрать больше отзывов о функциях, и мы сможем поэкспериментировать с ними, прежде чем появится LTS-версия. Это дает разработчикам меньше сюрпризов, поскольку заранее знает, что их ждет, и не перегружает их функциями.
Объявление: Мы нанимаем! Если вас интересуют подобные технологии и вы хотели бы работать с нами, посетите нашу страницу Карьера. Мы ищем активных кандидатов, особенно для Бельгии. Итак, присылайте нам свое резюме!
При этом не стесняйтесь экспериментировать с Java 15 сколько хотите, и увидимся, когда выйдет Java 16!
