оконное приложение java intellij idea
Процесс разработки простой GUI программы на языке Java
Основы программирования GUI на языке Java. Урок 1.
В этой короткой статье хочу описать процесс создания небольшой программы, поддерживающей GUI на языке Java. Предполагается, что читатель знаком с основами языка Java.
И так, какие инструменты нам необходимы:
Я назвал проект guiBase. Как видно на скрине, папка src не содержит ничего, поэтому создаем в ней наш главный класс, содержащий функцию main.
Открываем созданную GUI форму, нажимаем на JPanel и задаем его идентификатор в поле field name, я задал panel.
После чего перетаскиваем на форму с правой стороны JTextField, JPasswordField и JButton:
Осталось добавить код и связать нашу форму с ним. Когда мы добавляли форму MainWindow, автоматически создался и класс MainWindow, этот класс является классом созданной формы, т.е. именно этот класс будет обслуживать все события данной формы.
Содержание этого класса будет автоматически редактироваться во время изменения формы, например если добавить новую кнопку JButton, мы увидим его идендификатор в приватных атрибутах (свойстах) класса MainWindow.
Хотя класс нашего окна содержит необходимые элементы, но даже сейчас он не имеет ничего общего с GUI, поэтому расширим его с помощью JFrame и унаследуем всю основную и необходимую функциональность GUI.
В данный момент мы имеем форму MainWindow и класс MainWindow расширенный с помощью JFrame. Сейчас нам необходимо определить все добавленные GUI элементы как содержание класса MainWindow this.getContentPane().add(panel); После чего содержание файла MainWindow.java будет изменено следующим образом:
Если попробуете запустить код, вы снова увидите то же самое сообщение “Hello, Govzalla!“. Дело в том, что мы создали класс и форму к нему, но не создали инстанцию этого класса.
Пришло время изменить файл Main.java и добавить туда код создания нашего GUI:
Нажав на кнопку Button вы заметите, что программа никак не реагирует. Дело в том, что мы еще не добавили слушатель (Listener) для событий (Events) кнопки Button.
Слушатель событий (Event listener) JButton должен быть имплентацией адаптера ActionListener, поэтому добавим следующий код в тело класса MainWindow:
Метод actionPerformed() будет обрабатывать все события кнопки button1, но для начала еще необходимо указать кнопке button1 какой класс будет обрабатывать, поэтому добавим следующий код в конструктор класса MainWIndow: this.button1.addActionListener(new MyButtonListener()); Чтобы наш обработчик не был бессмысленным добавим следующий код в метод actionPerformed():
Сейчас уже программа будет правильно реагировать на события, не на все события, конечно. Например, если попытаться отключить программу нажав на крестик, окно исчезнет, но программа все еще будет работать, т.к. не добавлен обработчик событий главного окна.
Как начать пользоваться Swing GUI-визардом IntelliJ IDEA. Подробная инструкция
Давно не писал настольных приложений на Java вообще и с использовании Swing в частности. Однако, возникла необходимость немного по GUIть. В качестве инструмента выбрал IntelliJ IDEA Community edition, 2016.1 версии.
Взялся ваять и, естественно, первое, на что налетел — хотя со времён Borland Java Builder 2006 воды утекло немало, экранные интерфейсы создавать проще не стало, скорее наоборот. А одной из причин выбора IDEA было как раз наличие Swing дизайнера «из коробки», однако как им пользоваться с ходу решительно непонятно — форма генерится, класс создаётся, создаются переменные контролов из дизайнера… но и только: при создании нашего класса форма на экране не появляется
Пошарил интернет, информации приблизительно ноль. Народ говорит, мол, «создавай и — вперёд!». Хм…
По результатам небольших мытарств на эту тему решил опубликовать инструкцию, так как мне с учётом былого опыта было искать намного легче, чем новичку, который вообще в первый раз ваяет форму на Swing.
Создание Swing GUI форм средствами JetBrains IntelliJ IDEA 2016.1
В итоге нам действительно сгенерили класс-наследник JDialog (который можно создать и использовать) и форма к нему.
Запускаем наш проект на выполнение и… о ужасчудо! при компиляции IDEA добавляет в конец нашего файла некоторый дополнительный код.
Теперь, когда мы поняли, как оно работает, перейдём к созданию прочих форм — необязательно диалогов.
Генерится класс и форма к нему. Накидываем на форму несколько контролов. В GUI дизайнере смотрим имя корневого элемента (обычно panel1, если IDEA не задала имя, а такое бывает, задайте принудительно — я для наглядности назвал rootPanel).
Переходим к исходному коду нашего класса.
Итак:
1. Добавляем для нашего класса наследование «extends JFrame»;
2. Добавляем конструктор класса со строками:
Всё. Форма готова к употреблению. Остальное смотрите в многочисленных инструкциях по Swing.
P.S. Как вариант, можно не наследовать наш класс от JFrame, а создать конструктор вида:
Такой вариант тоже работает — возможно, кому-то пригодится.
Визуальное программирование на Java
Почти все книги и уроки по Java для новичков начинаются с описания ООП: какой он замечательный с великолепный. Понятно, поскольку в Яве просто невозможно любое другое программирование, кроме как объектно-ориентированное, то вначале предлагается освоить 40..80 страниц безумных аналогий с иерахией кошечек/собачек/уточек/автомашин, и только после этого предлагается написать «Hello, World!». 🙂
При этом стоит заметить, что абсолютно всё обучение Java строится на примитивнейшем выводе результата на консоль. То есть не консольное приложение в привычном понимание, а именно вывод каких-то данных построчно. Ну вот например Turbo Pascal 3.0 вышел в 1985 году и в нём уже была поддержка графических режимов. В 1990 году появился Turbo Vision — очень крутая вещь — аля-Windows только для DOS. А в Яве в 2018 году возможен только вывод на консоль. И вот вся эта восторженность и крутость как-то вдребезги разбивается уже на этапе «Hello, World!». Хуже наверное это только развлекаться на программируемом калькуляторе МК-61 или МК-52 — а что? там такой же построчный вывод.
Но, самое забавное — это то, что на Java реально можно создавать программы используя визуальное программирование! Я об этом узнал только когда прочитал (или скорее ознакомился) с 500 страничной книгой, где в одной из последних глав, вдруг выяснилось, что для Java существуют нормальные GUI (графические интерфейсы пользователя) и можно оформлять программы с кнопочками, полями ввода и нормальными меню. Спрашивается: зачем вы столько времени «мурыжили» эту паршивую консоль, когда можно было сразу всё делать красиво и аккуратно?
(Дальше много картинок!)
Потратив несколько дней на изучение данного вопроса, я выяснил несколько забавных нюансов.
Первый — GUI для Java есть трёх видов (библиотек): AWT, Swing (кто придумывает такие названия?) и JavaFX.
На сегодняшний день (Java 8 и 9) все они входят в комплект поставки JDK: то есть всё работает из коробки и не нужно заморачиватся с их установкой. Это большой плюс.
Но, AWT — это первая и очень старая реализация, поэтому её использовать не нужно. В общем — некошерно. Swing — тоже некошерно, поскольку там что-то не так замутили и программы из-за него жутко тормозят. Точнее не скажу, не разбирался, но вроде как она официально больше не развивается несколько версий. А вот JavaFX — это гуд и наше светлое будущее.
Есть ещё такая мерзость — java-апплеты, те которые работают в браузере и при этом его намертво «вешают», примерно как Flash, только ещё хуже. К счастью эту/эти штуку/штуки практически уже не используют, поэтому тратить время на их изучение бессмысленно.
Так что единственное на что стоит потратить время — это JavaFX.
Второй момент. Всё не так просто. Рассмотрим Delphi (или Visual Studio, Lazarus, не важно). Даже для «зеленого» новичка создание простой программы (одна кнопка и текстовое поле для вывода) будет происходить так:
То есть мы не написали ни единой строчки кода, IDE — всё сделала сама. Если посмотреть на сгенерированный код, то назвать его простым нельзя — здесь уже требуются определенные знания, но Delphi достаточно умна, чтобы понимать как с ним работать.
Если мы захотим добавить какое-то действие, например при нажатии на кнопку, заполнять текстовое поле фразой «Привет!», то делаем так:
То есть опять же, IDE выполнила всю черновую работу.
Но это в других языках, Java идёт своим путём. Чтобы создать кнопку в JavaFX нужно вручную создать Stage — «театральные подмостки» (название на полном серьёзе!) и на них разместить сцену (Scene). К ней какой-нибудь контейнер в который уже вкладывается прочие элементы.
При этом предполагается, что каждый элемент и каждое его свойство нужно программировать индивидуально. Вот пример на две кнопки и одну label из моей обучающей книги
Когда кнопок наберется с десяток, плюс 20 пунктов меню, плюс 30 других компонентов, то код маленьким не покажется. И это ещё без кода, который отвечает за дополнительные свойства, например выравнивание, размеры, шрифт. И вот это второе указывает на то, что обучалки по JavaFX как раз и показывают как писать «fx-код» ручками. Тоска, одним словом.
Но, тут возникает спасительный третий нюанс. Оказывается умные люди (видимо знакомые с полноценными IDE), разработали другой вид приложений, где для генерации «fx-кода» используется описательный xml-файл, который называется fxml, а такие программы менуются как «Приложения FXML JavaFX»
Для меня совершенно удивительно то, что обучение Java не начинается именно с таких приложений. Пусть это не Delphi, но всё-равно это в миллион миллионов раз лучше, чем работать с консолью и забивать себе голову прочим хламом о том, почему нужно использовать стопицот строк с ООП там, где в других языках на это уходит одна простенькая процедура. 😉
Теперь серьёзно. Если вы никогда не программировали на Java, то можете попробовать сделать это прямо сейчас. На самом деле — это довольно круто, хотя потребуется немного потратить время, чтобы освоится с программами. Если у вас есть опыт работы с «визуальными IDE», то ещё лучше — встретите много знакомого.
Ява должна быть установлена на компе. Я не буду приводить ссылки как это сделать — гугл в помощь, поскольку всё слишком просто.
В Яве нет какой-то одной программы — среды разработки, поэтому в Сети встречаются примеры из разных программ. Самые примитивные, вроде Notepad++ годятся только для консольного вывода, но если рассматривать что-то более серьёзное, то выделяются только три кандидата: NetBeans, Eclipse и IntelliJ IDEA.
NetBeans — самая простая программа, которая быстро (относительно остальных) запускается и довольно сносно работает.
Eclipse — тоже неплохой вариант, более мощный чем NetBeans, но слабее чем IntelliJ IDEA.
IntelliJ IDEA — выглядит самой крутой, но за это приходится платить скоростью работы. Стоит отметить, что Android Studio базируется на IntelliJ IDEA, но студия работает почему-то значительно медленней.
Важный момент связан с программированием под Андроид. Из этих трех IDE только IntelliJ IDEA для этого более-менее годится. В Сети масса материалов о программировании под Андроид в Eclipse, но они все уже устаревшие — не тратье время, запуская старенький ADT-плагин и пытаясь хоть что-то с ним сделать. Может быть старый Android SDK и будет работать, но все новые — уже нет.
Я покажу как сделать приложение FXML JavaFX во всех трёх программах, но прежде чем приступать, нужно установить ещё одну программу: SceneBuilder (используйте версию для Java 8). Это ключевая программа, где, собственно и выполняется всё визуальное построение. SceneBuilder самостоятельно может работать без IDE, поэтому можете её запустить и посмотреть как она устроена. На выходе будет fxml-файл, который содержит всю нужную разметку. Этот файл и используется в IDE, вместо написания мегатонны кода. 🙂
Создаваемая программа будет очень простой — кнопка и текстовое поле. При нажатии на кнопку в текстовое поле пусть добавляется текст «Привет!».
В каждой программе вам нужно заранее прописать настройку — используемую JDK. Если не можете понять как это сделать, гуглите.
NetBeans
Создаём новый проект, где нужно выбрать «Приложение FXML JavaFX».
Жмём «Далее» и видим окно настройки проекта. Нужно указать название проекта, у меня это myfx.
Жмём «Готово» и, после некоторой работы NetBeans, видим готовые файлы:
Теперь запустите программу. Вначале пойдет сборка и компиляция (довольно быстрая), после чего выскочит окно нашей программы.
Это круто, потому что мы не написали ни строчки кода, но уже получили программу с работающей кнопкой. 🙂
Если вы правильно указали путь к SceneBuilder, то можете выбрать пункт меню «Открыть» на файле FXMLDocument.fxml. Это же самое произойдёт если сделать двойной клик. Откроется SceneBuilder. Если пункта нет, то путь указан не верно, проверьте настройку.
Принцип работы в SceneBuilder един для всех IDE, поэтому пока я опишу только общие моменты, дальше вы уже сами сообразите.
Стоит отметить, что после редактирования файла, закрывать SceneBuilder не нужно. Достаточно только сохраниться (Ctrl+S) и переключиться на IDE — она сама подхватит изменения.
Окно SceneBuilder разделено на три части:
Построение FX-программ должно начинаться с контейнера. В данном примере NetBeans использовал AnchorPane. Он довольно удобный, позволяя настраивать для вложенных элементов «правильные» отступы. Вкладка Containers содержит другие контейнеры, с которыми вы сможете самостятельно потренироваться (я и сам ещё и половины не освоил 🙂 ).
Иерархия компонентов очень удобная штука, позволяющая быстро выбрать нужный элемент.
По условиям ТЗ у нас должно быть текстовое поле. NetBeans использует Label, но мы не будем ничего удалять, а просто добавим новый элемент TextField на форму (произвольно на ваш вкус).
В SceneBuilder возможен предварительный просмотр (Ctrl+P). В этом режиме отображается только форма и все элементы «без java-программирования».
Теперь важный момент: для того чтобы можно было использовать компонент в java-программе (в нашем коде), следует выполнить две вещи.
Как видно — это контролёр из файла FXMLDocumentController.java (пакет.контролёр). Не всегда IDE его указывают, но это важно, поскольку fxml-файл (точнее java-код) использует его для привязки.
Вверху появится желтый треугольник сообщения, что якобы нет связки этого id с контролёром. Пока не обращайте на него внимания, об этом пойдет речь дальше.
У кнопки, которая будет заполнять текстовое поле, тоже должен быть свой id, а также метод события onAction (это основное событие компонента, а не onClick, как в Delphi). NetBeans уже об этом позаботился, поэтому нам ничего не придется писать.
На этом визуальное построение можно завершить. Сохраняемся и переключаемся в NetBeans. Видим, что файл FXMLDocument.fxml изменился: добавился textField1:
Теперь нам нужно как-то использовать текстовое поле в java-коде. В отличие от Delphi, NetBeans не создаёт для этого никакого кода, потому нам придётся добавлять его в «полу-ручном» режиме. Для этого в разных IDE используются различные способы, но общий принцип в том, что нужно установить курсор на нужное поле в редакторе и выполнить некое «действие». В NetBeans оно называется Установить контролер в меню Источник. (Да в Яве большие проблемы с именованиями. )
После выполнения этой команды, произойдет переход к файлу FXMLDocumentController.java, где в код будет добавлено объявление переменной textField1:
Обратите внимание на «@FXML» — эта аннотация указывает, что код как-то используется в FXML. После этих изменений SceneBuilder уже не будет выдавать предупреждение, как желтый треугольник ранее. Если ещё раз запустить SceneBuilder, то это можно проверить.
Запускаем программу на выполнение для теста. Теперь наша задача по клику на кнопке заполнить текстовое поле. Как вы уже поняли метод handleButtonAction как раз и выполняет нужную работу. В нём дописываем:
Обратите внимание как работает автодополнение кода после того, как будет нажата точка.
По мере набора текста, NetBeans будет сужать область предложений, где можно выбрать нужный вариант. Эта возможность очень здорово облегчает жизнь программистам, поскольку вариантов слишком много и это позволяет избежать различного рода синтаксических ошибок при наборе.
Данная возможность присутствует по всех IDE, хотя есть различия в реализации и использовании.
Запускаем программу и видим, что всё работает как нужно.
Нам пришлось написать всего одну строчку кода, ну и выполнить несколько дополнительных действий в редакторе.
Eclipse
Обратите также внимание на то, что Eclipse неруссифицированная программа (даже не знаю, есть ли к ней руссификатор).
Создаём новый проект и выбираем JavaFX.
Жмем Next и попадаем на страницу настроек. Здесь я указал название проекта, как и прежде myfx (у меня для разных IDE разные каталоги проектов, поэтому они не пересекаются друг с другом).
Дальше ещё несколько раз жмем на Next, пока не попадем на последние настройки.
Здесь нужно выбрать тип приложения, тип контейнера и имя контролера. Жмем Finish и Eclipse быстро генерирует каркас нашей будущей программы.
Здесь всё очень похоже, только добавлен еще один файл application.css — да, да, в JavaFX можно использовать CSS для настройки оформления! Eclipse сразу сгенерировал для этого файла код подключения.
Запустим программу и убедимся, что нет ошибок.
В отличие от NetBeans, здесь совершенно пустая форма. Откроем её в SceneBuilder с помощью контекстного меню.
И здесь мы видим, что формы нет. Но, на самом деле она есть — просто по умолчанию используется вычисляемый размер (высота и ширина), который в данном случае равен нулю. Компонентов-то нет! В нашем случае это не совсем то, что нужно, поэтому мы выберем BorderPane в иерархическом списке и в свойствах Pref Width и Pref Height укажем какие-то значения. Эти свойства задают «желаемые» ширину и высоту. После этого форма сразу же «проявляется».
Контейнер BorderPane состоит из 4-х частей: top, right, bottom, left и center. Компоненты следует помещать в разные части — от этого будет зависеть их положение при изменении размера окна.
Здесь довольно сложно объяснить словами, просто попробуйте разместить несколько кнопок, а после в предварительном просмотре измените размеры окна.
Я не стал особо мудрить и разместил вверху текстовое поле, а в центре кнопку.
Теперь проверим, что указан контролёр: в данном случае application.SampleController — Eclipse выполнил эту работу за нас.
Теперь нужно указать id у наших элементов. Для кнопки я задал btn1, а текстовому полю textField1. У нас опять же возникло сообщение «желтый треугольник».
Для кнопки укажем метод на событие — btn1Click.
Сохранимся и вернёмся в Eclipse. Мы увидим, что файл Sample.fxml обновился, но рядом с некоторыми строками появились значки предупреждения.
Ситуация здесь точно такая же как и в NetBeans — нужно в «полу-ручном» режиме вносить правки. В Eclipse для этого используется контекстное меню по второй кнопке мыши: Quick Fix или горячая клавиша Ctrl+1 (что удобней).
При этом выскакивает подсказка о предполагаемом действии. Например для textField1 предлагается добавить идентификатор в контролёр:
а для кнопки ещё и метод-обработчик события:
При этом, Eclipse немного притормаживает и изменения не сразу отображаются на экране. Тут нужно либо переключиться на файл контролёра, либо немного подождать. В результате в код будет добавлены нужные изменения и значки предупреждений исчезнут.
Добавим наш код как и раньше мы сделали в NetBeans.
Обратите внимание на более интелектуальную работу автодополнения. В автоматическом режиме он немного подтормаживает, но если нажать Ctrl+Пробел (эта же комбинация используется во многих IDE), то позволяет получить и неплохой хелп.
Запускаем нашу программу.
И записываем себе на счёт ещё одну IDE. 🙂
IntelliJ IDEA
IntelliJ IDEA запускается довольно неспешно, можно успеть проверить почту. 🙂
Дальше создаем новый проект:
И указываем его имя (как обычно — myfx):
IntelliJ IDEA выполнит инициализацию и мы увидим уже знакомые три файла. Запустим программу, чтобы проверить отсутствие ошибок.
Здесь также пустая форма, но зато указан заголовок программы. Если посмотреть на код Main.java, то увидим строчку:
Это и есть заголовок приложения. В других IDE эта строчка отсутствует, но зато теперь мы знаем для чего нужны «театральные подмостки». 😉
Переключаемся в SceneBuilder (аналогично Eclipse): второй кнопкой мыши нужно выбрать Open in SceneBuilder.
Здесь также пустая форма, но с контейнером GridPane. Устанавливаем Pref Width и Pref Height, чтобы отобразилась форма.
Сам по себе GridPane представляет собой аля-сетку из ячеек для элементов. Думаю, что тут нет смысла повторяться — все действия будут аналогичными:
Закрываем SceneBuilder и возвращаемся в IntelliJ IDEA. Здесь нужно добавить идентификаторы id в код, а также создать метод для реакции на нажатие кнопки.
IntelliJ IDEA предлагает для этого два способа. Первый — при наведении мышки на «проблемное место» будет появляться подсказка, на которую можно кликнуть:
Второй — горячая клавиша Alt+Enter
При каждом добавлении происходит переключение на файл контролёра, где можно сразу увидеть изменения.
При этом, заметьте, не добавляется строчка «@FXML». Если мы вручную его добавим перед переменными и методом, то IntelliJ IDEA сразу предложит добавить нужный java-класс:
Вообще IntelliJ IDEA показывает достаточно хорошую сообразительность и выступает помощником в написании кода. Причём делает это самостоятельно без лишних нажатий кнопок.
Ну что ж, добавляем свой код для обработчика и запускаем программу:
Прекрасно, всё работает!
Итого
Главный вывод — на Яве возможно визуальное программирование. Может оно и не идеальное, но вполне годное, особенно для новичков. Изучать язык гораздо интереснее, когда есть какой-то осязаемый результат — ООП, классы и прочие премудрости — это хорошо, но лучше начать с кнопочек, полей ввода, меню и всего того, что подразумевает нормальная программа. А консоль — это скучно и неинтересно.
Три IDE я привел не случайно. В Сети очень много примеров для Явы и все они для разных программ. Лично я ещё не определился со своим предпочтением, поскольку у всех есть как плюсы, так и минусы. Наверное нужно поработать со всеми, тогда и будет понятно.
Но, ключевой момент — это умение работать с SceneBuilder. Построение формы в JavaFX немного отличается от той же Delphi, в первую очередь в использовании сложных контейнеров (они могут быть вложенными друг в друга). Поэтому вначале следует разобраться с ними, после уже можно браться за сами компоненты.
Рассмотренные программы очень простые, для изучения наверное стоит написать что-то более интересное, например калькулятор. То есть те проекты, которые не требуют особых знаний и рассчитанные на быстрый результат. Впрочем, это уже на любителя. 🙂