Что такое javafx в java

Введение в Java FX

JavaFX представляет инструментарий для создания кроссплатформенных графических приложений на платформе Java.

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

С помощью JavaFX можно создавать программы для различных операционных систем: Windows, MacOS, Linux, Android, iOS и для самых различных устройств: десктопы, смартфоны, планшеты, встроенные устройства, ТВ. Приложение на JavaFX будет работать везде, где установлена исполняемая среда Java (JRE).

JavaFX предоставляет большие возможности по сравнению с рядом других подобных платформ, в частности, по сравнению со Swing. Это и большой набор элементов управления, и возможности по работе с мультимедиа, двухмерной и трехмерной графикой, декларативный способ описания интерфейса с помощью языка разметки FXML, возможность стилизации интерфейса с помощью CSS, интеграция со Swing и многое другое.

История JavaFX фактически началась в первой половине 2000-х годов, когда разработчик по имени Крис Оливер (Chris Oliver), будучи работником компании SeeBeyond, разработал для создания графических интерфейсов новый язык F3 (Froms Follows Functions). Впоследствии в 2005 году SeeBeyond была приобретена компанией Sun Microsystems (которая на тот момент развивала язык Java до покупки компанией Oracle). F3 был переименован в JavaFX, а Крис Оливер продолжил работу над новой платформой уже в рамках компании Sun. И в мае 2007 года Sun Microsystems публично анонсировала новую платформу для создания графических приложений. А 4 декабря 2008 года вышел JavaFX 1.0 SDK.

После приобретения Sun Microsystems компанией Oracle в 2010 году была анонсирована, а в 2011 году вышла в релиз версия JavaFX 2.0. В первой версии JavaFX фактически представлял скиптовый язык. Во второй версии был полностью изменен подход. Скриптовый язык был убран, а платформа была полностью переписана фактически с нуля. Теперь создавать приложения можно было с помощью любого языка, который поддерживала JVM. Были добавлены новые API, интеграция со Swing и много других вещей.

Следующими важными вехами в развитии платформы стали версии JavaFX 8 и особенно JavaFX 9, которая вышла в сентябре 2017 года вместе с Java 9 и привнесла в платформу модульность. И если раньше JavaFX поставлялась вместе с Java SE, то сейчас JavaFX отделена от основной функциональности Java SE и используется как отдельный модуль. Последняя версия фреймворка — JavaFX 17 — вышла в сентябре 2021 года.

На данный момент JavaFX представляет предпочтительный способ для создания графических приложений с помощью языка Java, который пришел на смену AWT и Swing. Также стоит отметить, что для работы с JavaFX вместо Java теоретически можно использовать любой язык программирования, который поддерживается JVM.

Установка инструментария

Что необходимо для работы с JavaFX? Прежде всего необходимо установить последнюю версию JDK с официального сайта Oracle: https://www.oracle.com/java/technologies/downloads/.

Стоит учитывать, что версия JDK для работы с JavaFX должна быть от 11 и выше.

JavaFX SDK

Также необходимо загрузить последнюю версию JavaFX SDK с адреса https://gluonhq.com/products/javafx/.

На данной странице можно выбрать дистрибутивы для различных систем и архитектур. Например, если 64-х разрядная OC Windows, то соответственно надо загрузить JavaFX Windows x64 SDK. По сути SDK представляет архив с файлами, и после его загрузки его необходимо распаковать в любое предпочтительное место на жестком диске. Например, в моем случае SDK распакован в папку C:\javafx-sdk-17.0.0.1 .

Модули JavaFX

Если мы откроем папку lib в распакованном SDK, то мы увидим там модули, которые собственно и представляют JavaFX.

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

• javafx.base : определяет базовый функционал фреймворка, в частности, функциональность привязки, свойств, коллекций, событий и т.д.
• javafx.controls : определяет элементы управления, диаграммы и скины.
• javafx.fxml : определяет функционал для работы с FXML.
• javafx.graphics : определяет функциональность окон и контейнеров компоновки, жизненного цикла приложения, возможности рисования, пользовательского ввода, анимации, css и т.д.
• javafx.media : определяет функционал для работы с мультимедиа.
• javafx.swing : определяет интерфейс для взаимодействия и внедрения элементов Swing в приложении JavaFX.
• javafx.web : определяет функционал WebView.
• javafx-swt : модуль для взаимодействия с SWT.

Знакомство с JavaFX

Java FX – это мощный инструмент, который помогает создавать клиентские приложения, оснащенные насыщенными графическими интерфейсами. Технология, развивающаяся в рамках проекта OpenJFX. Она включает в себя все преимущества Java для разработки приложений.

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

История

JavaFX – проект, созданный в первой половине 2000-х годов. Его реализацией занялся некий Крис Оливер, разработчик SeeBeyond. Он создал для графических интерфейсов язык F3. В 2005 году SeeBeyond была выкуплена Sun Microsystems – она развивала Java до покупки корпорацией Oracle. F3 получил совершенно новое название – JavaFX.

Первые наработки платформы были представлены в мае 2007 года. Ее Sun Microsystems анонсирована в качестве инструмента создания графических приложений. В начале декабря 2008 года состоялся официальный релиз Java FX 1.0 SDK.

Чуть позже организация была выкуплена Oracle – права на рассматриваемую платформу перешли к ней. В 2010 корпорация анонсировала, а 2011 выпустила 2 версию Java FX. Она была полностью переписана, а ранее используемый скриптовый язык убрали. С тех пор приложения можно было создавать на любом языке, поддерживающем JVM.

В сентябре 2021 года вышла JavaFX 17. Это последняя актуальная версия на сегодня. Разработчики часто используют для обучения JavaFX 8 и 9.

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

Сферы применения

Данная платформа используется при создании приложений с продвинутым GUI. Программное обеспечение, написанное через технологии JavaFX, получается производительным, надежным и достаточно «легким».

Соответствующий инструмент активно используется в:

• IDE;
• игровом программном обеспечении;
• редакторах и проигрывателях музыки/видео;
• графических и текстовых редакторах.

Это – основное средство написания десктопных приложений. Некоторые мобильные программы, поддерживающие ПК-версии (Telegram, Skype, WhatsApp и им подобные), тоже работают с данной платформой.

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

Что может платформа

Рассматриваемый инструмент разработки оснащен впечатляющим пакетом средств программирования для GUI. Вот некоторые функции, с которыми пользователям предстоит иметь дело:

• шрифты;
• эффекты;
• анимация;
• диаграммы;
• веб-компоненты;
• управление контейнерами;
• оперирование UI;
• макеты;
• базовые функции – Stage, FXML, Scene и им подобные.

Проект оснащен богатой документацией, в которой рассказывается обо всех встроенных модулях, классах и иных элементов платформы. Вся она написана на английском языке. Русскоговорящие пользователи тоже могут найти туториалы и документацию на «родном» языке, но ее значительно меньше.

Основные плюсы проекта

Задумываясь над использованием JavaFX, необходимо помнить о его преимуществах и возможностях. Данный «пакет» активно применяется разработчиками – не только новичками, но и уже более опытными программистами. Он обладает следующими сильными сторонами:

1. Дает возможность писать понятные и управляемые на Java коды. Их удобно не только отслеживать, но и обновлять.
2. Не имеет проблем с кроссплатформенностью и дает возможность формирования нативных образов для мобильных устройств.
3. Поддерживает множество библиотек, необходимых для создания GUI.
4. Умеет работать с CSS, а также 2D и 3D-графикой без дополнительных модулей и расширений.
5. Поддерживает многопоточность.
6. Обеспечивает разработчика многочисленными готовыми инструментами для создания приложений с «сильной» графикой.
7. Поддерживается Java-сообществом, благодаря чему разработчики могут получить помощь по любому вопросу, связанному с платформой.
8. Регулярные обновления и доработки.
9. Простое и легкое освоение. Разобраться с JavaFX будет в разы проще разработчикам, которые уже знакомы с Java и ему подобными языками программирования.
10. Приложение JavaFX, преобразованное в нативный исполняемый файл, будет занимать на порядок меньше пространства на устройстве. Такое программное обеспечение запускается за несколько секунд.

Изучать инструмент рекомендуется всем программистам, работающим с Java и ему подобным языкам. Это современная и удобная платформа, которая позволяет выпускает легкие, практичные, детализированные проекты с потрясающими графическими интерфейсами. Она пришла на замену Swing.

Сравнение со Swing

Swing – технология в Джаве, которая используется для работы с графическими интерфейсами. Она плохо развивалась, поэтому на смену ей пришла платформа JavaFX. Эти две технологии имеют как схожие, так и принципиально различные черты:

Java FX	Swing
Исходный код имеет высокую читабельность. Он является чистым.	В программном коде приложения могут встречаться устаревшие модули.
Применяется для создания программного обеспечения с насыщенным пользовательским интерфейсом.	Используется для работы с обычным GUI
Имеет встроенную поддержку MVC	Не оснащен возможностью работы с MVC
Поддерживается дружелюбным сообществом. Регулярно обновляется и совершенствуется.	Новые опции в Swing не добавляются.
Поддерживает CSS и встроенный API для многопоточности.	Не работает с CSS – стили задаются через программный код. Для многопоточности необходимо устанавливать дополнительные API.
Оснащен FXML для декларативного создания макетов	Не поддерживает декларативную работу с макетами
Работает с 3D-графикой по умолчанию	Для работы с трехмерной графикой требуется установка дополнительных плагинов.
Поддерживает привязку устройств.	Не имеет опций привязки устройств.

Swing – технология работы с графикой, которая входит в состав JDK. JavaFX отсоединен от соответствующего «пакета», начиная с Java 11. Официальная поддержка рассмотренной платформы компанией Oracle прекратится в 2025 году, но она все равно будет работать. Обновления для нее будут выпускаться свободными разработчиками.

Основные библиотеки

JavaFX для разработки приложений предусматривает обширный пакет библиотек. Основная их масса доступна для скачивания, но в стандартный пакет включены основные фреймворки. К ним относят:

1. JacFX. Библиотека для структурирования приложения через слабо связанные многоразовые компоненты JavaFX. Задачи могут быть независимыми от изменений в пользовательском интерфейсе с клиентской программы. Данный прием позволяет избежать проблем, связанных с многопоточностью. Поддерживает асинхронные процессы, коммуникации на основе шин сообщений.
2. RichTextFX – инструменты создания текстовых и кодовых редакторов. Такие приложения будут уметь выделять синтаксические элементы и применять разные шрифты.
3. Ikonli – модуль для создания кастомных иконок.
4. MigLayout – библиотека создания и оперирования макетами.

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

Введение в Java FX

Однажды у меня возникла идея, написать небольшое настольное приложение для своих нужд — что-то типа небольшого словаря для изучения иностранных слов — и я начал ломать голову, а как бы мне это сделать? Естественно, первое, что мне пришло в голову — Swing. Все наверняка слышали о Swing . Это библиотека для создания пользовательских, графических интерфейсов. В связи с тем, что наш горячо любимый Oracle еще не полностью отказался от Swing, он не считается устаревшим, и приложения на нем по-прежнему работают. Однако он больше не модернизируется Swing, и ребята из Oracle дали нам понять, что за JavaFX будущее. Да и по сути, JavaFX использует компоненты Swing как поставщика услуг)

Что такое JavaFX?

JavaFX — это по сути инструментарий GUI для Java. Здесь будет небольшое отступление, и мы вспомним, что такое GUI : Graphical user interface — графический интерфейс пользователя — это разновидность пользовательского интерфейса, в котором все элементы (кнопки, меню, пиктограммы, списки) представленные пользователю на дисплее, выполнены в виде картинок, графики. В отличие от интерфейса командной строки, в GUI у пользователя есть произвольный доступ к видимым объектам с помощью устройств ввода. Зачастую элементы интерфейса реализованы в виде метафор и отображают их свойства и назначение для облегчение понимания пользователя. JavaFX нацелен на создание игр и настольных приложений на Java. По сути им заменят Swing из-за предложенного нового инструмента GUI для Java. Также, он позволяет нам стилизовать файлы компоновки GUI (XML) и сделать их элегантнее с помощью CSS, подобно тому, как мы привыкли к сетевым приложениям. JavaFX дополнительно работает с интегрированной 3D-графикой, а также аудио, видео и встроенными сетевыми приложениями в единый инструментарий GUI… Он прост в освоении и хорошо оптимизирован. Он поддерживает множество операционных систем, а также Windows, UNIX системы и Mac OS.

Особенности JavaFX:

• JavaFX изначально поставляется с большим набором частей графического интерфейса, таких как всякие там кнопки, текстовые поля, таблицы, деревья, меню, диаграммы и т.д., что в свою очередь сэкономит нам вагон времени.
• JavaFX часто юзает стили CSS, и мы сможем использовать специальный формат FXML для создания GUI, а не делать это в коде Java. Это облегчает быстрое размещение графического интерфейса пользователя или изменение внешнего вида или композиции без необходимости долго играться в коде Java.
• JavaFX имеет готовые к использованию части диаграммы, поэтому нам не нужно писать их с нуля в любое время, когда вам нужна базовая диаграмма.
• JavaFX дополнительно поставляется с поддержкой 3D графики, которая часто полезна, если мы разрабатываем какую-то игру или подобные приложения.

Давайте немного пройдёмся по основным составляющим нашего окна:

• Stage — по сути это окружающее окно, которое используется как начальное полотно и содержит в себе остальные компоненты. У приложения может быть несколько stage, но один такой компонент должен быть в любом случае. По сути Stage является основным контейнером и точкой входа.
• Scene — отображает содержание stage (прям матрёшка). Каждый stage может содержать несколько компонентов — scene, которые можно между собой переключать. Внутри это реализуется графом объектов, который называется — Scene Graph (где каждый элемент — узел, ещё называемый как Node ).
• Node — это элементы управления, например, кнопки метки, или даже макеты (layout), внутри которых может быть несколько вложенных компонентов. У каждой сцены (scene) может быть один вложенный узел (node), но это может быть макет (layout) с несколькими компонентами. Вложенность может быть многоуровневой, когда макеты содержат другие макеты и обычные компоненты. У каждого такого узла есть свой идентификатор, стиль, эффекты, состояние, обработчики событий.

Итак, давайте двигаться немного в сторону кода. Так как у меня юзается Java 8, мне не нужно подтягивать никакие зависимости, так как JavaFx по дефолту есть в JDK(как и в Java 9,10), но если у нас Java 11+, то нужно пойти в maven repository и стянуть оттуда зависимости.

JavaFX: примеры использования

Создаем обычный класс с методом main (точку входа):

 public class AppFX extends Application < public static void main(String[] args) < Application.launch(); >@Override public void start(Stage primaryStage) throws Exception < pimarySatge.show(); >> 

Тут наш класс наследуется от javafx.application.Application (который у нас из коробки Бугага). В мейне вызываем статический метод Application — launch() для запуска нашего окна. Также у нас наша idea будет ругаться, на то что мы не реализовали метод Application — start , что мы в итоге и делаем. Для чего он нужен? А для того, чтобы можно было управлять свойствами (функционалом нашего окна). Для этого у нас юзается входящий аргумент primaryStage , у которого мы вызываем метод show , чтобы можно было увидеть запускаемое окно в main . Давайте немного заполним наш метод start :

 public void start(Stage primaryStage) throws Exception < primaryStage.setTitle("Dogs application"); primaryStage.setWidth(500); primaryStage.setHeight(400); InputStream iconStream = getClass().getResourceAsStream("/images/someImage.png"); Image image = new Image(iconStream); primaryStage.getIcons().add(image); Button button = new Button("WOF WOF . '"); button.setOnAction(e -< < Alert alert = new Alert(Alert.AlertType.INFORMATION, "WOF WOF WOF. "); alert.showAndWait(); >); Scene primaryScene = new Scene(button); primaryStage.setScene(primaryScene); primaryStage.show(); > 

Итак, что мы тут видим? Пробежимся построчно: 2 — задаем название самого окна(stage) 3,4 — задаем его размеры 6,7 — задаем путь читающего потока к файлу (иконке) 8 — создаем файл как объект Image, который связан с реальным файлом потоком передаваемым в конструкторе 9 — задаем иконку в верхнюю панель окна 11 — создаем объект кнопки 13-16 — задаем реакцию при нажатии кнопки 17 — создаем сцену, куда помещаем нашу кнопку 18 — сцену помещаем на наше общее окно 20 — задаем флаг видимости для окна И как результат получаем небольшое окошко, для приветствия наших любимых песелей: Всё выглядит в разы проще, чем Swing, неправда ли? Но ещё не конец. Полностью писать весь код для отображения приложения, не есть хорошо, нужно его как-то делить, дабы сделать его более понятным (графические составляющие в одни корзинки, логику в — другие). И тут на сцену выходит xml…. О боже мой, xml? Именно. А конкретно — используется его специфичная реализация для JavaFX — FXML, в которой мы определяем графические компоненты приложения и их свойства (там всякие размеры и прочее), а после — связываем с контроллером, который и помогает управлять логикой. Давайте рассмотрим пример такого xml:

          function buttonClicked() 

2 — язык сценариев который мы юзаем 4-6 — импортируемые данные 8-9 Vbox — контейнер, который размещает подкомпоненты в одной строке. 11 — выводим некий текст 13 — кнопка при нажатии которой мы юзаем метод описанный в скрипте на 15-18 строке Тут должен быть код вызова данного xml файла в методе start , но сейчас это не столь важно, и мы это опустим (ниже будет пример подтягивания данного файла). Итак, xml — это, конечно, хорошо (да не очень), вручную писать их очень заморочено, разве это не прошлый век?

Знакомство с JavaFX SceneBuilder

Именно на этом моменте на сцену выходит (барабанная дробь) — SceneBuilder В JavaFX Scene Builder — это инструмент, с помощью которого мы можем конструировать наши окна в виде графического интерфейса и после их сохранять, и эта программа на основании результата будет конструировать xml файлы, которые мы будем подтягивать в нашем приложении. Как-то так выглядит интерфейс данного fmxl-строителя:

Небольшое отступление. JavaFX уроки

Детали установки я упущу, и подробное изучение данного инструмента тоже. Это темы, которые стоит изучить дополнительно. Поэтому всё же оставлю пару интересных ссылочек на JavaFX уроки: раз (онлайн учебник по JavaFX) и два (еще один неплохой туториал). Давайте немного пробежимся по небольшому примеру, который я набросал. В итоге у меня получилось, что-то вроде: (такое себе окошко для учёта собак) При выборе песеля и нажатии кнопки Delete, собака удаляется из нашего списка. При выборе четырехлапого друга и изменении его полей, а после нажатии кнопки Edit — инфа собачки обновляется. Когда нажимаем кнопку New, вылазит окошко для создания записи новой собаки (для начала её имени): После жмем Save и заполняем в первом окне остальные её поля, а затем жмём кнопку Edit для сохранения. Звучит несложно, верно? Давайте посмотрим, как это будем выглядеть у нас в приложении Java. Для начала, я просто оставлю здесь xml макеты для двух этих окон сгенерированных в SceneBuilder : Первое(базовое):

Второе(для создания новых пёсиков):

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

 public class AppFX extends Application < private Stage primaryStage; private AnchorPane rootLayout; private ObservableListlistDog = FXCollections.observableArrayList(); public AppFX() 

Тут мы видим конструктор, который будет заполнять наши начальные данные (которые храним в специальном листе — ObservableList).

 public static void main(String[] args) < Application.launch(); >@Override public void start(Stage primaryStage) throws Exception

Ничего особенного — main и реализация start() , запускающая приложение:

 public void showBaseWindow() < try < FXMLLoader loader = new FXMLLoader(); loader.setLocation(AppFX.class.getResource("/maket/rootWindow.fxml")); rootLayout = loader.load(); Scene scene = new Scene(rootLayout); primaryStage.setScene(scene); InputStream iconStream = getClass().getResourceAsStream("/icons/someImage.png"); Image image = new Image(iconStream); primaryStage.getIcons().add(image); BaseController controller = loader.getController(); controller.setAppFX(this); primaryStage.show(); >catch (IOException e) < e.printStackTrace(); >> 

Итак, тут мы видим метод, который мы собственно и запускаем в start() , а именно — задающий настройки нашего базового окна. Таких как на xml макете в ресурсах: задание ему иконки, связывание его с конкретным контроллером, и задание контроллеру ссылки на this класс)

 public void showCreateWindow(Dog dog) < try < FXMLLoader loader = new FXMLLoader(); loader.setLocation(AppFX.class.getResource("/maket/new.fxml")); AnchorPane page = loader.load(); Stage dialogStage = new Stage(); dialogStage.setTitle("Wow Wow Wow"); dialogStage.initModality(Modality.WINDOW_MODAL); dialogStage.initOwner(primaryStage); dialogStage.setScene(new Scene(page)); CreateController controller = loader.getController(); controller.setDialogStage(dialogStage); controller.setDog(dog); dialogStage.showAndWait(); >catch (IOException e) < e.printStackTrace(); >> > 

Тут мы видим метод, который ответственен за появление второго окна — окна создания новой записи (имени новой собаки). Также задаем контроллер, xml макет, stage и прочее… Следующим рассмотренным классом у нас будет модель, представляющая нашу собаку (инфу о ней): @Data

 public class Dog < private StringProperty name; private StringProperty breed; private IntegerProperty age; private StringProperty city; private IntegerProperty levelOfTraining; public Dog(String name, String breed, int age, String city, int levelOfTraining) < this.name = new SimpleStringProperty(name); this.breed = new SimpleStringProperty(breed); this.age = new SimpleIntegerProperty(age); this.city = new SimpleStringProperty(city); this.levelOfTraining = new SimpleIntegerProperty(levelOfTraining); >public Dog() < name = new SimpleStringProperty(); breed = null; age = null; city = null; levelOfTraining = null; >> 

Тут мы видим два конструктора.Один — почти обычный со всеми аргументами (почти, потому что мы юзаем специальные FX оболочки простых типов) и конструктор без аргументов: его мы используем при создании новой собаки, у которой по началу есть только имя. Контроллер для базового окна: @Data

 public class BaseController < @FXML private TableViewdogs; @FXML private TableColumn nameList; @FXML private TextField name; @FXML private TextField breed; @FXML private TextField age; @FXML private TextField city; @FXML private TextField levelOfTraining; private AppFX appFX; 

Тут мы видим наши поля объекта, но в формате TextField. Это формат, который представляет поле для ввода текста. @FXML — аннотация предназначенная для связывания кода Java и соответствующего объекта нашего макета (кнопки, поля или ещё чего-то).

 @FXML private void initialize() < nameList.setCellValueFactory( cellData ->cellData.getValue().getName()); dogs.getSelectionModel().selectedItemProperty().addListener( (observable, oldValue, newValue) -> showDogsInformation(newValue)); > 

Тут мы видим метод для вывода имён собак, справа в списке (его аннотация @FXML связывает с компонентом макета JavaFX TableView).

 public void setAppFX(AppFX appFX) < this.appFX = appFX; dogs.setItems(appFX.getListDog()); >private void showDogsInformation(Dog dog) < if (dog != null) < name.setText(dog.getName() != null ? dog.getName().getValue() : null); breed.setText(dog.getBreed() != null ? dog.getBreed().getValue() : null); age.setText(dog.getAge() != null ? String.valueOf(dog.getAge().get()) : null); city.setText(dog.getCity() != null ? dog.getCity().getValue() : null); levelOfTraining.setText(dog.getLevelOfTraining() != null ? String.valueOf(dog.getLevelOfTraining().get()) : null); >else < name.setText(""); breed.setText(""); age.setText(""); city.setText(""); levelOfTraining.setText(""); >> 

В первом методе мы видим задание внутренней ссылки на класс, реализующий Application (для того, чтобы можно было дёрнуть его метод для вызова второго окна), и задание начального списка для отображения. Второй же проверяет, есть ли определенные данные текущей собаки, и на основании этого задаёт текстовые поля:

 @FXML private void delete() < int selectedIndex = dogs.getSelectionModel().getSelectedIndex(); dogs.getItems().remove(selectedIndex); >@FXML private void edit() < int selectedIndex = dogs.getSelectionModel().getSelectedIndex(); dogs.getItems().set(selectedIndex, new Dog(name.getText(), breed.getText(), Integer.valueOf(age.getText()), city.getText(), Integer.valueOf(levelOfTraining.getText()))); >@FXML private void create() < Dog someDog = new Dog(); appFX.showCreateWindow(someDog); if (someDog.getName() != null && !someDog.getName().getValue().isEmpty()) < appFX.getListDog().add(someDog); >> > 

Тут мы видим три метода, базового окна, связанных с кнопками:

• delete — по индексу удаляем выбранную(выделенную) собаку;
• edit — создаем новую собаку с переданными данными, и задаем ее вместо той которая была до этого;
• create — создаем новую собаку и дергаем метод вызова окна создания, передав новый объект, и после закрытия которого если имя не null, то сохраняем нового питомца.

Двигаем дальше, контроллер окна для создания собаки: @Data

 public class CreateController < private Stage dialogStage; private Dog dog; @FXML private TextField nickName; @FXML private void ok() < if (nickName != null && !nickName.getText().isEmpty()) < dog.setName(new SimpleStringProperty(nickName.getText())); dialogStage.close(); >> @FXML private void cansel() < dialogStage.close(); >> 

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

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

Что такое JavaFX

Узнайте о JavaFX – мощном инструменте для создания красивых и интерактивных приложений на Java, начиная с простого примера.

Алексей Кодов
Автор статьи
7 июня 2023 в 16:04

JavaFX является мощным инструментом для создания современных графических пользовательских интерфейсов (GUI) для приложений на языке программирования Java. Он предоставляет множество элементов управления, анимации, графики и мультимедиа, которые позволяют разработчикам создавать красивые и интуитивно понятные приложения.

Преимущества JavaFX

Несколько ключевых преимуществ использования JavaFX включают:

1. Кросс-платформенность: JavaFX поддерживает все основные операционные системы, такие как Windows, macOS, Linux и даже мобильные платформы, например, Android и iOS.
2. Богатая библиотека элементов управления: JavaFX предоставляет множество встроенных элементов управления, таких как кнопки, текстовые поля, таблицы, списки, слайдеры и многое другое.
3. CSS-стилизация: JavaFX позволяет использовать CSS для стилизации элементов интерфейса, что делает процесс дизайна легким и гибким.
4. FXML: Это XML-подобный язык разметки, который упрощает процесс создания и модификации графического интерфейса пользователя.
5. Аппаратное ускорение: JavaFX использует аппаратное ускорение для быстрой отрисовки графики, что особенно полезно для анимаций и игр.

Пример простого приложения на JavaFX

Давайте рассмотрим пример простого приложения на JavaFX. В этом примере мы создадим окно с кнопкой, при нажатии на которую будет выводиться сообщение «Привет, JavaFX!».

import javafx.application.Application; import javafx.event.ActionEvent; import javafx.event.EventHandler; import javafx.scene.Scene; import javafx.scene.control.Button; import javafx.scene.layout.StackPane; import javafx.stage.Stage; public class HelloWorld extends Application < public static void main(String[] args) < launch(args); >@Override public void start(Stage primaryStage) < Button btn = new Button(); btn.setText("Нажми на меня!"); btn.setOnAction(new EventHandler<ActionEvent>() < @Override public void handle(ActionEvent event) < System.out.println("Привет, JavaFX!"); >>); StackPane root = new StackPane(); root.getChildren().add(btn); Scene scene = new Scene(root, 300, 250); primaryStage.setTitle("Пример JavaFX"); primaryStage.setScene(scene); primaryStage.show(); > >

Java-разработчик: новая работа через 11 месяцев
Получится, даже если у вас нет опыта в IT

Заключение

JavaFX предлагает множество возможностей для создания современных и функциональных графических интерфейсов для Java-приложений. Если вы новичок в сфере Java-разработки, ознакомьтесь с нашими другими статьями, чтобы узнать больше о Java и её возможностях. ��