Gui — из java(кода) в GUI


Содержание

Java GUI

На чём сейчас принято делать gui в java? Смотрел в сторону swing и fx, если я правильно понял, то на fx давно забили?

Кто это забил? JavaFX — рекомендуемая либа. Swing — deprecated.

На языках подходящих для этого.

Не на java — человеческого гуя в ней нэма.

Поправил, мне именно в java.

CSS/javascript через webkit/chromium биндинги для джава есть готовые

либо OpenGL(сотни UI либ и биндингов)

для кофеврок и холодильников свинг

оно рендериться через DX(на винде), и OpenGL на линуксе

количество невероятных багов, при запуске пары DX/OpenGL приложений паралельно, в JavaFX просто зашкаливает(пропадают куски интерфейса, ломаются таймеры анимации, ад и ужас)

если нет DX/OpenGL(или софтвеерный рендер прописан руками) то все эмулируется чере Swing. и какже оно тормозит, чистый Swing просто летает по сравнению с этим

поэтому никто это не использует

очевидного сравнения с CSS/javasript UI и JavaFX, последняя не переживает

Это ту, которую выкинут из жабы11? Ту, которую 4 года не обновляли, рекомендуют? Кто рекомендует?

На react-native, electron + rest api.

Нет, не надо тебе писать гуй на жаве. Тебе может казаться, что тебе надо писать гуй на жаве, ты можешь себя даже в этом убедить, но на самом деле это не так. Писать гуй тебе надо на чем-нибудь другом.

Гуй на Java принято делать на HTML5/CSS/JavaScript и пользоваться им в браузере.

Ты ничего не понял, никто не выкидывает FX. Начиная с JDK11, FX будет поставляться отдельным модулем, а не в составе JDK. Это касается только Oracle JDK, емнип, в OpenJDK оно и было отдельно.

Ясно. Тогда всё не так плохо.

JavaFX будет поставлятся и развиваться как отдельный модуль, не привязанный к релизам JDK.

Иди проспись. Обновляют регулярно

Англоязычная википедия, тот еще источник, пишет что стабильная 4 года назад. Если продолжают пилить — ну хорошо, чо, я не жабоед.

Ну и зря. Жабка нынче вкусная, особенно с Kotlin. Гыыы

Оно будет тормозить сильнее любой жабы

Пруфы? Jetbrains IDEA тормозит сильнее VSCode (electron).

На чём сейчас принято делать gui в java? Смотрел в сторону swing и fx, если я правильно понял, то на fx давно забили?

На C#. https://en.wikipedia.org/wiki/COMSOL_Multiphysics — ядро на жабе, гуйня под венду на c#. Под линухом — свинг или через браузер.

Хотя может и не свинг, я видел только мельком окно с лицензией.

либо OpenGL(сотни UI либ и биндингов)

а какая либа поддерживает создание меню с текстом?
freeglut уже давно заброшено, а sdl слишком жирная

текст рендерят так, в 2020:
1.рендерится шрифт в текстуру(картинку), или берем готовую картинку символов
2.пишется шейдер строк на 20 с показом нужного индекса(буквы) из сектуры
3.все готово, это все минут за 10-20 делается с нуля

а какая либа поддерживает создание меню с текстом?

любая imgui очевидный пример

Swing вроде не упраздняли..

2.пишется шейдер строк на 20 с показом нужного индекса(буквы) из сектуры

лол, нет, man кернинг

Гуй на Java принято делать на HTML5/CSS/JavaScript и пользоваться им в браузере.

Давно ли Eclipse и NetBeans IDE используют для отрисовки себя браузер?

Я даже больше скажу: на JavaFX забили с самого начала её появления.

На чём сейчас принято делать gui в java?

Традиционно на десктопе: Swing и SWT.

Давно ли Eclipse и NetBeans IDE используют для отрисовки себя браузер?
Eclipse

Swing старый как мамонты, но поддерживается. FX модный, молодёжный, но его саппорт дропнули. В общем GUI лучше делать не на джаве. А если сильно хочется, то я бы выбрал Swing.

FX модный, молодёжный, но его саппорт дропнули

Исчо один. Никто него не дропал. Сегодня выпустили очередной билд. GUI лучше и НУЖНО делать на Жабе. На чем еще его делать? На ублюдочном цепепе?

Там даже «стрелка осциллографа»(С)(ТМ) имеет место быть —

Ай, да трол-ло-ло какой!

И? Что сказать то хотел? Читай лучше тред, что тебе пишут умные дяди.

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


Мнение кульхацкеров с ЛОРа (админов локалхостов) авторитетнее мнения IBM/OTI и даже JetBrains.

Мнение кульхацкеров с ЛОРа (админов локалхостов)

Давно локалхосты админишь?

6. Is JavaFX replacing Swing as the new client UI library for Java SE? Yes. However, Swing will remain part of the Java SE specification for the foreseeable future, and therefore included in the JRE. While we recommend developers to leverage JavaFX APIs as much as possible when building new applications, it is possible to extend a Swing application with JavaFX, allowing for a smoother transition.

Источник сам сможешь найти, мамкин кульхацкер и гроза локалхостов?

Ждем Apache NetBeans и IDEA на JavaFX — специально для «хелловордиста» философема-куна.

Какой год этого документа?

Вылезайте из криокамеры.

Читай доки. Из стандартной поставки выкинут, а без этого он точно никому не нужен будет. Какой-нибудь SWT тоже наверняка кто-то пилит, только толку от этого. GUI надо писать на родной для платформы среде. В Linux это GNOME/KDE. В Windows .NET UWP, в macOS Cocoa. Если хочется кроссплатформу, самый адекватный вариант сейчас это Electron и Qt.

Але, гараж! JDK перешла на модульную архитектуру и каждый модуль может пилиться и поставляться отдельно. Как это будет с JavaFX/ И от этого он не становиться нестандартным. А свинг не выкинули, ибо под него завязано куча старых приложений, не умеющих в Jigsaw. Но лет через 15 — его дропнут окончательно.

Java, построитель GUI или ручное кодирование?

27 Billbo bug [2009-01-22 10:34:00]

У моего программного обеспечения компании много форм, до сих пор мы написали код вручную (путь MVC).

Мы планируем начать использовать построитель GUI.

Существует несколько проблем с использованием Builder.

  • Части кода не являются читаемый.
  • Части кода не являются редактируемые.
  • Редактировать код будет сложнее позже.
  • Нам придется продолжать использовать строитель в будущем, даже если мы хотим заменить конструктор или написать вручную, и никто не может заверить, что инструмент будет доступен и поддержан в будущем.

Я хочу учиться у других:

  • Вы рекомендуете использовать инструмент или продолжать писать код вручную?
  • Какой строитель лучше?
  • Как он справляется с проблемами? (Есть ли другие проблемы?)

java user-interface forms

16 ответов

Для нескольких форм я рекомендую использовать Builder. Это ускорится. Однако, если у вас есть много форм, которые вам нужно поддерживать в течение некоторого времени, я рекомендую против строителя. В этом случае время, затрачиваемое на чтение кода и обслуживания, намного больше, чем время первоначального проектирования. Таким образом, хотя строитель экономит время на начальной стадии, это затрудняет чтение и обслуживание кода. Более того, это делает повторное использование кода, даже в виде копирования и вставки из одной формы в другую, сложнее.

Я не знаю, ссылаетесь ли вы на веб-приложения или настольные приложения, но в целом я не нашел Java Gui builder, который производит элегантный вывод. Netbeans Swing сгенерированный код, например, беспорядок. Возможно, если бы был хороший строитель, я бы передумал. У меня не возникло проблем с использованием конструктора форм Visual Studio — он создает хороший код, который вы можете читать и понимать.

Для настольных приложений смотрите MiGLayout. Это менеджер компоновки, а не строитель, для Swing и SWT, которые облегчат вашу жизнь.

10 OscarRyz [2009-01-22 10:50:00]

Используя хороший строитель, разработка будет намного быстрее.

Тревога, которую вы не можете изменить код, может быть вызвана тем, что у вас много логики в представлении, где оно не принадлежит. Фактически это изменение может помочь вам переместить логику из представления, которое хорошо подходит для возможности изменять визуальные элементы без нарушения кода.

В соответствии с «нечитаемым» вы должны рассмотреть возможность использования лучшего генератора графического интерфейса. Я слышал только положительные вещи о NetBeans, и я использовал конструктор GUI IntelliJ, код которого довольно чистый.

В обоих случаях исходный код доступен для чтения и редактирования, но только для небольших настроек. Для основных, хорошо используйте GUI-конструктор.

Я думаю, что для небольшого числа форм нет проблем при работе вручную, но поскольку у вас есть «многие из них», как вы только что сказали, использование этих инструментов будет наиболее полезным.

7 Srikanth [2009-01-22 10:58:00]

Мне никогда не нравился код, созданный создателем GUI. По крайней мере, в мире VB это не так, что все (ну, почти) будут использовать одну и ту же среду IDE для создания приложений. В Java люди используют несколько IDE, а некоторые используют VIM и Notepad. И все IDE не генерируют такой же код. И еще одна проблема заключается в том, что они обычно не понимают код, созданный другими IDE. Поэтому, чтобы ответить на ваш 1-й вопрос, я не рекомендую.

Следующий вопрос: какой строитель лучше? В прошлый раз, когда я использовал, Netbeans был лучше, чем большинство из них, которые я пробовал.

Если вы должны использовать построитель графического интерфейса, потому что вам нужно быстрее разрабатывать приложения, убедитесь, что все члены вашей команды используют один и тот же построитель. Лучше получить их мнение об этом, иначе их глаза будут повреждены исходным кодом, созданным IDE.

Дайте нам знать ваше решение!

Я использую NetBeans Java Swing GUI Builder (Matisse) для всех моих проектов за последние 3 1/2 года. Я читал так много жалоб людей на GUI Builders, и самые опытные программисты приветствуют всех, кто даже намекает на использование одного, но вот мой опыт:

  • Не редактируемый код никогда не требуется для редактирования. Действительно, GUI Builder предоставляет скелет для вашего графического интерфейса. Вы перетаскиваете, уменьшаете, изменяете размер и ограничиваете свои компоненты с помощью редактора, но контент таблицы, список для поля со списком и т.д. Все нужно обрабатывать на бэкэнд. Создатель GUI позволяет вам сосредоточиться на этом, пока он заботится о том, чтобы все выглядело красиво и оставалось на месте.
  • WYSIWYG всегда более продуктивен. Текстовые процессоры являются свидетельством этого. Люди скажут вам: «вы не редактируете код GUI, поэтому, если это экономит ваше время, это не так много времени». Но это утверждение чрезвычайно относительное. Когда вы работаете в программной среде с моделью процесса, которая требует постоянных обновлений из-за изменений бизнес-модели, это утверждение ложно. Кроме того, вы тратите большую часть своего времени на контент своего английского эссе, не так ли? Таким образом, этот аргумент сказал бы, что WYSIWYG Word-процессоры не экономят вас столько времени, и такое утверждение будет падать на глухие уши, потому что никто не захочет скомпоновать их внешний вид эссе.
  • Ничего не может сделать GUI Builder, который может сделать этот рукописный код, в то время как я потратил часы, пытаясь решить небольшие проблемы с рукописным графическим интерфейсом, который занял у меня 1 минуту в построителе графического интерфейса.

Создатель GUI Netbeans, в частности, стал намного лучше с течением времени, что большая часть полученного им flak (похожего на большую часть flak Java получила) была действительно аннулирована. Это отличная программа, и это отличный способ быстро и эффективно создавать многофункциональные, красивые интерфейсы. Я очень рекомендую хороший GUI Builder, особенно Netbeans.

Там я это сказал.

Нет, я не работаю для них.

4 broschb [2009-10-19 17:02:00]

Я бы держался подальше от строителей ги. По моему опыту (matisse) вы в конечном итоге тратите столько времени на то, чтобы писать gui с создателем вручную, если не больше. Из-за попытки прочитать сгенерированный код и очистить его при внесении изменений. Кроме того, если вы пишете gui вручную, вам нужно будет понять код, чтобы написать gui, и это поможет сверхурочно стать более опытным, и вы быстрее начнете писать gui, и вы будете быстрее и вручную их записывать, Со временем вы также можете разработать компонентную библиотеку для функциональности gui, которую вы можете писать несколько раз. Я бы держался подальше от строителей. Хороший разработчик в любой момент будет бить среднего разработчика с помощью строителя.

Если у вас слишком сложные формы для сборки, вы можете взглянуть на DesignGridLayout, это Swing LayoutManager с что позволяет легко писать код для вашей формы и легко читать этот код (и поддерживать, я имею в виду, изменять, если необходимо) и визуализировать форму через код.

С DesignGridLayout одна строка компонентов в вашей форме — это одна строка кода. Нет XML, полная безопасность во время компиляции. Нет жестко заданных значений интервала, выравнивания. DesignGridLayout обрабатывает все это для вас.

Краткая кривая обучения и как быстрая компоновка формы в качестве дизайнера GUI!

С тех пор, как я открыл его около 2 лет назад, я использовал его исключительно (у меня всегда были аллергические реакции на дизайнеров GUI из-за ужасного сгенерированного кода). Именно по этой причине я взял на себя этот проект 8 месяцев назад, потому что я хотел дать ему полный потенциал.

Я использовал много дизайнеров GUI на протяжении многих лет (для разных языков): Delphi, Visual Studio, JBuilder, Netbeans.


Качество кода, которое они производят, и объем важны. Delphi был фантастическим, он производил небольшие количества кода относительно размера формы, и код был легко понятен, а двухсторонние инструменты позволяли с уверенностью изменять сгенерированный код. Это помогло просто понятая библиотека графического интерфейса. VS производит коды кода, и вы боитесь его изменить.

Java частично подпадает под язык, без делегатов или закрытий, поэтому код на основе событий может быстро стать разрастанием.

Я бы сбил простые вещи с Netbeans Matisse и, когда-то уверенно, передал их код. Сложный материал стоит запланировать и ручное кодирование, чтобы вы хорошо определили свою модель.

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

Для систем с множеством простых форм я склоняюсь к XML-маршруту —

  • определить файлы XML для информации и любой рабочий поток для каждой формы
  • создать XSLT для создания Java/XHTML/любого кода для запуска форм на настольном ПК/мобильном/веб-сервере
  • также создают XSLT для генерации объектов данных исходного кода и т.д.

Вы можете использовать XForms и их реализации, но обычно я работаю в тех местах, где покупка решений занимает больше времени, чем создание собственного простого XSLT. Обычно требуется неделя, чтобы получить все и запустить, если в формах не слишком много специализированных виджетов. Если вы создаете собственные генераторы кода, у вас есть полный контроль. Если вы обнаружите, что хотите переключать все свои формы на прокрутку вверх/вниз, чтобы быть представленными в столбцах, то есть только одно место, которое вам нужно изменить, а не изменять реализацию каждой формы. (хотя вы могли бы создать структуру для абстрактной информации формы из презентации на Java, она не очень подходит для такого декларативного программирования)

2 boutta [2009-01-22 10:53:00]

Мы делаем это вручную, но с библиотекой, помогающей нам с макетом (JGoodies Forms) и так далее. Далее мы используем набор предопределенных компонентов, которые мы подключаем к нашему пользовательскому интерфейсу (Jide). Хорошо работает для нас.

1 Miles D [2009-01-22 11:05:00]

Я делал это в последнее время — я использую Netbeans и изначально был разочарован отсутствием контроля сгенерированного кода. Затем я обнаружил, что вы можете добавить пользовательский код из построителя GUI, который преодолел большинство проблем. Однако я больше расстроился менеджером компоновки в NetBeans и обнаружил, что это ухудшает мою производительность больше, чем что-либо. Я переключился на MiGLayout и теперь большую часть кодирования выполняет вручную. Сказав это, NetBeans в целом довольно хорош, и, возможно, мне следовало потратить больше времени на изучение GroupLayout.

Если вы занимаетесь разработкой команды, убедитесь, что вы все используете один и тот же инструмент, если полагаетесь на построитель графического интерфейса.

Я лично поклонник ветки графического интерфейса от кода (в противном случае вы в конечном итоге с проблемами, о которых вы только что упоминали). Также, похоже, эта тенденция: у Microsoft есть свой XAML, вы продолжаете слышать о разных механизмах просмотра для MVC и т.д.

Почему бы не пойти с графическим интерфейсом на основе XML? Вы можете попробовать что-то вроде JFormDesigner, которое может обрабатывать как XML, так и сгенерированные кодом макеты.

Я начал программировать на VB, а затем перешел к С#. Я бы сказал, что разработчик GUI Netbean по-прежнему далеко от Microsoft, особенно с менеджером макета в форме. Это очень радует, когда вы пытались переместить кнопки и ярлык, чтобы их выровнять по желанию, и те, которые вы не хотите переместить, начали перемещаться по всему месту.

Цукерберг рекомендует:  Android - Мобильные приложения

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

Я использовал Netbeans в прошлом для создания кода GUI и использовал Eclipse для написания логики программы. Просто включите GUI-код в отдельную исходную папку LINKED.

Я бы сказал, что используйте только GUI-конструктор, если вы понимаете, что вы пытаетесь сделать, чтобы вы могли сделать это сами.

Если вы создаете GUI-формы с помощью редактора графического интерфейса или нет, я настоятельно рекомендую вам разработать набор стандартных панелей bean, которые вы можете разместить в своих формах.

У нас около 100 из этих beans, которые мы использовали в более чем 600 формах. Ниже приведена картинка с изображением одного из этих beans:

Эта панель состоит из стандартного ярлыка, обязательного индикатора (красная звездочка), поля редактора (в данном случае комбинированного поля) и поля только для отображения (серый квадрат). В этом случае поля combo-box и display-only являются взаимоисключающими — только один из них видим за раз, в зависимости от того, в каком режиме находится форма/поле.

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

Теперь, как мы строим наши формы? Ну, мы делаем все наши формы в построителе GUI NetBeans Matisse. Мы очень этому довольны. Хотя вы не можете редактировать код, который он генерирует, у меня никогда не было таких случаев, когда это мешало мне что-то делать в графическом интерфейсе. beans, о котором я упоминал выше, можно легко добавить в палитру, поэтому добавление их в формы — это drag-n-drop.

Существуют определенные методы, которые, на мой взгляд, делают вещи проще. Мы используем BoxLayout (по оси страницы) в большинстве наших форм и в сочетании с нашими стандартными панелями bean, построение формы может буквально занять несколько минут (по крайней мере, на графической стороне). Кроме того, FlowLayout полезно, если у вас несколько элементов управления в одной и той же строке в форме (например, несколько флажков).

И это тоже легко, а это значит, что мы можем заставить некоторых (не программистов) бизнес-аналитиков создавать формы до того, как программист добавит код «под капот».

0 David [2013-05-31 21:19:00]

Если ваши формы просты и не являются динамическими, то создатель GUI идеально подходит. Чем сложнее форма, тем меньше преимуществ вы получите от использования GUI-застройщика.

Компания, над которой я работаю, делает именно это. Простые приложения разрабатываются с помощью GUI-конструктора, и более сложные приложения выполняются вручную. Когда есть достаточное количество часов, пытаясь обойти ограничения GUI-застройщика, он обычно заброшен. Кроме того, каждый GUI-конструктор не создается одинаково, поэтому вам будет необходимо оценить с вашей стороны, чтобы определить, в каких ситуациях подходит GUI-конструктор. (Конструктор GUI NetBeans довольно хорош.)

Лично мне нравится использовать GUI-сборщики, чтобы придумать общий макет и приложение/форму и играть с разными макетами, но затем я конвертирую это в более читаемый код и делаю все остальное вручную.

GUI в Java c помощью JFace: Создание окна приложения

JFace — это доплнительный слой абстракции над графической библиотекой SWT, предоставляющий возможности для разработки графического интерфейса приложения на основе модели MVC(Model View Controller). Основные компоненты JFace включают:

  • Viewers — классы для инкапсуляции задач предоставления данных для отображения, их фильтрации, сортировки и т.п.
  • Actions and contributions — вводят семантику описания пользовательских действий и того, как они должны быть доступны пользователю.
  • Image and font registries — предоставляют классы для управления ресурсами, такими как изображения и шрифты.
  • Dialogs and wizards — фреймворк для построения сложного диалогового взаимодействия с пользователем.
  • Field assist — предоставляет возможности для реализации вспомогательной функциональности для полей, такой как отображение статуса поля или подсказки о содержимом.

В первой части будет рассмотрено создание простого окна с использованием JFace, добавление к нему меню, статусной строки и панели инструментов.

Настройка проекта

Для того, чтобы разрабатывать графические приложения с использованием JFace в Eclipse, необходимо подключить jar-файлы SWT и JFace.

  • В случае, если в Eclipse установлено PDE, то это можно сделать, указав в настройках проекта использовать библиотеку SWT, и поставить галочку для поддержки JFace.
  • Если же PDE не установлен, то необходимо подключить jar-файлы к проекту вручную. Найти их можно в директории plugins эклипса, называются они org.eclipse.swt_*.jar и org.eclipse.jface_*.jar

Создание окна

Окно приложения в JFace наследуется от класса ApplicationWindow, предоставляющего возможности для создания меню, панелей управления и строки статуса.

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

Создание содержимого окна

Для того, чтобы создать какое-то содержимое окна, необходимо переопределить метод Control createContents( Composite parent ) класса ApplicationWindow. Метод должен возвращать компонент, который будет являться содержимым окна.

В этом же методе можно установить и заголовок окна, вызвав метод setText( String text ) шелла, доступного по вызову getShell()

В этом примере таким компонентом будет просто метка белого цвета, в реальных приложениях таким компонентом является какой-нибудь композит.

Добавление статусной строки

Добавление к окну приложения статусной строки реализуется не просто, а очень просто. Для этого надо всего-навсего вызвать защищенный метод addStatusBar(). Наверное, наиболее подходящим местом для такого вызова является конструктор окна, или какой-нибудь метод его инициализации.

Для того, чтобы отобразить текст в статусной строке необходимо вызвать метод setStatus( String status ), аргументом которого и является та самая строка, которую необходимо отобразить.

Создание меню


Для создания строки меню в JFace необходимо, вызвать метод addMenuBar(), как и для создания строки статуса.
Но затем необходимо добавить пункты меню на панель. Осуществляется это следующим образом:

  • Раздел меню описывается классом MenuManager. В конструкторе ему может быть передана строка — имя раздела, где символ «&» означает, что следующий за ним символ будет ключом при навигации с помошью клавиши Alt. Добавляется раздел меню на панель с помощью конструкции getMenuBar().add( menu ).
  • Пункт меню описывается классом Action. Сам класс является абстрактным, пункт меню должен быть унаследован от него и переопределять метод vo >В следующем примере мы создаем раздел меню File и один пункт Hello в нем, выбор которого вызывает появление текста в статусной строке окна. Код создания меню я оформил в один метод, который вызывается из конструктора окна:

Создание панели инструментов

Для того, чтобы создать панель инструментов в окне необходимо в конструкторе окна вызвать метод addToolBar( int style ), в который передать стиль компонента панели.

Для доступа к созданной панели используется метод getToolBarManager(). Для добавления действия на панель используется метод add панели, куда передается действие.

В простейшем случае создание панели и добавление на нее кнопки будет выглядеть:

Создание нескольких перемещаемых панелей инструментов

Вместо одной панели инструментов можно создать набор перемещаемых панелей (CoolBar). Для этого необходимо:

  1. Вместо метода addToolBar вызвать метод addCoolBar
  2. Для доступа к набору панелей используется метод getCoolBarManager()
  3. Создать панель инструментов, на которую можно будет добавлять действия. Для этого необходимо создать новый экземпляр класса ToolBarManager, который будет представлять панель и вызвать метод add у CoolBarManager, передав туда панель.
  4. На созданную панель можно добавлять действия

Пример кода, создающего две плавающие панели:

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

Возможные проблемы

Здесь будут описаны некоторые проблемы, с которыми можно столкнуться:

  • При добавлении пунктов меню после запуска приложения они не появляются — чтобы изменения меню после создания окна отобразились на нем, необходимо вызвать метод getMenuBarManager().update( true ) — указать обновить панель меню.

Ссылки

Дополнительная информация по JFace может быть найдена по следующим ссылкам:

How to create a GUI in Java [closed]

Want to improve this question? Update the question so it’s on-topic for Stack Overflow.

Closed 2 months ago .

I have used Java for some time, but I have never created a GUI — always CLI. How does one create a GUI in Java? Can you suggest a good tutorial/reference?

I’m looking to create a simple GUI that has two long text areas and some buttons.

7 Answers 7

Here’s a simple example

Read about Swing on Oracle Tutorial’s pages.

Well what you have to do is create your text/code thin (Note Pad++ or Notepad) and remember the name.

Then open it an type

This basically tells java to get java.awt and javax.swing from its various code libraries that came with java when you downloaded it (Understandable as this is language made to help developers).

You then need to make your function that will have everything from the size, text inside it, color ect. REMEBER, we are not coding the gui here as that was already done when we imported import java.awt.*; and javax.swing.* ;.

When I put public class work ,Work in the name of my file (if it was called code it would be public class code .

Remember you have not called the function anywhere, its basically waiting there until it is called.

This tells the computer that what ever comes next, you do when i run the program.

So inside that you need to put

As this is what you called your function above and it is calling the function, you do not need to call this function as it does it when you run the program.

Визуальное программирование на Java

Почти все книги и уроки по Java для новичков начинаются с описания ООП: какой он замечательный с великолепный. Понятно, поскольку в Яве просто невозможно любое другое программирование, кроме как объектно-ориентированное, то вначале предлагается освоить 40..80 страниц безумных аналогий с иерахией кошечек/собачек/уточек/автомашин, и только после этого предлагается написать «Hello, World!». :-)

При этом стоит заметить, что абсолютно всё обучение Java строится на примитивнейшем выводе результата на консоль. То есть не консольное приложение в привычном понимание, а именно вывод каких-то данных построчно. Ну вот например Turbo Pascal 3.0 вышел в 1985 году и в нём уже была поддержка графических режимов. В 1990 году появился Turbo Vision — очень крутая вещь — аля-Windows только для DOS. А в Яве в 2020 году возможен только вывод на консоль. И вот вся эта восторженность и крутость как-то вдребезги разбивается уже на этапе «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, не важно). Даже для «зеленого» новичка создание простой программы (одна кнопка и текстовое поле для вывода) будет происходить так:

  • запускаем Delphi;
  • автоматом создается новый проект с главной формой;
  • выбираем на палитре компонентов кнопку и размещаем на форме; всё визуально
  • аналогично кидаем на форму текстовое поле;
  • при необходимости в панели свойств можно указать текст кнопки, размеры и т.п.;
  • запускаем — Delphi предложит сохраниться, сохраняемся.


То есть мы не написали ни единой строчки кода, IDE — всё сделала сама. Если посмотреть на сгенерированный код, то назвать его простым нельзя — здесь уже требуются определенные знания, но Delphi достаточно умна, чтобы понимать как с ним работать.

Если мы захотим добавить какое-то действие, например при нажатии на кнопку, заполнять текстовое поле фразой «Привет!», то делаем так:

  • два раза кликаем на кнопку (или выбираем событие onClick);
  • Delphi создает код обработчика этого события и перекидывает нас в редактор;
  • набираем название текстового поля и 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

Перед началом работы, нужно подключить SceneBuilder: Сервис — Параметры — Java — JavaFX — Начальная страница Scene Builder. Выберите каталог программы. Настройку достаточно сделать один раз. Это относится ко всем IDE.

Создаём новый проект, где нужно выбрать «Приложение FXML JavaFX».

Жмём «Далее» и видим окно настройки проекта. Нужно указать название проекта, у меня это myfx.

Жмём «Готово» и, после некоторой работы NetBeans, видим готовые файлы:

  • Myfx.java — это main-файл, который, собственно и запускает всю программу.
  • FXMLDocumentController.java — это «контролёр», где и будет в основном программирование.
  • FXMLDocument.fxml — этот файл хранит визуальную часть.

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

Это круто, потому что мы не написали ни строчки кода, но уже получили программу с работающей кнопкой. :-)

Если вы правильно указали путь к SceneBuilder, то можете выбрать пункт меню «Открыть» на файле FXMLDocument.fxml. Это же самое произойдёт если сделать двойной клик. Откроется SceneBuilder. Если пункта нет, то путь указан не верно, проверьте настройку.

Принцип работы в SceneBuilder един для всех IDE, поэтому пока я опишу только общие моменты, дальше вы уже сами сообразите.

Стоит отметить, что после редактирования файла, закрывать SceneBuilder не нужно. Достаточно только сохраниться (Ctrl+S) и переключиться на IDE — она сама подхватит изменения.

Окно SceneBuilder разделено на три части:

  • слева — наборы компонентов, иерархия и Controller, где указывается основной класс (это важно!)
  • в центре — сама форма, где и происходит визуальное построение.
  • справа — свойства компонентов, разделенные на три закладки (это условное деление). Вкладка Code отвечает за то, что будет использоваться в java-файле.

Построение FX-программ должно начинаться с контейнера. В данном примере NetBeans использовал AnchorPane. Он довольно удобный, позволяя настраивать для вложенных элементов «правильные» отступы. Вкладка Containers содержит другие контейнеры, с которыми вы сможете самостятельно потренироваться (я и сам ещё и половины не освоил :-) ).

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

По условиям ТЗ у нас должно быть текстовое поле. NetBeans использует Label, но мы не будем ничего удалять, а просто добавим новый элемент TextField на форму (произвольно на ваш вкус).

В SceneBuilder возможен предварительный просмотр (Ctrl+P). В этом режиме отображается только форма и все элементы «без java-программирования».

Теперь важный момент: для того чтобы можно было использовать компонент в java-программе (в нашем коде), следует выполнить две вещи.

Первая — проверить, что указан верный контролёр. В нашем случае NetBeans сам уже всё сделал и указал myfx.FXMLDocumentController .

Как видно — это контролёр из файла FXMLDocumentController.java (пакет.контролёр). Не всегда IDE его указывают, но это важно, поскольку fxml-файл (точнее java-код) использует его для привязки.

Второй момент — используемый компонент должен иметь свой ID — это параметр fx:id . Здесь я указал textField1.

Вверху появится желтый треугольник сообщения, что якобы нет связки этого 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 происходит несколько дольше, чем NetBeans. Вначале нужно указать путь к SceneBuilder. Делается это в Window — Preferences — JavaFX.

Обратите также внимание на то, что 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 запускается довольно неспешно, можно успеть проверить почту. :-)

Опять же указываем путь к SceneBuilder: File — Settings:

Дальше создаем новый проект:

И указываем его имя (как обычно — myfx):

IntelliJ IDEA выполнит инициализацию и мы увидим уже знакомые три файла. Запустим программу, чтобы проверить отсутствие ошибок.

Здесь также пустая форма, но зато указан заголовок программы. Если посмотреть на код Main.java, то увидим строчку:

Это и есть заголовок приложения. В других IDE эта строчка отсутствует, но зато теперь мы знаем для чего нужны «театральные подмостки». ;-)

Переключаемся в SceneBuilder (аналогично Eclipse): второй кнопкой мыши нужно выбрать Open in SceneBuilder.

Здесь также пустая форма, но с контейнером GridPane. Устанавливаем Pref Width и Pref Height, чтобы отобразилась форма.

Сам по себе GridPane представляет собой аля-сетку из ячеек для элементов. Думаю, что тут нет смысла повторяться — все действия будут аналогичными:

  • разместить кнопку и тестовое поле,
  • присвоить им id,
  • для кнопки прописать метод для обработки клика,
  • не забываем проверить, указан ли контролёр (sample.Controller).

Закрываем SceneBuilder и возвращаемся в IntelliJ IDEA. Здесь нужно добавить идентификаторы id в код, а также создать метод для реакции на нажатие кнопки.

IntelliJ IDEA предлагает для этого два способа. Первый — при наведении мышки на «проблемное место» будет появляться подсказка, на которую можно кликнуть:

Второй — горячая клавиша Alt+Enter

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

При этом, заметьте, не добавляется строчка «@FXML». Если мы вручную его добавим перед переменными и методом, то IntelliJ IDEA сразу предложит добавить нужный java-класс:


Вообще IntelliJ IDEA показывает достаточно хорошую сообразительность и выступает помощником в написании кода. Причём делает это самостоятельно без лишних нажатий кнопок.

Ну что ж, добавляем свой код для обработчика и запускаем программу:

Прекрасно, всё работает!

Итого

Главный вывод — на Яве возможно визуальное программирование. Может оно и не идеальное, но вполне годное, особенно для новичков. Изучать язык гораздо интереснее, когда есть какой-то осязаемый результат — ООП, классы и прочие премудрости — это хорошо, но лучше начать с кнопочек, полей ввода, меню и всего того, что подразумевает нормальная программа. А консоль — это скучно и неинтересно.

Три IDE я привел не случайно. В Сети очень много примеров для Явы и все они для разных программ. Лично я ещё не определился со своим предпочтением, поскольку у всех есть как плюсы, так и минусы. Наверное нужно поработать со всеми, тогда и будет понятно.

Но, ключевой момент — это умение работать с SceneBuilder. Построение формы в JavaFX немного отличается от той же Delphi, в первую очередь в использовании сложных контейнеров (они могут быть вложенными друг в друга). Поэтому вначале следует разобраться с ними, после уже можно браться за сами компоненты.

Рассмотренные программы очень простые, для изучения наверное стоит написать что-то более интересное, например калькулятор. То есть те проекты, которые не требуют особых знаний и рассчитанные на быстрый результат. Впрочем, это уже на любителя. :-)

Лекция 09. GUI.Swing¶

Введение¶

Пакеты¶

Для построения GUI в Java используются следующие основные пакеты:

  1. Awt — появился в первых версиях, используется мало.
  2. Swing — самый популярный пакет.
  3. JavaFX — современный и перспективный.

Awt пример¶

Swing пример¶

JavaFX пример¶

Сравнение¶

Недостатки awt:

  • ‘’тяжеловесные’’ компоненты (системозависимые);
  • невозможность изменения внешнего вида.

Недостатки swing:

  • ограничения в изменении внешнего вида;
  • ориентация на desktop-приложения.

Swing¶

Простое приложение¶

Рассмотрим простейшее Swing-приложение.

Контейнеры верхнего уровня¶

Все swing-программы должны включать в себя Контейнеры первого уровня

  • JFrame
  • JApplet
  • JWindow
  • JDialog

Эти контейнеры находятся на вершине иерархии контейнеров и

содержат в себе другие, ‘’легковесные’’ контейнеры и элементы

управления. Разница между JFrame и JWindow может быть показана

на следующем примере:

Окно JFrame, в отличие от JWindow

Выбор библиотеки для написания GUI приложения

Разработка настольных приложений на я. /

Swing, AWT & SWT

04 апр 2009 18:18

Подскажите в двух словах разницу между Swing, AWT & SWT.
Всмысле что предпочтительнее, проще или еще какие минусы и плюсы. На сколько я понимаю SWT наиболее продвинутый?

Мне просто срочно понадобилось написать прогу на java, а времени на изучение, анализ и выбор инструментов к сожелению нет. Опыта в java программировании 0.

И если можно, то подскажите какой из бесплатных плагинов к IDE eclipse для визуального создания GUI интерфейса.

Заранее всем спасибо.

04 апр 2009 18:30

P.S. в двух словах)

04 апр 2009 18:56

В этом случае соглашусь с masyan .
Использовать Swing, Eclipse сменить на NetBeans, т.к. визуальное создание GUI там идет «искаропки».

04 апр 2009 22:02


А я бы посоветовал SWT и Eclipse ;-)
Плагин называется VisualEditor, только он не все умеет, что в принципе можно делать.

http://ru.wikipedia.org/wiki/Swing_(Java) — (это все одна ссылка, скопируйте в окно браузера)
SWT

04 апр 2009 23:12
04 апр 2009 23:43

Да я вобчем то и сам программер, только вот с явой знаком только в теории.
Ну а прога нужна вот для чего:
1) рекурсивно обойти все дерево Novell eDir (возможно LDAP) и сохранить в определенном виде (наверно в LDIF) значения определенных атрибутов с определенных объектов;
2) восстановить значения атрибутов из сохраненных данных;
3) ну и куча доп. функций по мере развития проги.

Основная прога должна быть без гуи (консольная) и нужна гуевая обертка к ней.

Вот такая вот простая прога, а почему на яве? — хочется кросплатформенность попробовать. Да и давно хотел яву пощупать.

05 апр 2009 00:28
05 апр 2009 00:34

Вот Вы уже составили кое-какой план своей работы, теперь по мере выполнения каждого пункта задавайте конкретные вопросы в родственные разделы форума.

PS
Скачайте книги Хорстмана или Шилдта, перед тем как спрашивать на форуме, там очень много ответов :wink:

05 апр 2009 01:51
05 апр 2009 10:38

Возможно я не совсем точно выразил то, чего я хотел. А хотел я, что бы люди, имеющие определенный опыт работы с java, подсказали какие инструменты на данный момент предпочтительнее использовать.
Просто хотелось пропустить ту стадию, когда приходится самому опробывать все и выбирать правильные инструменты.
Например, не хотелось бы, что бы через неделю другую, начав писать с использованием Swing оказалось, что эта библиотека не перспективна и уже не развивается, а все подовляющее большенство использует SWT к примеру.
Тем более что я не буду ограничиваться написанием одной проги, а это просто как повод подружиться с явой всерьез и на долго.

Если можно, то просто коротко перечислите основные средства, которые вы используете обычно.
Например так: eclips, SWT и т.д.; или netbeans, Swing и т.д.
А если кто знает ссылки на хорошие материалы по статистике использования средств для разработки ПО на java, то буду благодарен.

Спасибо всем за ответы.

06 апр 2009 09:14
06 апр 2009 12:40

Я когда устроился на работу, там был Eclipse и, соответственно, SWT. Про свинг знаю постольку-поскольку. Ни то, ни другое отмирать не собирается. Свинг — как основной инструмент GUI на Java, а Eclipse и SWT — как детище IBM.

Часть 2

Серия контента:

Этот контент является частью # из серии # статей: Создание GUI приложений в Java с использованием библиотеки GTK+

Этот контент является частью серии: Создание GUI приложений в Java с использованием библиотеки GTK+

Следите за выходом новых статей этой серии.

В предыдущей статье вы получили представление о том, как создавать и собирать приложения GTK+ с использованием Java. Для тех, кто не читал предыдущую статью, но знаком с разработкой на Java, коротко резюмируем: чтобы использовать библиотеки GTK+ в Java-программе, достаточно добавить gtk-4.0.jar в classpath. Взять этот файл можно на сайте java-gnome.sourceforge.net.

Что касается средств разработки, то собирать и запускать программы из командной строки, как это делалось в предыдущей статье, не очень удобно. Поэтому лучше будет воспользоваться какой-нибудь IDE, например, Eclipse. Она доступна в освоении даже для новичка. Прежде чем переходить к примерам этой статьи, проделайте следующее:

  1. Скачайте, установите и запустите Eclipse (www.eclipse.org).
  2. Создайте java-проект (File -> New -> Java Project).
  3. Добавьте в buildpath библиотеку gtk-4.0.jar Для этого перейдите в Project -> Properties -> Java Build Path -> Libraries -> Add External JARs, найдите в иерархии папок gtk-4.0.jar (скорее всего, он находится в /usr/share/java) и нажмите ОК.

Теперь в проекте можно использовать GTK+. Также нелишним будет добавить javadoc к библиотеке. Для это необходимо установить пакет libjava-gnome-java-doc (в Ubuntu, для других систем название может слегка отличаться). Помимо справки по API, в этом пакете содержатся неплохие примеры. Чтобы добавить javadoc к библиотеке, щелкните правой кнопкой на ней в структуре проекта (gtk-4.0 -> Properties -> Javadoc Location) и впишите что-то вроде file://usr/share/doc/libjava-gnome-java/api/ в появившемся поле. В вашей системе путь может отличаться: поищите папку api самостоятельно или посмотрите содержимое пакета libjava-gnome-java-doc.

Можно также установить и исходные тексты библиотеки. По адресу http://ftp.gnome.org/pub/gnome/sources/java-gnome/4.0/ доступна самая свежая версия. Принцип подключения такой же, как и для javadoc, только tar.gz-файл необходимо будет распаковать — по крайней мере, Eclipse 3.5 tgz-архивов не понимает.

Далее будут последовательно разбираться элементы библиотеки GTK+: мы познакомимся с созданием окон, кнопок, меню и тому подобного. Итак, приступим.

Окна, контейнеры, размещение элементов

Окно — основа основ любого GUI-приложения. За его создание (а также поведение, внешний вид и т.д.) отвечает класс org.gnome.gtk.Window. В качестве примера приведем полный код класса создания пустого окна. Далее при рассмотрении элементов управления мы будем приводить только соответствующие фрагменты кода. Их положение в общей структуре программы обычно не будет вызывать вопросов, и мы не будем заострять на этом моменте внимание. Тем не менее, полный исходный код будет представлен в конце дискуссии.

Листинг 1. Создание пустого окна.

Хорошо известно, что приложение начинается с вызова статического метода main(). Назначение Gtk.init(args) и Gtk.main() обсуждается в предыдущей статье. Если запустить это приложение, то можно увидеть абсолютно пустое окно, без меню, кнопок и даже без заголовка. Кнопка закрытия окна — и та не работает нормально: не завершает приложение, а только скрывает окно. Ситуация вполне ожидаемая, т. к. никаких манипуляций с окном, кроме создания и отрисовки, мы не проводили. Ниже мы рассмотрим, как заставить эту кнопку работать. Конструктор без параметров создает окно верхнего уровня. Типы окон определены в классе WindowType и могут принимать значения TOPLEVEL или POPUP. В первом случае создаваемая область, называемая «окном», уже имеет «признаки оконного приложения», т. е. кнопки сворачивания/разворачивания, закрытия, границы, заголовок и т. д. Но самое главное — это окно «видно» менеджеру окон. Для создания основного интерфейса приложения нужно использовать именно такие окна. Тип POPUP (всплывающее окно) предназначен, очевидно, для различных подсказок, меню и т. п. По умолчанию, он не имеет никаких из вышеперечисленных атрибутов и представляет из себя лишь пустую прямоугольную область. Создать его можно, если явно указать тип в конструкторе Window: new Window(WindowType.POPUP);

Рассмотрим некоторые методы класса Window. Самый главный из них, пожалуй, — это showAll(). Без него окно и его содержимое не прорисуется на экране. Принцип работы с окном в общем заключается в следующем: сначала окно создается (new Window()), ему присваиваются различные свойства (например, setTitle(«Window’s Title»)), добавляются элементы (метод add()), и затем вызывается метод showAll(), чтобы все это отрисовать. Отделение создания окна от его отрисовки обусловлено тем, что если оно появится на экране в момент создания, а затем ему, например, изменят ширину, то пользователь увидит дергающееся окошко. При использовании же showAll() GTK+ уже имеет всю необходимую информацию и знает что, где и в каком виде рисовать [Это, конечно, не значит, что вы обязаны установить все свойства окна перед его отрисовкой, или что параметры отрисованного окна нельзя изменить. — Прим.ред.].

Окно обладает различными свойствами: заголовком (Title), именем (Name), размерами (Width, Height, SizeRequest), модальностью (Modal) и т. д. Практически у каждого такого свойства есть соответствующие сеттеры. Например, добавим в наше приложение заголовок и установим размеры:

В качестве особенности можно отметить наличие свойства Stick. Метод setStick(boolean) устанавливает, будет ли окно видно на всех рабочих столах Gnome, KDE или аналогичного окружения. Здесь уместно затронуть вопрос кросс-платформенности: в Windows концепция множественных рабочих столов распространения не получила, что будет влиять на внешний вид и поведение вашего приложения. В данном случае это едва ли критично, но подобные вещи следует иметь в виду. Теперь поговорим о размещении в окне чего-нибудь полезного. Для этих целей существует абстрактный класс org.gnome.gtk.Container. Методов у него немного: add(Widget child), remove(Widget child), getChildren(), setBorderWidth(int width). Их говорящие имена едва ли требуют пояснений. Уже рассмотренный нами класс Window также является потомком Container, однако не прямым: Window наследует org.gnome.gtk.Bin, аBin — Container. Класс Bin — это контейнер, который может хранить только один элемент. На практике это означает, что использовать, например, Window для создания разметки не получится. Для этого существуют классы типа VBox и HBox. Как правило, в качестве этого единственного хранимого виджета для Window выступают представители именно этих двух классов. Например, обычная кнопка (org.gnome.gtk.Button) также является потомком Bin, и в ней может быть текст и/или иконка, но опять же — в единственном экземпляре.

Различные кнопки, поля ввода, надписи необходимо как-то группировать и размещать в удобочитаемом виде. Думая над разметкой, следует учитывать, что оперировать придется в основном классами VBox и HBox. HBox — это, грубо говоря, таблица с одной строкой и бесконечно большим числом колонок, VBox — таблица из одной колонки и также неограниченным числом строк.

Классы VBox и HBox наследуются от абстрактного org.gnome.gtk.Box, в котором сосредоточена вся функциональность этих виджетов. Кроме конструкторов, они ничего не переопределяют. Класс Box предназначен для организации элементов в прямоугольной области или в таблице. Используется он лишь в трех классах: VBox, HBox и ButtonBox. Этот класс примечателен своими методами добавления виджетов. Они более гибкие, чем add(Widget child) класса Container, потомком которого он является. Метод packStart(Widget child) добавляет элемент в начало контейнера (сверху вниз в VBox и слева направо в HBox), packEnd(Widget child) — в конец (снизу вверх в VBox и справа налево в HBox). Наверное, это требуется немного пояснить: виджет, установленный первым вызовом packStart будет первым, вторым вызовом — вторым и т. д., при использовании packEnd() список как бы переворачивается и происходит то же, что и при packStart() — виджет, установленный первым вызовом, будет последним, вторым вызовом — предпоследним и т. д. packStart() и packEnd() имеют свои расширенные версии, в которых можно задавать, например, будет ли элемент расширяться до размеров ячейки или величину границы. Метод packStart(Widget child), по сути, является полным эквивалентом add(Widget child).

Теоретически можно создать сколь угодно сложную разметку, используя лишь VBox и HBox, потому как они также наследуют классу Widget и, следовательно, могут быть вложенными друг в друга. Подобным образом и создаются интерфейсы: дочерним элементом в окне устанавливается экземпляр VBox, в ячейки этого контейнера помещаются экземпляры HBox, в его ячейки — экземпляры VBox и т. д. Степень вложенности зависит от того, насколько сложный требуется интерфейс: кому-то можно будет обойтись вообще без контейнеров, т. е. разместить одну кнопку прямо в окне. Делать так не запрещается, ибо кнопка — тот же виджет, что и VBox.

Давайте добавим в наше приложение контейнер и разместим в нем виджет класса Label, т. е. просто некую надпись, чтобы он не пустовал.

Не забудьте, конечно, добавить сам контейнер в окно, иначе никакой надписи не появится. Конструктор VBox принимает два параметра. Первый отвечает за распределение пространства между дочерними элементами. Значение true означает, что всем элементам будет отдано одинаковое пространство. Это не очень удобно: задать отступы, скажем, в методе packStart уже не получится — скорее всего что-то «съедет» или вообще скроется, поэтому чаще используется значение false. Второй параметр — это расстояние между ячейками в пикселях. Конструктор HBox имеет те же самые параметры.

Java, построитель GUI или ручное кодирование?

У моего программного обеспечения компании много форм, до сих пор мы написали код вручную (путь MVC).

Мы планируем начать использовать построитель GUI.

Существует несколько проблем с использованием Builder.

  • Части кода не являются читаемый .
  • Части кода не являются редактируемые .
  • Редактировать код будет сложнее позже.
  • Нам придется продолжать использовать строитель в будущем, даже если мы хотим заменить конструктор или написать вручную, и никто не может заверить, что инструмент будет доступен и поддержан в будущем.


Я хочу учиться у других:

  • Вы рекомендуете использовать инструмент или продолжать писать код вручную?
  • Какой строитель лучше?
  • Как он справляется с проблемами? (Есть ли другие проблемы?)

Для нескольких форм я рекомендую использовать Builder. Это ускорится. Однако, если у вас есть много форм, которые вам нужно поддерживать в течение некоторого времени, я рекомендую против строителя. В этом случае время, затрачиваемое на чтение кода и обслуживания, намного больше, чем время первоначального проектирования. Таким образом, хотя строитель экономит время на начальной стадии, это затрудняет чтение и обслуживание кода. Более того, это делает повторное использование кода, даже в виде копирования и вставки из одной формы в другую, сложнее.

Я не знаю, ссылаетесь ли вы на веб-приложения или настольные приложения, но в целом я не нашел Java Gui builder, который производит элегантный вывод. Netbeans Swing сгенерированный код, например, беспорядок. Возможно, если бы был хороший строитель, я бы передумал. У меня не возникло проблем с использованием конструктора форм Visual Studio — он создает хороший код, который вы можете читать и понимать.

Для настольных приложений смотрите MiGLayout. Это менеджер компоновки, а не строитель, для Swing и SWT, которые облегчат вашу жизнь.

Используя хороший строитель, разработка будет намного быстрее.

Тревога, которую вы не можете изменить код, может быть вызвана тем, что у вас много логики в представлении, где оно не принадлежит. Фактически это изменение может помочь вам переместить логику из представления, которое хорошо подходит для возможности изменять визуальные элементы без нарушения кода.

В соответствии с «нечитаемым» вы должны рассмотреть возможность использования лучшего генератора графического интерфейса. Я слышал только положительные вещи о NetBeans, и я использовал конструктор GUI IntelliJ, код которого довольно чистый.

В обоих случаях исходный код доступен для чтения и редактирования, но только для небольших настроек. Для основных, хорошо используйте GUI-конструктор.

Я думаю, что для небольшого числа форм нет проблем при работе вручную, но поскольку у вас есть «многие из них», как вы только что сказали, использование этих инструментов будет наиболее полезным.

Мне никогда не нравился код, созданный создателем GUI. По крайней мере, в мире VB это не так, что все (ну, почти) будут использовать одну и ту же среду IDE для создания приложений. В Java люди используют несколько IDE, а некоторые используют VIM и Notepad. И все IDE не генерируют такой же код. И еще одна проблема заключается в том, что они обычно не понимают код, созданный другими IDE. Поэтому, чтобы ответить на ваш 1-й вопрос, я не рекомендую .

Следующий вопрос: какой строитель лучше? В прошлый раз, когда я использовал, Netbeans был лучше, чем большинство из них, которые я пробовал.

Если вы должны использовать построитель графического интерфейса, потому что вам нужно быстрее разрабатывать приложения, убедитесь, что все члены вашей команды используют один и тот же построитель. Лучше получить их мнение об этом, иначе их глаза будут повреждены исходным кодом, созданным IDE.

Дайте нам знать ваше решение!

Я использую NetBeans Java Swing GUI Builder (Matisse) для всех моих проектов за последние 3 1/2 года. Я читал так много жалоб людей на GUI Builders, и самые опытные программисты приветствуют всех, кто даже намекает на использование одного, но вот мой опыт:

  • Не редактируемый код никогда не требуется для редактирования. Действительно, GUI Builder предоставляет скелет для вашего графического интерфейса. Вы перетаскиваете, уменьшаете, изменяете размер и ограничиваете свои компоненты с помощью редактора, но контент таблицы, список для поля со списком и т.д. Все нужно обрабатывать на бэкэнд. Создатель GUI позволяет вам сосредоточиться на этом, пока он заботится о том, чтобы все выглядело красиво и оставалось на месте.
  • WYSIWYG всегда более продуктивен. Текстовые процессоры являются свидетельством этого. Люди скажут вам: «вы не редактируете код GUI, поэтому, если это экономит ваше время, это не так много времени». Но это утверждение чрезвычайно относительное. Когда вы работаете в программной среде с моделью процесса, которая требует постоянных обновлений из-за изменений бизнес-модели, это утверждение ложно. Кроме того, вы тратите большую часть своего времени на контент своего английского эссе, не так ли? Таким образом, этот аргумент сказал бы, что WYSIWYG Word-процессоры не экономят вас столько времени, и такое утверждение будет падать на глухие уши, потому что никто не захочет скомпоновать их внешний вид эссе.
  • Ничего не может сделать GUI Builder, который может сделать этот рукописный код, в то время как я потратил часы, пытаясь решить небольшие проблемы с рукописным графическим интерфейсом, который занял у меня 1 минуту в построителе графического интерфейса.

Создатель GUI Netbeans, в частности, стал намного лучше с течением времени, что большая часть полученного им flak (похожего на большую часть flak Java получила) была действительно аннулирована. Это отличная программа, и это отличный способ быстро и эффективно создавать многофункциональные, красивые интерфейсы. Я очень рекомендую хороший GUI Builder, особенно Netbeans.

Там я это сказал.

Нет, я не работаю для них.

Я бы держался подальше от строителей ги. По моему опыту (matisse) вы в конечном итоге тратите столько времени на то, чтобы писать gui с создателем вручную, если не больше. Из-за попытки прочитать сгенерированный код и очистить его при внесении изменений. Кроме того, если вы пишете gui вручную, вам нужно будет понять код, чтобы написать gui, и это поможет сверхурочно стать более опытным, и вы быстрее начнете писать gui, и вы будете быстрее и вручную их записывать, Со временем вы также можете разработать компонентную библиотеку для функциональности gui, которую вы можете писать несколько раз. Я бы держался подальше от строителей. Хороший разработчик в любой момент будет бить среднего разработчика с помощью строителя.

Если у вас слишком сложные формы для сборки, вы можете взглянуть на DesignGridLayout, это Swing LayoutManager с что позволяет легко писать код для вашей формы и легко читать этот код (и поддерживать, я имею в виду, изменять, если необходимо) и визуализировать форму через код.

С DesignGridLayout одна строка компонентов в вашей форме — это одна строка кода. Нет XML, полная безопасность во время компиляции. Нет жестко заданных значений интервала, выравнивания. DesignGridLayout обрабатывает все это для вас.

Краткая кривая обучения и как быстрая компоновка формы в качестве дизайнера GUI!

С тех пор, как я открыл его около 2 лет назад, я использовал его исключительно (у меня всегда были аллергические реакции на дизайнеров GUI из-за ужасного сгенерированного кода). Именно по этой причине я взял на себя этот проект 8 месяцев назад, потому что я хотел дать ему полный потенциал.

Я использовал много дизайнеров GUI на протяжении многих лет (для разных языков): Delphi, Visual Studio, JBuilder, Netbeans.

Качество кода, которое они производят, и объем важны. Delphi был фантастическим, он производил небольшие количества кода относительно размера формы, и код был легко понятен, а двухсторонние инструменты позволяли с уверенностью изменять сгенерированный код. Это помогло просто понятая библиотека графического интерфейса. VS производит коды кода, и вы боитесь его изменить.

Java частично подпадает под язык, без делегатов или закрытий, поэтому код на основе событий может быстро стать разрастанием.

Я бы сбил простые вещи с Netbeans Matisse и, когда-то уверенно, передал их код. Сложный материал стоит запланировать и ручное кодирование, чтобы вы хорошо определили свою модель.

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

Для систем с множеством простых форм я склоняюсь к XML-маршруту —

  • определить файлы XML для информации и любой рабочий поток для каждой формы
  • создать XSLT для создания Java/XHTML/любого кода для запуска форм на настольном ПК/мобильном/веб-сервере
  • также создают XSLT для генерации объектов данных исходного кода и т.д.

Вы можете использовать XForms и их реализации, но обычно я работаю в тех местах, где покупка решений занимает больше времени, чем создание собственного простого XSLT. Обычно требуется неделя, чтобы получить все и запустить, если в формах не слишком много специализированных виджетов. Если вы создаете собственные генераторы кода, у вас есть полный контроль. Если вы обнаружите, что хотите переключать все свои формы на прокрутку вверх/вниз, чтобы быть представленными в столбцах, то есть только одно место, которое вам нужно изменить, а не изменять реализацию каждой формы. (хотя вы могли бы создать структуру для абстрактной информации формы из презентации на Java, она не очень подходит для такого декларативного программирования)

Мы делаем это вручную, но с библиотекой, помогающей нам с макетом (JGoodies Forms) и так далее. Далее мы используем набор предопределенных компонентов, которые мы подключаем к нашему пользовательскому интерфейсу (Jide). Хорошо работает для нас.

Чтение документации класса Java из кода в GUI

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

Пример: Пользователь выбирает значение «Протокола» Я хочу, чтобы показать JavaDoc для этого «протокола».

Как я могу идти о признании правильного Javadoc и представить его в текстовой области?

..Javadoc .. представить его в текстовой области?

Не использовать JTextArea , но JEditorPane . Последнее будет оказывать HTML.

JavaDoc не является частью программы Java. Таким образом, вы должны объединять ресурсы с вашей программой независимо от того, какой подход вы используете.

Таким образом, у вас есть две возможности:

Сформировать документацию с Javadoc и перевяжите результат. Легко видеть, как сопоставить с именем класса на страницу HTML, глядя на созданные файлы. Документация JavaDoc (документация Значение по умолчанию Doclet, чтобы быть более точным) содержит более подробное описание

Если вы хотите создать документацию на лету, вы должны связать исходный код приложения. Кроме того, приложение должно работать внутри JDK, а не простой JRE, чтобы получить на руки JavaDoc.

Запуск Стандартный доклет Программная

Инструмент Javadoc имеет программный интерфейс с открытыми методами для вызова инструмента Javadoc из другой программы, написанной на языке Java. Эти методы находятся в классе com.sun.tools.javadoc.Main в Lib / tools.jar. .

открытые статические INT выполнить (String ProgramName, PrintWriter errWriter, PrintWriter warnWriter, PrintWriter noticeWriter, String defaultDocletClassName, String [] арг)

Этот метод выполнения перегружен вариантами, принимая меньше параметров.

Цукерберг рекомендует:  12345 - напишите программу на с# пожалуйста
Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих