Java как сделать всплывающее окно
Обновлено: 04.05.2024
Как сделать всплывающие подсказки в JavaFX
Давным-давно, когда люди ещё делали домашние странички, интернет был по шипучему модему, а Napster казался опасной провокацией коммунистов, простенькие оконные приложения под Windows очень часто писали на библиотеке VCL. Одни пользовались Delphi (но признавались только домашним), другие смело запускали её из C++ Builder (и удивлялись ещё одному String, а также спискам, которые начинаются с 1). А кто-то ухитрялся писать на нём под unix-ы (вы помните Kylix? А он был!)
В VCL почти у всех визуальных компонент были свойства ShowHint и Hint. Если быть точным, они были у всех компонент оконного типа (кнопок, выпадающих списков и прочих панелек).
В строковой Hint писался текст подсказки, а булевый ShowHint мог её отключить. А более прокачанные даже знали, что можно сделать расширенный вариант подсказки. Если написать в Hint Нажми меня|Кнопка просит, чтобы вы её нажали, то левая часть всплывёт, а правая будет передана в событие. Это событие перехватывали и показывали полученный текст в строке состояния.
Настолько простые и удобные подсказки были предметом величайшей зависти тех, кто сидел на MFC (никаких WinForms в тогдашней Visual Studio ещё не было, не говоря о WPF), поддерживал OWL или штурмовал чистый WinAPI с Петцольдом наперевес. Кто знает, может быть кто-то из них и приложил свою мозолистую от кодинга руку к тому, что уникальная по своей удобности технология подсказок оказалась полностью утрачена в JavaFX.
Что у нас есть?
В JavaFX за подсказки отвечает компонент Tooltip. По всей видимости, это тайный компонент, потому что, к примеру, SceneBuilder его знать не знает.
Если мы создадим новый Tooltip, а потом привяжем через setTooltip, то при наведении курсора на компонент, к которому привязывали, мы и правда увидим подсказку. На чёрном фоне (так надо). И с поддержкой картинок (спасибо).
Но JavaFX не позволит нам расслабиться: свойство Tooltip (и соответствующие методы) есть только у наследников класса javafx.scene.control.Control. А все панели и прочие области наследуются от javafx.scene.layout.Region. И никаких подсказок на них всплывать, получается, не может. Видимо, раз в приложении есть панель, то пользователю должно быть и так ясно, что там находится.
А может, разработчиков в школе слишком часто заставляли решать задачу «двумя разными способами»? Что до поддержки подсказок в панели статуса, то их нет даже близко.
А ТЗ требовало панель состояния и подсказки в ней в том числе и на панелях. И я справился своими силами.
Показываем и подсказываем
Я не стал пытаться заставить Tooltip всплывать над компонентами «неправильного» типа. Я просто хотел получить простой стандартный интерфейс, чтобы привязывать к компонентам подсказки в строке состояния, И, по возможности, делать всплывающие подсказки.
Причём интерфейс должен быть настолько простым, чтобы я мог поручить непосредственное привязывание подсказок студенту-стажёру, который работает на полставки.
Как и положено рабочему прототипу, это решение выглядит почти тривиальным. Поэтому я исключил все комментарии, которые бы только растянули статью. Но у него есть маленькое, но преимущество: приспособить его к своему проекту намного быстрее и проще, чем писать с нуля.
Особенно если вы такой же лентай, как и я.
Подсказываем
Саму подсказку мы будем хранить в двух классах, унаследованных от общего предка. Сначала создадим абстрактный класс подсказки.
Буква A перед названием пошла из старых учебников C++, по которым я учился программировать. Я не против, если вы привыкли по-другому (например, с постфиксом Base и т. п.). Я люблю начальную A, потому что она короткая.
И, как вы наверное догадались, любовь к шаблонам и генетикам у меня тоже из C++:
Теперь создадим по классу на оба случая. Вот класс для Region:
А вот для Control:
Контролируем
Теперь берёмся за Controller. А контроллер у нас начинается с интерфейса. Java без интерфейса — это как хакер без ноутбука.
А вот и сам контроллер:
Дальше можно смело писать, даже не задумываясь, кто от кого унаследован:
А если у нас есть labelStatusBar в качестве строки состояния, то мы можем использовать и его:
Конечно, эту реализацию стоит доработать — ведь чисто теоретически в приложении может быть и больше одной строки состояния. Если вам такие известны (разумеется, современные, на JavaFx и активно используемые) — дайте знать.
Заключение
К сожалению, этот набор из 4 классов слишком объёмен, чтобы свестись к одному документу на pastebin. Но и слишком мал и несамостоятелен, чтобы стать гордым maven-пакетом и занять почётное место в известном репозитории.
Но я всё равно надеюсь, что он найдёт своего пользователя (точнее, своего разработчика). А может, он попадётся на глаза разработчикам из Oracle и убедит их сделать подсказки удобней.
Есть одобренные самой Oracle библиотеки расширений — возможно. стоит попытаться пристроить этот интерфейс в одну из них?
Создать всплывающее окно в Java
Java позволяет нам создавать несколько типов компонентов графического интерфейса с использованием таких библиотек, как AWT, Swing и JavaFX. В этом уроке мы рассмотрим диалог и узнаем, как его создать. В следующих примерах мы будем использовать два класса: JOptionPane и JDialog .
Создать всплывающее окно в Java с помощью JOptionPane
Ниже приведены примеры методов:
Создать всплывающее окно в Java с помощью JDialog
Во втором методе мы используем класс Jdialog . Для создания фрейма нам нужен объект jFrame , который передается конструктору Jdialog в качестве аргумента, когда мы создаем объект JDialog и jd . Теперь нам нужно установить макет диалога, который указывает, как размещать компоненты внутри диалога. Мы устанавливаем функцию FlowLayout() , которая выстраивает компоненты в линию с помощью jd.setLayout() .
Чтобы установить положение и размер всплывающего окна, мы используем функцию setBounds() , где первые два аргумента - это позиции x и y, а последние два аргумента - ширина и высота.
Наконец, мы добавляем все компоненты или объекты, которые мы создали с помощью jd.add() .
Сопутствующая статья - Java GUI
JWindow, JFrame, JDialog
Окна являются основой пользовательского интерфейса любой операционной системы. Они визуально разделяют выполняемые в среде приложения. Окна, используемые в библиотеке Swing, мало чем отличаются от окон библиотеки AWT, которые представляют собой окна операционной системы.
Все окна библиотеки Swing — а к ним относятся окно без рамки JWindow, окно с рамкой JFrame и диалоговое окно JDialog — являются исключением из правила, согласно которому все компоненты Swing представляют собой легковесные компоненты и унаследованы от базового класса JComponent. Окна Swing являются тяжеловесными контейнерами для размещения в них легковесных компонентов, которые операционная система не видит.
Наиболее полезные JFrame методы
| Методы | Описание |
|---|---|
| setLocation() | Эта группа методов позволяет задать позицию и размеры окна на экране. setLocation() задает позицию окна, setSize() позволяет указать его размеры, а с помощью setBounds() можно сразу задать прямоугольник, который займет ваше окно на экране |
| setSize() | |
| setBounds() | |
| раск() | Позволяет «упаковать» имеющиеся в окне компоненты, так чтобы они занимали столько места, сколько им необходимо. Компоненты при вызове этого метода переходят в «видимое» состояние, хотя и не появляются на экране до вызова одного из следующих методов |
| show() | Отображение окна на экране. После вызова этих методов компоненты переходят в «видимое» состояние и начинают обслуживаться очередью событий. Метод show() к тому же проводит валидацию содержащихся в окне компонентов |
| setVisible() | |
| dispose() | Убирает окно с экрана (если оно в момент вызова метода видимо) и освобождает все принадлежащие ему ресурсы. |
Окно JWindow
«Родителем» всех окон Swing является окно без рамки и без элементов управления JWindow.
Класс JWindow представляет собой окно без рамки и без элементов управления, предназначенных, к примеру, для его закрытия или перемещения. Данный тип окна дает минимальные возможности по своей настройке, в отличие от чаще всего используемого окна JFrame. Окно без рамки не часто требуется в программах. Однако в отдельных случаях оно может быть полезно, особенно в тех случаях, когда необходимо ненадолго вывести на экран какую-либо информацию типа заставки программы или подсказку для пользователя, и управлять окном с этой информацией не нужно.
Окна JWindow используются всплывающими меню JPopupMenu в тех ситуациях, когда в окне приложения не хватает места для размещения легковесного компонента в слое POPUP_LAYER многослойной панели, где всплывающие меню располагаются по умолчанию. В такой ситуации вместо легковесного компонента создается небольшое окно без рамки JWindow, которое можно разместить в любом месте экрана, потому что оно принадлежит операционной системе. В этом окне и размещается всплывающее меню.
Рассмотрим пример JWindowTest. Основная идея использования окна без рамки JWindow заключается в копировании части "изображения рабочего стола" в окно приложения. Благодаря появившемуся в пакете JDK 1.3 классу Robot можно "снимать" экранную копию рабочего стола.
Пример JWindow
В этом примере приложение наследуем от окна JWindow, чтобы удобнее вызывать методы этого класса и добавлять в окно компоненты. Объект Robot необходимо создавать в блоке try . catch, т.к. его создание может быть запрещено менеджером безопасности, используемым виртуальной машиной Java. Впрочем, нам нарушение безопасности не грозит, потому что мы создаем отдельное приложение, а не апплет.
Вырезаем часть изображения "рабочего стола" методом createScreenCapture() в стороне он местоположения нашего окна. Затем в панель содержимого окна добавляется компонент ImageDraw, который и отображает вырезанное изображения рабочего стола. После вывода окна на экран программа засыпает на 10 секунд, а потом заканчивает свою работу.
Скриншот рабочего стола с интерфейсом окна примера JWindow представлен на следующем рисунке.
Прежде чем производить настройку окна, в примере JWindowTest вызывается конструктор базового класса ключевым словом super() без параметров. На самом деле окна без рамки JWindow обязательно требуют при создании указывать своего «родителя» — окно с рамкой JFrame,что не всегда может быть неудобно. Специально для таких случаев в класс JWindow был добавлен конструктор без параметров, который создает вспомогательное невидимое окно JFrame и использует его как «родителя». После этого все окна без рамки, созданные таким образом, задействуют только это окно и экономят ресурсы.
Следует также отметить, что с помощью конструктора без параметров создается окно JWindow, неспособное получать фокус ввода. Чаще всего именно такое поведение необходимо (ведь панелям инструментов, всплывающим заставкам и меню фокус ввода не нужен). При необходимости получения фокуса ввода, используйте метод setFocusableWindowState(true).
Окно JFrame
Окно JFrame наследует свойства класса JWindow и представляет собой наиболее часто используемое в приложениях окно «общего назначения». Основные отличия окна JFrame от JWindow :
- наличие рамки, которая позволяет изменять размер окна;
- наличие заголовка с названием приложения (заголовок может быть пустым);
- возможность использования системного меню, позволяющее проводить манипуляции с окном и приложением;
- наличие кнопок управления для закрытия и свертывания окна.
Для размещения компонентов пользовательского интерфейса в подавляющем большинстве приложений применяется класс JFrame. Разработчики Swing определили специальный метод закрытия окна setDefaultCloseOperation, существенно упрощающий эту операцию. Рассмотрим простой JFrame пример (JFrameWindowListener) с обработкой события закрытия окна.
JFrame пример
В примере создается окно JFrame с определением заголовка в конструкторе базового класса. Для определения титульной строки окна можно также использовать метод setTitle() класса JFrame.
Прежде чем задать размеры окна и отобразить его на экране, вызывается метод setDefaultCloseOperation(). Данный метод позволяет указать, какое действие будет произведено при предварительной обработке события processWindowEvent() перед закрытием окна. По умолчанию используется константа HIDE_ON_CLOSE, убирающая окно с экрана при его закрытии. Можно использовать значение EXIT_ON_CLOSE, которое указывает, что при закрытии окна необходимо закончить работу приложения.
В примере методу setDefaultCloseOperation передается константа DO_NOTHING_ON_CLOSE - ничего не делать при закрытии окна. К окну JFrame подключается слушатель и обработка события закрытия окна выполняется в методе windowClosing. Алгоритм обработки построен таким образом, что окно закрывается при третьей попытке. Номер попытки отображается в метке интерфейса.
Скриншот рабочего стола с интерфейсом окна нашей программы представлен на следующем рисунке.
Для определения иконки окна необходимо использовать метод setIconImage(). Иконка располагается на кнопке свернутого окна или в заголовке окна в нормальном состоянии.
Из дополнительных возможностей окна с рамкой JFrame следует упомянуть о его способности «прятать» свои «украшения»: рамку и элементы управления окном. Делает это метод JWindow.
События окон, WindowListener, WindowFocusListener
Окна Swing (JWindow, JFrame, JDialog) поддерживают два типа событий :
- WindowListener - позволяет узнать об изменениях в состоянии окна;
- WindowFocusListener - сообщает о получении или потере компонентами окна фокуса ввода
Полный список методов данных слушателей можно найти в интерактивной документации Java.
В интерфейсе слушателя WindowListener чаще остальных применяют метод windowClosing, вызываемый системой событий при закрытии окна. Рассмотренный выше пример наглядно демонстрирует это.
К фрейму JFrame можно подключить слушателя окна, созданного на основе WindowAdapter (чтобы не реализовывать все определенные в интерфейсе WindowListener методы) и переопределить метод windowClosing, как это представлено в следующих строках кода :
При выходе из программы открывается диалоговое окно в панели JOptionPane и у пользователя спрашивается подтверждение, действительно ли он желает закончить работу с приложением. Если ответ положительный, то программа завершает работу.
Диалоговое окно JDialog
Диалоговые окна чаще всего используются в приложениях для получения дополнительной информации с целью установки параметров приложения, вывода важной вспомогательной/отладочной информации. Диалоговые окна, как правило, создаются модальными (modal), блокирующими доступ к остальным окнам приложения, пока пользователь не закончит работу с модальным диалоговым окном. Модальные диалоговые окна располагаются поверх основного окна приложения. Внешний вид диалоговых окон мало отличается от окон с рамкой JFrame, но обычно у них меньше элементов управления окна (чаще всего, имеется только кнопка закрытия окна) и отсутствует системное меню.
В Swing диалоговые окна реализуются классом JDialog, унаследованном от базового класса окон JWindow и позволяющим создавать как обычные, так и модальные диалоговые окна. JDialog поддерживает как и JFrame закрытие окна, а в остальном сходен с другими окнами Swing.
При создании диалоговых окон Swing необходимо указать «родительское окно», которым может быть окно с рамкой JFrame или другое диалоговое окно JDialog. Имеется также конструктор, не требующий «родительского» окна, но использующий вспомогательное прозрачное окно, о котором было сказано на странице «Окно без рамки JWindow».
JDialog пример создания диалоговых окон
В примере создаем окно с рамкой JFrame, в панели содержимого которого размещается две кнопки JButton. По нажатию на кнопки создаются диалоговые окна в отдельном методе createDialog(). Диалоговое окно с заданным заголовком JDialog может быть модальным и немодальным. Программа позволяет создать несколько немодальных окон одновременно, но только одно модальное. Немодальные окна не блокируют работу с основным окном приложения. При закрытии диалогового окна используется константа DISPOSE_ON_CLOSE, удаляющую окно после закрытия.
Интерфейс работы примера JDialog представлен на следующем скриншоте.
Библиотека Swing предоставляет набор стандартных диалоговых окон JDialog для получения и вывода несложной информации. Прежде чем создавать собственное диалоговое окно, следует рассмотреть возможность использования стандартного.
Оформление окон
Начиная с JDK 1.4 появилась возможность настраивать так называемое визуальное «оформление» окон: рамка, элементы управления окном (кнопки закрытия или свертывания), системное меню. Необходимость этого ощущалась с самых первых выпусков Swing.
Сейчас создание различных интерфейсов окон возможна благодаря усовершенствованиям в UI-представителе корневой панели JRootPane. UI-представитель позволяет создавать специальные рамки, заголовок, системное меню и кнопки управления окном, и размещать их в корневой панели нужным образом, используя специализированный менеджер расположения. Менеджер расположения контролирует пространство корневой панели. Кроме этого, при новом оформлении окон отключаются системные элементы окна.
В классах JFrame и JDialog имеется статический метод setDefaultLookAndFeelDecorated(), обеспечивающий возможность оформления всех создаваемых окон.
Пример оформления окон : JDialog decoration
В примере создается простое окно с рамкой и диалоговое окно. Перед создания окон вызывается метод setDefaultLookAndFeelDecorated(), означающий, что для создаваемых окон JFrame и JDialog потребуется специальное оформление. Далее определяются размеры окон и они выводятся на экран.
Интерфейс примера окон, оформленных с внешним видом Metal, представлен на следующем скриншоте.
Специальное оформление окон может быть полезно как средство, позволяющее полностью, вплоть до окон, управлять внешним видом вашего приложения. Создав собственного UI-представителя корневой панели, можно придать своему приложению уникальный вид, легко узнаваемый пользователями.
Исходные коды примеров, рассмотренных в тексте страницы, можно скачать здесь (3.54 Кб).
Создание диалоговых окон в Java
Как вы наверное уже знаете, для использования предопределенных диалоговых окон применяется класс JOptionPane. Теперь мы опишем, как "вручную" создать собственное диалоговое окно.
Для того чтобы реализовать такое окно, необходимо создать подкласс класса JDialog. По сути, это тот же процесс, которым мы воспользовались для создания главного окна приложения, расширяя класс JFrame.
Точнее говоря, нужно сделать следующее:
- В конструкторе вашего диалогового окна вызовите конструктор суперкласса JDialog. Добавьте в диалоговое окно компоненты пользовательского интерфейса.
- Добавьте обработчики событий.
- Задайте размер диалогового окна.
При вызове конструктора суперкласса нужно указать фрейм-владелец, заголовок окна и признак модальности.
Фрейм-владелец управляет местом отображения диалога. Вы можете указать null вместо владельца - тогда диалог будет принадлежать скрытому фрейму.
Признак модальности указывает на то, должны ли блокироваться другие окна вашего приложения, пока отображается диалог. Немодальные окна не блокируют другие окна.
Модальный диалог блокирует все остальные окна приложения(за исключением дочерних по отношению к этому диалогу). Вы используете немодальные диалоги для создания панелей инструментов, к которым постоянно открыт доступ.
С другой стороны, модальные диалоги вы будете использовать, чтобы вынудить пользователя ввести необходимую информацию, прежде чем продолжить работу приложения.
Начиная с Java SE 6, добавлены два дополнительных типа модальности. Документо-модальный диалог блокирует все окна, относящиеся к одному "документу", или, точнее говоря, все окна с тем же родительским корневым окном, что и у данного диалога.
Это решает проблему систем помощи. В более старых версиях пользователи не могли взаимодействовать с окнами справки, когда всплыли модальный диалог. Toolkit-модальный диалог блокирует все окна их одного и того же "toolkit"(набора инструментов).
Создание всплывающих окон(диалога) на Java
Используйте JOptionPane.showInputDialog(), чтобы пользователь мог ввести текст в диалоговом окне.
Пример
Теперь выберите любой элемент сверху и нажмите OK, чтобы отобразить выбранный элемент в консоли.
Средняя оценка / 5. Количество голосов:
Спасибо, помогите другим - напишите комментарий, добавьте информации к статье.
Как создать графический интерфейс с примерами Swing на Java
Swing в Java является частью базового класса Java, который является независимым от платформы. Он используется для создания оконных приложений и включает в себя такие компоненты, как кнопка, полоса прокрутки, текстовое поле и т. д.
Объединение всех этих компонентов создает графический интерфейс пользователя.
Что такое Swing в Java?
Создавать приложения становится проще, поскольку у нас уже есть компоненты GUI, такие как кнопка, флажок и т. д.
Контейнерный класс
Любой класс, в котором есть другие компоненты, называется контейнерным классом. Для создания приложений с графическим интерфейсом необходим как минимум один класс контейнеров.
Ниже приведены три типа контейнерных классов:
Разница между AWT и Swing
Иерархия
Объяснение: Все компоненты в свинге, такие как JButton, JComboBox, JList, JLabel, унаследованы от класса JComponent, который можно добавить в классы контейнера.
JButton Class
Он используется для создания помеченной кнопки. Использование ActionListener приведет к некоторым действиям при нажатии кнопки. Он наследует класс AbstractButton и не зависит от платформы.
JTextField Class
Он наследует класс JTextComponent и используется для редактирования однострочного текста.
JScrollBar Class
Он используется для добавления полосы прокрутки, как горизонтальной, так и вертикальной.
JPanel Class
Он наследует класс JComponent и предоставляет пространство для приложения, которое может присоединить любой другой компонент.
JMenu Class
Он наследует класс JMenuItem и является компонентом выпадающего меню, которое отображается из строки меню.
Вывод:
Класс JList
Он наследует класс JComponent, объект класса JList представляет список текстовых элементов.
Вывод:
JLabel Class
Используется для размещения текста в контейнере. Он также наследует класс JComponent.
Вывод:
JComboBox Class
Он наследует класс JComponent и используется для отображения всплывающего меню выбора.
Вывод:
Для размещения компонентов внутри контейнера мы используем менеджер макета. Ниже приведены несколько менеджеров макетов:
Макет границы
Макет потока
FlowLayout просто кладет компоненты в ряд один за другим, это менеджер компоновки по умолчанию для каждого JPanel.
GridBag Layout
GridBagLayout размещает компоненты в сетке, что позволяет компонентам охватывать более одной ячейки.
Пример: фрейм чата
Это простой пример создания GUI с использованием Swing в Java.
Средняя оценка / 5. Количество голосов:
Спасибо, помогите другим - напишите комментарий, добавьте информации к статье.
Как сделать всплывающее окно в java
В настоящее время я занимаюсь разработкой приложения Java).
Я хочу показать новое окно, которое содержит текстовую область и кнопку.
У тебя есть идеи?
Тот же ответ: JOptionpane с примером :)
Хм, прошло немного времени, но насколько я помню .
Если вы хотите создать собственное окно, вы можете просто создать новый фрейм и отобразить его так же, как в главном окне. Java также имеет большую библиотеку диалогов, которую вы можете проверить здесь:
Это может дать вам ту функциональность, которую вы ищете, с гораздо меньшими усилиями.
Если вы не хотите ограничивать выбор пользователя, вы можете либо использовать форму метода showInputDialog, которая принимает меньше аргументов, либо указать значение null для массива объектов. В интерфейсе Java) подстановка нулей для возможностей приводит к диалогу, который имеет текстовое поле и выглядит следующим образом:
Способы создания окон PopUp
В данном уроке я не открою тайну для матерых верстальщиков и гуру css, но данная статья будет полезна начинающим. именно здесь вы сможете узнать, как создавать всплывающие окна поверх всего сайта.
Чаще всего такие окна появляются после совершения определенных действий на сайте, например, пользователь нажимает на ссылку «Заказать обратный звонок» и перед ним всплывает форма заказа.
Очень удобно использовать PopUp окна в связке с ajax, но это уже тема другого урока.
Всё больше и больше в сети начинает появляться веб-ресурсов, которые используют всплывающие окна PopUp. В пример можно привести всем знакомые социальные сети. Все лишние данные со скриншотов удалены.
Вконтакте
Думаю достаточно доводов, чтобы начать изучать вопрос: как же сделать на своем сайте всплывающее окно PopUp.
Постановка задачи(ТЗ)
Необходимо создать поверх всего сайта всплывающее окно с затемнением экрана.
Решение
Способ 1
Результат:
Очень часто предлагают использовать:
Да, результат получается аналогичный, но из-за того, что у нас задана высота блока «затемнения», появляются полосы прокрутки. Именно поэтому такой метод не подходит.
Способ 2
Этот способ не отличается кардинально от Способа 1, но я считаю его более удобным.
Html (без изменений)
Результат аналогичный
Благодаря свойству: min-height:100%; наш блок «затемнение» обрел ширину в 100% и минимальную высоту в 100% экрана.
Единственным минусом данного способа является то, что Internet Explorer поддерживает данное свойство только с версии 8.0.
Добавление магии на Jquery
Теперь добавим ссылки для скрытия/отображение нашего всплывающего окна.
Для этого необходимо подключить библиотеку JQuery и небольшой скрипт:
Также необходимо обновить Html:
Результат
Теперь при загрузке страницы всплывающее окно PopUp скроется.
Если мы нажмем на ссылку «Show popup», у нас появится всплывающее окно. А если нажать на ссылку «Hide popup», то всплывающее окно вновь скроется.
Окошко с кнопками на JavaFX:
Привет!
Мои знания в создании какого-либо графического интерфейса до недавних пор были нулевыми. Поэтому было принято решение немного пошерстить просторы Интернета и сотворить какое-нибудь окошко с какими-нибудь кнопками, при нажатии которых будет что-то происходить. Возможно, в этом тексте кто-то найдет ответы на возникшие когда-то вопросы; в то же время я надеюсь на серьезную и грамотную критику.
Что будет происходить?
Так как цель у меня — разобраться с JavaFX, нужно придумать какую-то функцию у нашего окна. Идея такая: создадим набор людей (предположим, что они работают в какой-то компании), для каждого из которых будет известно имя, возраст, зарплата и семейное положение. Наше окно, во-первых, будет выводить информацию о каждом из них, во-вторых, изменять зарплату какого-либо сотрудника, в-третьих, иметь возможность добавлять нового сотрудника, и, наконец, в-четверных, будет способно фильтровать сотрудников в зависимости от значений их атрибутов. В результате должно получиться что-то по типу этого:
Начинаем
Перво-наперво создаем главный класс Company, откуда будет происходить запуск приложения:
В этом классе будем расширять возможности класса Application. Из него нам нужен главным образом метод start(), в котором будет происходить основное действие (будем пропускать ошибки, возникающие в этом методе; другими словами, если что-то пойдет не так, наше окно не закроется, но в консоли появится StackTrace ошибки):
Отлично. Для того, чтобы работать с представителями сотрудников компании, создадим класс User: объекты этого класса и будут выступать в роли сотрудников.
Создаем
Пока при запуске приложение у нас не происходит ничего. Чтобы появилось хотя бы окошечко, его необходимо добавить. Это и сделаем.
Что мы только что сделали: мы добавили сцену (scene) размером , дали ей название «Company». На нашей сцене присутствует группа root, которая по своей сути является «контейнером», который будет содержать в себе все кнопки.
Добавим выпадающий список с нашими сотрудниками. Создадим HBox, в который положим наш выпадающий список ComboBox userBox и кнопку, которая будет выдавать информацию о сотруднике (сам HBox поместим в VBox):
HBox — это набор кнопок, текстов, полей для ввода, каждый объект которого расположен последовательно горизонтально. Аналогичный ему, VBox является тем же самым, но хранит свои объекты (children) по вертикали. Мы будем использовать следующую схему: создатим VBox, в который будем класть несколько HBox'ов, в каждый из которых положим последовательность кнопок и полей.
ComboBox — это сам просто выпадающий список.
Теперь мы хотим создать кнопку, которая будет выдавать информацию о выбранном сотруднике. Добавим саму кнопку (Button) и текстовое поле (TextField), в которое будет выводиться текст. Эти два объекта добавим в HBox:
Но пока эта кнопка ничего не делает. Чтобы она что-то делала, необходимо ей присвоить действие:
Дальнейшие действия
Абсолютно аналогичным образом добавляем еще два HBox'а: во втором будет происходить изменение зарплаты, в третьем — добавляние нового сотрудника. В силу того, что логика здесь абсолютно та же самая, пропустим объяснения этих моментов и сразу покажем результат:
Фильтры
Теперь добавим «фильтрацию» сотрудников по признакам. Опять же, списки для фильтров будем добавлять с использованием ComboBox по той же самой логике.
Класс Company (главный)
Класс User
Что это было
Сама по себе программа не представляет никакой полезности и была написана исключительно для того, чтобы познакомиться с JavaFX и ее инструментами. В некотрых местах, например, при изменении зарплаты, не учитываются варианты, когда не выбран пользователь, или когда введена строка: в эти случаях будет появляться ошибка. То же самое касается полей, куда вводится информация при добавлении новых сотрудников. И, наконец, ошибка будет возникать, если не выбрано какое-то значение в любом из выпадающих списков. При желании, каждый может добавить свой «обход» этих моментов.
При написании фильтров, кстати, я использовал небезызвестные StreamAPI и -выражения, которые сокращают код, добавляют в него легкость понимания и свой шарм.
Читайте также: