Графический интерфейс на java: Введение в разработку графического интерфейса

Введение в разработку графического интерфейса

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

1. Выберите Run («Запуск») > Run Main Project («Запуск главного проекта») (как вариант, нажмите F6).

Примечание. При открытии окна с указанием того, что для Project NumberAddition не задан основной класс, следует выбрать my.NumberAddition.NumberAdditionUI в качестве основного класса в том же окне и нажать кнопку ОК.

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

1. Для сборки архива JAR приложения выберите «Run > Clean and Build Main Project» (Shift-F11).

2. При помощи проводника по файловой системе или диспетчера файлов перейдите в каталог ` NumberAddition/dist`.

Примечание. Местоположение каталога проекта NumberAddition зависит от пути, указанного при создании проекта в шаге 3 в разделе Упражнение 1. Создание проекта.

1. Дважды щелкните файл NumberAddition.jar.

Через несколько секунд приложение запустится.

Примечание. Если при двойном щелчке файла JAR не выполняется запуск приложения, дополнительные сведения о настройке связей файлов JAR в используемой операционной системе см эту статью.

Можно также запустить приложение из командной строки.

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

1. Вызовите командную строку или окно терминала.

2. В командной строке измените текущий каталог на каталог NumberAddition/dist.

3. В командной строке введите следующий оператор:

java -jar  NumberAddition.jar

Примечание. Убедитесь, что my.NumberAddition.NumberAdditionUI задан как основной класс до запуска приложения. Для провери этого, щелкните правой кнопкой узел мыши узел проекта NumberAddition на панели ‘Проекты’, выберите ‘Свойства’ во всплывающем меню и выберите категорию ‘Выполнить’ в диалоговом окне ‘Свойства проекта’. В поле ‘Основной класс’ должно отображаться my.numberaddition.NumberAdditionUI .

Графический интерфейс на Java

И на Java можно разрабатывать графические интерфейсы. Данный раздел сайта посвящен Java Swing и другим библиотекам для построения GUI.

2007-06-21

Графический интерфейс на Java

Пример реализации прозрачного окна на Java Swing. Как бонус — эмулируем прозрачность окна с помощью механизма снятия скриншотов.

2006-10-06

Графический интерфейс на Java

Реализация популярной игры Мемеорина на Java Swing. Кроме этого в статье описывается решение пробемы с загрузкой ImageIcon.

2006-03-07

Графический интерфейс на Java

Реализация всем известной игры Пятнашки с использованием технологии Java Swing. Игра и исходный код программы доступен для свободного скачивания.

2006-02-16

Графический интерфейс на Java

Еще одна библиотека для создания пользовательских интерфейсов — Standard Widget Toolkit. В статье приведен простой пример GUI на Eclipse SWT.

2006-02-09

Графический интерфейс на Java

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

Создание графических интерфейсов в Java-программах

вопрос в процессе изучения

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

Abstract Window Toolkit (AWT) (wiki_eng, wiki_ru) — исходная платформо-независимая оконная библиотека графического интерфейса (Widget toolkit). Некоторые разработчики предпочитают эту модель, поскольку она обеспечивает высокую степень соответствия основному оконному инструментарию и беспрепятственную интеграцию с родными приложениями. Другими словами, GUI программа, написанная с использованием AWT, выглядит как родное приложение Microsoft Windows, будучи запущенной на Windows, и в то же время как родное приложение Apple Macintosh, будучи запущенным на Mac, и т. д.. Однако, некоторым разработчикам не нравится эта модель, потому что они предпочитают, чтобы их приложения выглядели одинаково на всех платформах.

AWT появилась вместе с Java в 1995 году. Компоненты AWT часто определяют термином heavyweight. В J2SE 1.2 виджеты AWT были в значительной степени заменены аналогичными из Swing.

Swing (wiki_eng, wiki_ru) —  библиотека для создания графического интерфейса. Разработана компанией Sun Microsystems. Содержит ряд графических компонентов (англ. Swing widgets), таких как кнопки, поля ввода, таблицы и т. д. Архитектура Swing разработана таким образом, что вы можете изменять «look and feel» (L&F) вашего приложения. «Look» определяет внешний вид компонентов, а «Feel» — их поведение.

Swing была представлена миру в 1997 году, как технология, призванная решить проблемы AWT. Компоненты Swing часто определяют термином lightweight.

Сравнение Swing с AWT:
Swing предоставляет более гибкие интерфейсные компоненты, чем более ранняя библиотека AWT. В отличие от AWT, компоненты Swing разработаны для одинаковой кросс-платформенной работы, в то время как компоненты AWT повторяют интерфейс исполняемой платформы без изменений. AWT же использует только стандартные элементы ОС для отображения, то есть для каждого элемента создается отдельный объект ОС (окно), в связи с чем AWT не позволяет создавать элементы произвольной формы (возможно использовать только прямоугольные компоненты), элементы управления на основе AWT всегда отображаются поверх Swing-элементов (так как все Swing компоненты отображаются на поверхности контейнера). Компоненты Swing поддерживают специфические динамически подключаемые виды и поведения (англ. plugable look-and-feel), благодаря которому возможна адаптация к графическому интерфейсу платформы (то есть к компоненту можно динамически подключить другой, специфический для операционной системы, в том числе и созданный программистом вид и поведение). Таким образом, приложения, использующие Swing, могут выглядеть как родные приложения для данной операционной системы. Основным минусом таких «легковесных» (англ. Lightweight) компонентов является относительно медленная работа. Положительная сторона — универсальность интерфейса созданных приложений на всех платформах.

Swing Tutoriall (tutorialspoint.com)

Java Swing tutorial, Java 2D tutorial и Java 2D games tutorial (zetcode.com)

Статьи на beginnersbook.com «Java Swing Tutorial for beginners» и 2 смежные — объяснение толковое, но только основы.

Страница в Java-курсе от guru99.com, посвящённая создания графического интерфейса.

Примеры создания элементов графического интерфейса с помощью технологий AWT и Swing на сайте tutorialspoint.com.

Глава, посвящённая созданию графического интерфейса с помощью технологий AWT и Swing на mathbits.com.

Электронная книга «Java Programming» на en.wikibooks.org имеет разделы, связанных с созданием графических интерфейсов.

Электронная книга «Introduction to Programming Using Java» на math.hws.edu имеет главы «Introduction to GUI Programming» и «Advanced GUI Programming»

Коммерческие:

Java Swing (GUI) Programming: From Beginner to Expert (caveofprogramming.com) — instructor John Purcell, IDE Eclipse, 29$

From description: «Learn how to create desktop and Internet GUI Java programs and take your Java programming to the next level. «
По форме обучения курс напоминает курсы на Udemy. Имеет приличную продолжительность.

=== Udemy ===
Сайт содержит ряд курсов. Все они коммерческие.
фильтр1, фильтр2, фильтр3
Из них можно отметит следующие:

— Java SE Desktop Application with Swing, JPA and Maven — created by Holczer Balazs (from Hungary), 2017, rating 4.8, Eclispse, basic price 200$
From description: «This course is meant for everyone who knows basic Java and wants to get a good grasp of professional software engineering and design.«
[8.5 hours video, 7 articles, 9 supplemental resources]

— Java Swing (GUI) Programming: From Beginner to Expert — created by John Purcell, 2015, rating 4.5, Eclispse, basic price 35$
From description: «Target audience. Java beginners who are OK with learning new stuff rapidly. Fluent Java programmers who want to learn desktop programming in Java.«
[14 hours video, 2 articles]

— Learn To Create Calculator In Java Swing — Step By Step — Intermediate, created by Mohammad Faizan, 2016, rating 4.2, Netbeans, basic price 100$
[1.5 hours video, 4 articles]

— Java basic and Swing : 2 Course Bundle — created by Eighton School (team of instructors who are actually engineers), 2018, rating -, Netbeans, basic price 100$
[14 + 6.5 hours video, 3 articles]
В первом из этих курсов имеются обширные лекции, посвящённые AWT, Java 2D и различным темам программирования для веб.
( Эти курсы также выложены отдельно под названиями
«Java SE Edition: Learn Java from the scratch» (rating 1.5 — 1 voice) и
«Java Swing for beginners: Graphical User Interface (GUI)» (rating 3.5 — 2 voices). )
P.S. По какой-то причине авторы удалили свой профиль с Udemy со всеми курсами. Курсы доступны только тем, кто приобрёл их ранее.

Standard Widget Toolkit (SWT) (wiki_eng, wiki_ru) —  библиотека с открытым исходным кодом для разработки графических интерфейсов. Разработана фондом Eclipse. SWT не является самостоятельной графической библиотекой, а представляет собой кросс-платформенную оболочку для графических библиотек конкретных платформ, например, под Linux SWT использует библиотеку GTK+. SWT написана на стандартной Java и получает доступ к OS-специфичным библиотекам через Java Native Interface, который рассматривается в качестве сильного средства, несмотря на то, что это не является чистой Java. SWT — альтернатива AWT и Swing (Sun Microsystems) для разработчиков, желающих получить привычный внешний вид программы в данной операционной системе. Использование SWT делает Java-приложение более эффективным, но снижает независимость от операционной системы и оборудования, требует ручного освобождения ресурсов и в некоторой степени нарушает Sun-концепцию платформы Java. Первый релиз SWT состоялся в 2003 году.

JavaFX (wiki_eng, wiki_ru) — платформа на основе Java. Предназначена для создания
— настольных приложений, запускаемых непосредственно из-под операционных систем;
— насыщенных интернет-приложений (англ. rich Internet applications — RIAs), работающих в браузерах;
— приложений на мобильных устройствах.
JavaFX создана с целью заменить библиотеку Swing. Платформа JavaFX конкурирует с Microsoft Silverlight, Adobe Flash и аналогичными системами.

JavaFX cоздана корпорацией Sun Microsystems. Впервые продемонстрирована в мае 2007 года. Версия 1.0 вышла в декабре 2008. Приложения JavaFX создаются с помощью декларативного языка программирования JavaFX Script. Для разработки приложений на языке JavaFX Script необходимо установить JavaFX SDK, который входит в поставку с Java SE 7. Из кода, написанного на языке JavaFX Script, можно обращаться к любым библиотекам Java. Поэтому совместное использование языков Java и JavaFX Script позволяет решать разнообразные задачи, например, логика бизнес-приложения может быть написана на Java, а графический интерфейс пользователя — на JavaFX Script.

JavaFX также может использоваться при созданий приложений на языках Groovy, Scala и JRuby.

JavaFX Tutorial (tutorialspoint.com)

JavaFX tutorial (zetcode.com)

=== Udemy ===
Сайт содержит ряд курсов. Бесплатный из них только один:
— Crash Course Into JavaFX: The Best Way to make GUI Apps  — created by Anirudh Balasubramanian, 2017, rating 4.2, Eclipse
[5 hours video, 1 articles]

Из коммерческих можно отметить следующие:

— UI-UX Design , Animation and Material Design in JavaFX — created by Mohamed Adel (from Egypt), 2018, rating 4.5, IntelliJ IDEA, basic price 200$
Не очень хорошее качество звука, присутствует фоновый шум.
[7 hours video, 13 articles]

— Build Outstanding Java Apps with JavaFX much faster — created by  Jonas Schindler, 2015, rating 4.6, Eclipse, basic price 25$
Самое крупное из создаваемых приложений — калькулятор.
[4 hours video]

— Java Web and JavaFX : 2 Course Bundle — created by Eighton School (team of instructors who are actually engineers), 2018, rating 5.0 (2 voices), Netbeans, basic price 100$
[4 + 3 hours video, 4 articles]
( Эти курсы также выложены отдельно под названиями
«Java Web Technologies: JSP, JSF, Ajax, Spring. . .» (rating 3.5 — 1 voice) и
«JavaFX for beginners:Learn JavaFX from the scratch» )
P.S. По какой-то причине авторы удалили свой профиль с Udemy со всеми курсами. Курсы доступны только тем, кто приобрёл их ранее.

— Complete Java Masterclass -Beginner, instructor Tim Buchalka and Goran Lochert, rating 4.6, IDE IntelliJ, 2018, basic price 195$
[74 hours video, 5 articles, 10 coding exercises]
Самый полный курс по Java на Udemy. Среди прочего содержит 10 часов лекций по JavaFX.

— Complete Oracle JavaFX with Database & Advance Java projects — instructor Ejike IfeanyiChukwu, rating 4.4, IDE Eclipse, 2018, basic price 50$
[13 hours video, 1 supplemental resource]

Примечания:

Java 2D (wiki_eng, wiki_ru) — это API для рисования двумерной графики.

Abstract Window Toolkit, Swing и Java 2D входят в состав набора библиотек Java Foundation Classes (JFC) (wiki_eng, wiki_ru). Этот термин появился в 1997 году.

#23 — GUI Java (Swing JFrame)

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

Для создания графического интерфейса на Java существует несколько библиотек. Мы с вами рассмотрим библиотеку Swing, которая является одной из самых популярных библиотек и позволяет создавать полноценные оконные приложения на языке Java.

Создание приложения

Создание нового окна необходимо делать в отдельных файлах, а в основном классе лишь запускать нужное окно. Поэтому, изначально создайте файл и назовите его: SimpleGUI.

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

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

Чтобы работать со многими методами, наш основной класс должен наследовать всё от класса с названием JFrame.

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

• JLabel — класс для создания объекта с надписью; 
• JTextField — класс для создания текстового поля; 
• JButton — класс для создания кнопки; 
• JCheckBox — класс для создания кнопки-галочки;
• JRadioButton — класс для создания кнопок выбора.

Разработка проекта

В Swing используются контейнеры «Container» для группировки нескольких элементов в одну форму. Перед созданием контейнера необходимо установить: название окна, его размеры и координаты (x, y, w, h), а также установили операцию при закрытии окна.

Далее создается объект на основе класса Container и прописывается метод getContentPane (). Данный метод возвращает контейнер верхнего уровня, в который помещаются все остальные объекты на окне.

Для размещения объектов стоит выбрать какой-либо слой. В уроке был использован слой GridLayout, что позволяет располагать объекты в формате сетки или же таблицы.

Добавление элементов

После создания контейнера и основного слоя, можно добавлять элементы. Все элементы создаются на основе классов, что были рассмотрены в самом начале: JLabel, JButton и так далее. Чтобы добавить элемент в контейнер используется метод add, а в качестве параметра выступает элемент, что добавляется.

Для создания выбора между radio кнопками необходимо объединить их в общую группу, таким образом переключаясь между ними они будут работать корректно.

Для отслеживания событий используется интерфейс «ActionListener». Создаем класс с реализацией интерфейса и выполняем обработку действий пользователя:

class ButtonEventListener implements ActionListener {
	public void actionPerformed (ActionEvent e) {

	}
}

Внутри метода «actionPerformed» (действие выполнено) прописывается любой код, что должен сработать по нажатию на кнопку. 

В программе что мы создавали мы прописали получение данных из полей формы и вывод данных в новом окне. Чтобы взять данные из поля необходимо использовать метод «getText» для нужного вам поля: input.getText().

Для создания всплывающего окна мы использовали класс «JOptionPane», в который поместили: объект, сообщение, название и тип диалогового окна.

Остается все это вызвать с основного класса. В основном классе мы создаем объект на основе класса, что мы создавали и вызываем метод для отображения окна с параметром true: app.setVisible(true).

Иллюстрированный самоучитель по Java › Принципы построения графического интерфейса [страница — 147] | Самоучители по программированию

Принципы построения графического интерфейса

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

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

Есть много различных графических систем: MS Windows, X Window System, Macintosh. В каждой из них свои правила построения окон и их компонентов: меню, полей ввода, кнопок, списков, полос прокрутки. Эти правила сложны и запутанны. Графические API содержат сотни функций.

Для облегчения создания окон и их компонентов написаны библиотеки классов: MFC, Motif, OpenLook, Qt, Tk, Xview, OpenWindows и множество других. Каждый класс такой библиотеки описывает сразу целый графический компонент, управляемый методами этого и других классов.

В технологии Java дело осложняется тем, что приложения Java должны работать в любой или хотя бы во многих графических средах. Нужна библиотека классов, независимая от конкретной графической системы. В первой версии JDK задачу рещили следующим образом: были разработаны интерфейсы, содержащие методы работы с графическими объектами. Классы библиотеки AWT реализуют эти интерфейсы для создания приложений. Приложения Java используют данные методы для размещения и перемещения графических объектов, изменения их размеров, взаимодействия объектов.

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

Библиотека классов Java, основанных на peer-интерфейсах, получила название AWT (Abstract Window Toolkit). При выводе объекта, созданного в приложении Java и основанного на peer-интерфейсе, на экран создается парный ему (peer-to-peer) объект графической подсистемы операционной системы, который и отображается на экране. Эти объекты тесно взаимодействуют во время работы приложения. Поэтому графические объекты AWT в каждой графической среде имеют вид, характерный для этой среды: в MS Windows, Motif, OpenLook, OpenWindows, везде окна, созданные в AWT, выглядят как «родные» окна.

Именно из-за такой реализации peer-интерфейсов и других «родных» методов, написанных, главным образом, на языке C++, приходится для каждой платформы выпускать свой вариант JDK.

В версии JDK 1.1 библиотека AWT была переработана. В нее добавлена возможность создания компонентов, полностью написанных на Java и не зависящих от peer-интерфейсов. Такие компоненты стали называть «легкими» (lightweight) в отличие от компонентов, реализованных через peer-интерфейсы, названных «тяжелыми» (heavy).

«Легкие» компоненты везде выглядят одинаково, сохраняют заданный при создании вид (look and feel). Более того, приложение можно разработать таким образом, чтобы после его запуска можно было выбрать какой-то определенный вид: Motif, Metal, Windows 95 или какой-нибудь другой, и сменить этот вид в любой момент работы.

Эта интересная особенность «легких» компонентов получила название PL&F (Pluggable Look and Feel) или «plaf.

Была создана обширная библиотека «легких» компонентов Java, названная Swing. В ней были переписаны все компоненты библиотеки AWT, так что библиотека Swing может использоваться самостоятельно, несмотря на то, что все классы из нее расширяют классы библиотеки AWT.

Библиотека классов Swing поставлялась как дополнение к JDK 1.1. В состав Java 2 SDK она включена как основная графическая библиотека классов, реализующая идею «100% Pure Java», наряду с AWT.

В Java 2 библиотека AWT значительно расширена добавлением новых средств рисования, вывода текстов и изображений, получивших название Java 2D, и средств, реализующих перемещение текста методом DnD (Drag and Drop).

Кроме того, в Java 2 включены новые методы ввода/вывода Input Method Framework и средства связи с дополнительными устройствами ввода/вывода, такими как световое перо или клавиатура Бройля, названные Accessibility.

Все эти средства Java 2: AWT, Swing, Java 2D, DnD, Input Method Framework и Accessibility составили библиотеку графических средств Java, названную JFC (Java Foundation Classes).

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

инструмент для автоматического тестирования графического интерфейса Java-приложений – тема научной статьи по компьютерным и информационным наукам читайте бесплатно текст научно-исследовательской работы в электронной библиотеке КиберЛенинка

УДК 004.416.2

П. А. Садовников, А.Ю. Дроздов, Ю.Н. Фонин

Дизайн-центр Московского физико-технического института (государственного университета)

Jubula: инструмент для автоматического тестирования графического интерфейса Java-приложений

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

Ключевые слова: тестирование, автоматизация, графический интерфейс, GUI, Java.

P. A. Sadovnikov, A. Yu. Drozdov, Yu.N. Fonin

Design Center of the Moscow Institute of Physics and Technology

Jubula: instrument for automated Java-application’s GUI

testing

This article relates an experience of using the environment for automated testing of Java-application’s graphical interface. At the beginning a list of necessary properties, an instrument for GUI testing and a review of several similar instruments are provided. Most of the article is devoted to intrinsic organisation and features of Jubula, the most advanced and extraordinary system among the candidates. Means of keeping and conducting tests, displaying their results and other testing tools integration capabilities are examined. In conclusion, it is shown in which cases one should use this instrument.

Key words: testing, automatisation, graphical interface, GUI, Java. Введение

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

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

На этом этапе отлавливаются:

• грубые ошибки: отсутствие, недоступность или полная неработоспособность некоторых элементов,

• исключения при передаче данных от графического интерфейса к логике: отсутствие валидации данных, искажение или потеря информации,

• ошибки локализации: неправильные надписи,

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

С этой проблемой столкнулась наша организация, разрабатывающая плагин для Eclipse. Потребовался инструмент, с помощью которого мы могли бы проверять показатели среды разработки после проведения определённых манипуляций, в частности значения регистров. Работа выполнена при поддержке Министерства образования и науки в рамках договора № 02.G25.31.0061 от 12 февраля 2013 года (в соответствии с Постановлением Правительства Российской Федерации от 9 апреля 2010 г. № 218).

Хотя исходный код Eclipse доступен, тестировать его «изнутри» было бы чрезвычайно трудоёмко, поэтому был необходим продукт с возможностью работать в режиме «чёрного ящика», без явного внедрения в код. Разумеется, проверка графического интерфейса связана со многими другими особенности [1]:

• Внутренняя логика приложения обычно хорошо поддаётся модульному тесту. К сожалению, это неверно для GUI. Невозможно протестировать кнопку или контекстное меню в отрыве от всего остального интерфейса.

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

• Откуда, в свою очередь, следует, что тесты должны следовать типичным операциям пользователя. Они описываются в спецификациях, которые впоследствии редактируются на основе отзывов тестировщиков.

• Желательно, чтобы средство автоматического тестирования поддерживало парадигмы Test Driven Development и Data Driven Development.

• В случае обнаружения ошибки инструмент должен недвусмысленно сообщать её причину. Например, если при нажатии кнопки текст в текстовом поле не изменился, это может вызываться разными причинами: не выполнены внешние условия, кнопка была неактивна, поле стало недоступно или программа вовсе зависла.

Обзор автоматических средств тестирования

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

• Abbot

• AutoIt

• HP WinRunner

• Jemmy

• Jubula/GUIdancer

• Ranorex

• Robotframework

• Sikuli

• SilkTest

• SwingLibrary Demo

• SWTBot

Test CompleteSilkTest, Test Complete, HP WinRunner и Robotframework были отброшены сразу, так как хоть и имеют великолепный набор функций и подходят для тестирования чего угодно, но платны и довольно дороги.

Abbot, Jemmy и SwingLibrary Demo — вовсе не отдельные утилиты для тестирования, а open-source библиотеки. Они удобны для проверки отдельных компонентов будущего приложения на стадии разработки, но обработать с их помощью уже готовый продукт довольно трудоёмко. Ни одна из этих библиотек не поддерживает режим «чёрного ящика» и не предоставляет тестировщику удобный интерфейс для записи тестов и отслеживания результатов. Кроме того, в каждой из них не хватает поддержки определённых графических библиотек Java. Ranorex к тому же слишком ориентируется на простое воспроизведение тестов, записанных при помощи рекордера.

AutoIt хорошо подходит для автоматизации приложений c графическим интрефейсом, а также славится простым Basic-подобным синтаксисом, но не обладает встроенной ва-лидацией данных. Плюс тесты в этом инструменте сложно поддаются структуризации. Недостаёт и интеграции со внешними средствами.

SWTBot плагин/библиотека была хорошим кандидатом. По ней есть документация и живая ветка форума. Тесты можно писать как кодом, так и рекордером. Кроме того, SWTBot обладает несколькими режимами тестирования, в том числе и с использованием встроенного отладчика. Является, по сути, надстройкой JUnit. Однако, во-первых, иногда отказывается воспроизводить свои же записанные тесты, во-вторых, нестабилен, в-третьих, требует доступ к исходному коду тестируемого приложения.

Из оставшихся был выбран Jubula, бесплатный аналог GUIdancer благодаря следующим достоинствам [2]:

• быстрое обучение,

• два режима работы: рекордер тестов и конструктор,

• бесплатная (открытый исходный код),

• большой help-файл,

• быстро ставится, всё из коробки,

• кросс-платформенная,

• обновляется.

Из недостатков следует отметить малую известность и отсутствие представления тестов в виде кода: тесты представлены в виде «кирпичиков» конструктора. Однако понятный даже для рядового пользователя интерфейс, система рефакторинга тестов и служба разметки элементов GUI делает работу намного легче. Более того, разработку тестов в конструкторе можно отрядить даже новичку в программировании, так как конструктор не требует ни строчки кода.

Обзор конкретных свойств Jubula Общая информация

Изначально компания BREDEX поддерживала два инструмента тестирования: Jubula с открытым исходным кодом и платный GUIdancer с дополнительными возможностями [3]. С самого появления эти инструменты заслужили популярность в сообществе

Eclipse Foundation, что выразилось в награде «лучший коммерческий продукт для разработки» в 2010 году [4]. В связи с переходом BREEDEX на бизнес-модель предоставления услуг вместо программ, с 2015 года GUIdancer окончательно отправился в архив, а Jubula поглотила все его возможности. Теперь этот инструмент поддерживает не только разнообразные Java-графические приложения, основанные на технологиях Swing, SWT/RCP/GEF, JavaFX, но и программы, созданные для .NET и iOS. Существует как автономная версия продукта, так и версия в виде плагина к Eclipse. Мы использовали Jubula как отдельный продукт, так как этот вариант стабильнее и предоставляет больше возможностей для точной настройки и получения информации из тестов.

Таблица1

Краткое сравнение инструментов тестирования по общим признакам

Инструмент Платный Справка Обучение Обновление Баги

SilkTest да много легко часто мало

HP WinRunner да много средне часто мало

Robotframework да много легко часто мало

Ranorex да много средне часто мало

Abbot нет мало сложно редко средне

Jemmy нет мало сложно редко средне

SWTBot нет мало средне редко много

SwingLibrary нет мало сложно часто средне

AutoIt нет средне средне редко средне

Ranorex нет средне легко часто средне

Jubula нет средне легко часто средне

Такое разнообразие продуктов тестирования вкупе с возможностью обращаться к внутренним свойствам графических компонентов поддерживается, возможно, благодаря способу взаимодействия с тестируемой программой. Например, для поддержки классов Rich Client Platform Jubula использует специальную библиотеку, обеспечивающую перехваты обращений к ним (также известны среди программистов как хуки/hooks). Её достаточно добавить в папку библиотек тестируемого приложения и отметить в конфигурации, а при релизе продукта — так же легко убрать.

Для подключения к приложению Jubula использует AUT agent (AUT — application under test, тестируемое приложение), специальную подпрограмму-демона, обеспечивающую TCP/IP-мост между исполнителем задач и объектом испытаний. Такая структура позволяет проводить распределённое тестирование, а также взаимодействовать с другими сервисами и инструментами, призванными облегчить жизнь программиста.

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

Рис. 1. Настройка процедуры тестирования. Показано меню, позволяющее указать переменную информацию, передаваемую в подтест

Отсутствие кода также позволяет решить проблему с программированием методом копировать-вставить, бичом многих разработчиков. В Jubula используется принцип «переиспользование вместо копирования»: попросту нельзя склонировать несколько действий в другое место. Вместо этого используется метод Extract Test Case: выделенные действия переносятся в отдельную процедуру. Её свойства можно настроить таким образом, чтобы некоторая информация передавалась извне, как аргументы в функцию в классических языках программирования.

В Jubula нет выражений if или for [5]. Можно выполнить assert или проверку для каждого элемента из набора, но в явном виде инструкции ветвления и цикла недоступны. Это ещё одна непривычная вещь, с которой сталкивается программист при первом знакомстве с Jubula. С другой стороны, благодаря отсутствию рекурсивного вызова подтестов и бесконечных циклов, тест не может выполняться вечно, какой бы неудачной не была очередная версия GUI.

Существует также альтернативный способ создания тестов: рекордер. Специальная подпрограмма запускается вместе с AUT и записывает все действия тестировщика в отдельную процедуру. Подобный способ удобен, но документация предостерегает от его использования. Такие тесты намного сложнее поддерживать, теряются многие преимущества «конструк-торного» подхода.

На случай, если средствами Jubula никак не обойтись, предусмотрена возможность запуска внешних программ. Таким же способом во время прохождения теста можно вывести дополнительную информацию в консоль или лог-файл. во время воспроизведения записанного теста не смогла найти определённый объект, она попытается использовать эвристические методы, чтобы всё-таки продолжить тест.

Рис. 2. Режим нанесения на карту. В правом нижнем углу можно видеть AUT — Eclipse с тестируемым плагином. Зелёная рамка вокруг консоли означает, что этот объект можно отмаркировать. Сверху-слева расположен длинный список уже соотнесённых элементов, список распознанных элементов, которым ещё не были сопоставлены внутренние имена (выделен красным) и список имён без элементов (пуст)

Объекты можно начать маркировать ещё задолго до того, как будет написана логика их действия, поэтому нет практически никаких ограничений на парадигму Test Driven Development.

Как сами тесты, так и данные для них хранятся в специальной внутренней базе данных [6]. При желании её можно изменить на внешнюю, удобную для отдела тестирования. Таким образом, несколько человек стандартными SQL-средствами могут независимо добавлять новые тестовые данные и выполнять поиск с фильтрами, чтобы проверить, не дублируют ли они работу друг друга. Как и большинство других инструментов, Jubula придерживается парадигмы DDT (Data Driven Testing): данные для проверки не «вшиты» в тест, а поставляются в виде отдельного набора. Такой подход позволяет не создавать однотипные тесты, а повторять одну и ту же процедуру для всех данных из множества.

Кроме того, благодаря ациклической структуре тестов их можно экспортировать в XML-формате, чтобы перенести на компьютер без доступа к Интернету или поделиться

ими в Интернете. Благодаря такому платформонезависимому представлению, а также тому, что Jubula написана на Java, можно ожидать, что результаты тестов не будут зависеть от операционной системы, на которой они проводятся.

Выполнение тестов и получение их результатов

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

По умолчанию при провале теста или проверки внутри него проведение всех тестов останавливается. Обычно это нежелательно. Чтобы восстановиться после сбоя, используется Event Handler, обработчик внештатной ситуации [7]. Например, если исполнитель тестов не сумел найти компонент, можно указать несколько типов поведения: продолжить выполнение, тщательнее попытаться ещё раз, начать следующий тест или поставить всё на паузу до вмешательства человека, возможно, с какими-то дополнительными действиями.

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

Таблица2

Сравнение двух подходов к обработке исключений

Начало теста

Начало теста

Действие 1

Действие 1

Действие 2

Ошибка

Действие 2

Ошибка

I

Действие 3

Процедура восстановления

Действие 3

Процедура сброса

Действие 4

Действие 4

Завершение

Завершение

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

По умолчанию результаты просто отображаются внутри ЛиЪи1а. При провале показывается причина и скриншот программы в момент сбоя. Также можно организовать хранение

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

• Интеграция с JIRA+Jenkins позволяет отслеживать, кто и когда создал или должен покрыть тестами определённый функционал. Встроенные меню позволяют заходить в репозиторий задач прямо из Jubula или добавлять новую задачу прямо из окна с результатами тестов [8, 9].

• BIRT позволяет вывести историю прохождения тестов и множество полезных графиков, показывающих, как развивался проект.

• Jacoco позволяет узнать процент покрытия кода тестами и различную информацию о «нагрузке» на различные ветви в программе [10].

Заключение

Тогда как крупной организации лучше выбрать платный продукт, Jubula может быть оптимальным инструментом для небольшой компании, занимающейся разработкой Java-приложений. Для бесплатного инструмента с открытым исходным кодом Jubula обладает всеми необходимыми особенностями для тестирования GUI и поддерживает большое количество других возможностей. Она позволяет даже в отсутствие полноценного отдела тестирования срочно перебросить людей на проверку кода, добавить в систему отслеживания проблем новые задачи или быстро сформировать отчёт по результатам теста. Система маркирования объектов позволяет писать тесты вперёд кода, что тоже ценно для маленьких компаний. Время, пока согласуются отдельные детали внутренней работы приложения, не тратится впустую.

Среди недостатков хотелось бы отметить некоторую неотлаженность и непривычный интерфейс самой Jubula. Кроме того, настораживает отсутствие циклов и ограниченное использование условных операторов. Без них сложно реализовать, например, нагрузочное тестирование, для которого, впрочем, есть специальные утилиты. На больших проектах образуется сложная иерархия тестовых задач, так что для многолетней разработки лучше выбрать что-то другое.

Работа выполнена при поддержке Министерства образования и науки в рамках договора № 02.G25.31.0061 от 12 февраля 2013 года (в соответствии с Постановлением Правительства Российской Федерации от 9 апреля 2010 г. № 218).

Литература

1. Reminnyi O. Functional GUI Testing Automation Patterns [Электронный ресурс] // infoq URL: http://www.infoq.com/articles/gui-automation-patterns (дата обращения: 22.07.15).

2. Jubula Features Testtool review [Электронный ресурс] // infoq URL: https://www.testtoolreview.de/en/testtool-overview/tool-list/tooldetail/479-jubula/ (дата обращения: 22.07.15).

3. BREDEX company site [Электронный ресурс] // BREDEX URL: http://testing.bredex.de/ (дата обращения: 22.07.15).

4. Eclipse Awards Winners [Электронный ресурс] // infoq URL: http://www.infoq.com/news/2010/03/eclipse-awards/ (дата обращения: 22.07.15).

5. Vogel J. Jubula Summary [Электронный ресурс] // eclipse URL: http://www.eclipse.org/forums/index.php/t/302031/ (дата обращения: 22.07.15).

6. Eclipse Jubula Database [Электронный ресурс] // eclipse URL: http://marketplace.eclipse.org/content/eclipse-jubula-database-drivers (дата обращения: 22.07.15).

7. Dealing With Errors In Tests: Event Handlers [Электронный ресурс] // eclipse URL: http://help.eclipse.org/juno/index.jsp?topic=/%2Forg.eclipse.jubula. client.ua.help/%2Fhtml/%2Fmanual/%2Fnode214.html (дата обращения: 22.07.15).

8. Automating Eclipse Jubula Tests with Jenkins [Электронный ресурс] // devnotesblog URL: https://devnotesblog.wordpress.com/2011/06/14/automating-eclipse-jubula-tests-with-jenkins/ (дата обращения: 22.07.15).

9. UI Tests Say More With JIRA + Jubula [Электронный ресурс] // atlassian URL: http://blogs.atlassian.com/2013/11/guest-blog-ui-tests-say-more-with-jira-jubula/ (дата обращения: 22.07.15).

10. Jacoco [Электронный ресурс] // eclemma URL: http://www.eclemma.org/jacoco/ (дата обращения: 22.07.15).

References

1. Reminnyi O. Functional GUI Testing Automation Patterns [Internet resource] // infoq URL: http://www.infoq.com/articles/gui-automation-patterns (visited: 22.07.15).

2. Jubula Features Testtool review [Internet resource] // infoq URL: https://www.testtoolreview.de/en/testtool-overview/tool-list/tooldetail/479-jubula/ (visited: 22.07.15).

3. BREDEX company site [Internet resource] // BREDEX URL: http://testing.bredex.de/ (visited: 22.07.15).

4. Eclipse Awards Winners [Internet resource] // infoq URL: http://www.infoq.com/news/2010/03/eclipse-awards/ (visited: 22.07.15).

5. Vogel J. Jubula Summary [Internet resource] // eclipse URL: http://www.eclipse.org/forums/index.php/t/302031/ (visited: 22.07.15).

6. Eclipse Jubula Database [Internet resource] // eclipse URL: http://marketplace.eclipse.org/content/eclipse-jubula-database-drivers (visited: 22.07.15).

7. Dealing With Errors In Tests: Event Handlers [Internet resource] //

eclipse URL: http://help.eclipse.org/juno/index.jsp?topic=/%2Forg.eclipse.jubula. client.ua.help/%2Fhtml/%2Fmanual/%2Fnode214.html (visited: 22.07.15).

8. Automating Eclipse Jubula Tests with Jenkins [Internet resource] // devnotesblog URL: https://devnotesblog.wordpress.com/2011/06/14/automating-eclipse-jubula-tests-with-jenkins/ (visited: 22.07.15).

9. UI Tests Say More With JIRA + Jubula [Internet resource] // atlassian URL: http://blogs.atlassian.com/2013/11/guest-blog-ui-tests-say-more-with-jira-jubula/ (visited: 22.07.15).

10. Jacoco [Internet resource] // eclemma URL: http://www.eclemma.org/jacoco/ (visited: 22.07.15).

Поступила в редакцию 12.10.2015.

Библиотека Swing . Графические интерфейсы пользователя Java

Графическая библиотека Swing была создана на основе библиотеки AWT для решения таких проблем AWT как недостаточный выбор графических компонентов и зависимость внешнего вида и поведения AWT графического интерфейса пользователя от конкретной операционной системы.

Эти проблемы были решены созданием классов и интерфейсов библиотеки Swing с использованием одного только языка Java.

Компоненты AWT являются тяжеловесными, в то время как компоненты Swing являются легковесными.

Библиотека AWT использует нативный код (код, специфичный для конкретной операционной системы) для отображения компонентов.

Каждая реализация среды выполнения Jave Runtime Environment должна обеспечивать собственные реализации кнопок, меток, панелей и всех других компонентов AWT.

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

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

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

Прежде чем AWT компонент будет сначала нарисован на экране, будет создан его пир.

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

Например, когда Java рисует метку, она не просто рисует строку в нужном месте на экране.

Она создает пир и помещает его на экран.

В свою очередь компоненты Swing используют пиры для двух задач.

Во-первых, Swing компоненты JFrame, JWindow, JDialog и JApplet расширяют свои AWT-аналоги.

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

Другие компоненты Swing легковесные; у них нет пиров.

Эти компоненты отрисовывают себя поверх существующих JFrame, JWindow, JDialog или JApplet.

И поэтому на самом деле они также неявно используют пиры.

В AWT библиотеке использование пиров значительно затрудняло создавать подклассы этих компонентов для изменения их поведения.

Потому что их поведение исходит от нативного пира и поэтому не может быть легко переопределено или расширено.

Далее, наличие нативного кода значительно затрудняет перенос Java на новую платформу.

Проще говоря, хотя сам язык Java был кросс-платформенным, библиотека AWT была его ахиллесовой пятой.

Наконец, нативные пиры потребляют много ресурсов.

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

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

Решением было создание легковесных компонентов библиотеки Swing, которые полностью написаны на Java, и поэтому не требуют прямого использования нативного кода.

Легковесный компонент – это просто компонент, полностью реализованный на Java.

Для создания легковесного компонента достаточно расширить AWT класс Component или Container напрямую, реализуя внешний вид компонента на Java, а не делегируя внешний вид пиру.

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

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

В библиотеке AWT для создания совершенно нового компонента вам нужно было бы расширять класс Canvas.

Легковесному компоненту достаточно расширить класс Component или Container.

Когда легковесный компонент помещается в контейнер, он не получает нативный пир.

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

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

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

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

Метод setBackground легковесного компонента, просто расширяющего класс Component, не работает, так как всю работу по изображению кнопки на экране выполняет не peer-двойник компонента, а тяжеловесный контейнер, в котором расположен компонент.

Контейнер ничего не знает о том, что надо обратиться к методу setBackground, он рисует только то, что записано в методе paint.

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

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

Предпочтительный размер тяжеловесного компонента устанавливается peer-объектом, поэтому для легковесных компонентов его надо задать явно, переопределив метод getPreferredSize, иначе некоторые менеджеры компоновки, например FlowLayout (), установят нулевой размер, и компонент не будет виден на экране.

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

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

Библиотека Swing составляет основную часть библиотеки JFC (Java Foundation Classes), которая объединяет классы и интерфейсы, обеспечивающие интерфейс пользователя Swing-компонентами, выбор внешнего вида и поведения интерфейса, поддержку технологий для людей с ограниченными возможностями, работу с высококачественной двухмерной графикой, текстом и изображениями, а также интернационализацию графического интерфейса пользователя.

В настоящее время библиотека Swing входит в набор настольных Java-технологий.

Все классы Swing-компонентов являются наследниками базового класса JComponent пакета javax. swing.

При конструировании Swing-интерфейса компоненты помещаются в контейнеры, образующие иерархию, которая берет свое начало от контейнеров верхнего уровня, представленных классами JApplet, который уже запрещен, JDialog, JFrame и JWindow.

Основные свойства графической библиотеки Swing можно суммировать как:

Кроссплатформенность.

Механизм сменного внешнего вида и поведения компонентов (pluggable look and feel).

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

Расширяемость за счет возможности расширения классов и интерфейсов библиотеки.

Архитектура Swing-компонентов основана на технологии Java Beans.

Возможность настройки внешнего вида Swing-компонентов за счет изменения свойств таких элементов компонентов как рамки, цвет, фон и др.

Легковесность.

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

Компоненты Swing представляют собой области в окне, характеризующиеся координатами и размером, при этом они не работают напрямую с операционной системой, их отображение основывается на реализации Java 2D API, поэтому их называют легковесными.

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

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

Использование библиотеки Swing не является потоково-безопасной.

Доступ к Swing-компонентам должен осуществляться в специальном потоке Event Dispatch Thread (EDT).

Поддержка технологий для людей с ограниченными возможностями.

Снабжение компонентов всплывающими подсказками и механизмом управления клавиатурой.

Возможность настройки текста, отображаемого Swing-компонентами с помощью HTML-тэгов.

С помощью разметки HTML, компоненты могут отображать многострочный, многошрифтовый текст с использованием простого форматирования HTML.

Чтобы отобразить форматированный текст, нужно просто указать строку текста HTML, которая начинается с тега <HTML>.

Возможность отображения иконок Swing-компонентами.

Реализация модели MVC (Model-View-Controller) – модели отделения данных от внешнего вида и поведения интерфейса.

Многие Swing-компоненты имеют связанные с ними интерфейсы (Model), которые отвечают за доступ к данным и генерацию событий, связанных с изменением данных.

Архитектура MVC (модель – вид – контроллер) – это объектно-ориентированная архитектура пользовательских интерфейсов, состоящая из трех частей.

Модель предназначена для хранения, изменения и получения данных графического компонента.

Вид представляет данные на экране.

Контроллер обеспечивает реакцию модели и вида в ответ на действия пользователя.

Архитектура MVC реализована в библиотеке Swing в виде архитектуры с разделенной моделью, состоящей из двух, а не из трех частей.

Вид и контроллер, в архитектуре Swing, объединены вместе в один элемент – представителя пользовательского интерфейса (delegate UI).

Класс графического компонента связывает модель и представителя с помощью менеджера пользовательского интерфейса (UIManager), который определяет внешний вид и поведение интерфейса (Look and Feel).

Именно поэтому библиотека Swing имеет подключаемую архитектуру look-and-feel.

Таким образом, для реализации модели MVC библиотека Swing использует делегирование (delegation) полномочий, назначая в качестве модели данных представителя (delegate) – экземпляр класса с именем вида xxxModel.

Класс библиотеки Swing содержит защищенное или даже закрытое поле model – объект этого класса-модели, и метод getModel, предоставляющий разработчику доступ к полю model.

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

Swing класс JComponent содержит защищенное поле ui – экземпляр класса-представителя ComponentUI из пакета javax.swing.plaf, непосредственно отвечающего за вывод изображения на экран в нужном виде.

Класс-представитель содержит методы paint и update, формирующие и обновляющие графику компонента.

Такие представители образуют целую иерархию с общим суперклассом ComponentUI.

Они собраны в пакет javax.swing.plaf и его подпакеты.

В их именах есть буквы UI (User Interface), например, ButtonUI.

Представители класса тоже являются полями класса Swing компонента, и доступ к ним осуществляется методами вида getUI.

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

В большинстве случаев достаточно обращаться к методам самого класса компонента.

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

Новая модель данных устанавливается методом setModel (xxxModel).

Для создания графического интерфейса пользователя с использованием библиотеки Swing в среде разработки IntelliJ IDEA, нужно нажать правой кнопкой мышки на пакете приложения и выбрать New – GUI Form.

Ввести имя класса и нажать OK.

В результате будет создан Java класс и его XML описание с расширением. form, которое открывается в визуальном редакторе, позволяя визуально создавать и редактировать GUI интерфейс.

Первоначально форма состоит только из контейнера JPanel.

Для дальнейшей работы с GUI интерфейсом, нужно в поле field name ввести имя этого компонента.

При желании можно изменить компоновку компонента.

Далее нужно открыть связанный с формой Java класс и в коде класса нажать правой кнопкой мыши и выбрать Generate – Form main ().

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

А именно, будет сгенерирован метод main, в котором будет создано окно верхнего уровня JFrame.

И в это окно будет добавлена панель формы.

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

При этом по умолчанию в Java класс будут добавляться только соответствующие поля.

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

Изменить это можно в настройках File | Settings | Editor | GUI Designer, выбрав опцию Java source code.

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

Для добавления слушателя к компоненту, нужно нажать правой кнопкой мыши на компоненте и выбрать Create Listener.

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

Если у вас есть поля в Swing компоненте, которые вы хотите связать с данными класса JavaBean, нужно нажать правой кнопкой мыши на компоненте и выбрать Data Binding Wizard.

Дальше следовать подсказкам.

В результате будет сгенерирован Plain Old Java Object класс.

И будет сгенерирован код, связывающий Plain класс с GUI компонентом.

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

Для этого нужно нажать на поле Client Properties.

И открыть окно свойств.

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

С выбранным классом в левой панели нажмите кнопку + на правой панели.

И добавьте свойство.

Данный текст является ознакомительным фрагментом.

Продолжение на ЛитРес

Создание графического интерфейса пользователя с помощью JFC / Swing (Учебники по Java ™)

Также известен как The Swing Tutorial

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

Начало работы с Swing — это урок для быстрого старта. Во-первых, он дает вам немного информации о Swing.Затем в нем рассказывается, как компилировать и запускать программы, использующие компоненты Swing.

Изучение Swing с помощью IDE NetBeans — это самый быстрый и простой способ начать работу с Swing. В этом уроке исследуется построитель графического интерфейса IDE NetBeans — мощная функция, позволяющая визуально создавать свои графические пользовательские интерфейсы.

Использование компонентов Swing рассказывает вам, как использовать каждый из компонентов Swing — кнопки, таблицы, текстовые компоненты и все остальное. Здесь также рассказывается, как использовать границы и значки.

Параллелизм в Swing обсуждает параллелизм в применении к программированию Swing. Информация о потоке отправки событий и классе SwingWorker включена.

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

Компоновка компонентов в контейнере рассказывает вам, как выбрать менеджер компоновки, как использовать каждый из классов менеджеров компоновки, предоставляемых платформой Java, как использовать абсолютное позиционирование вместо менеджера компоновки и как создать свой собственный макет. управляющий делами.

Изменение внешнего вида рассказывает вам, как указать внешний вид компонентов Swing.

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

Написание прослушивателей событий сообщает вам, как обрабатывать события в ваших программах.

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

Другие маршруты, связанные с пользовательским интерфейсом

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

• 2D-графика, описывающая функции 2D-графики, доступные в JDK.
• Звук, в котором обсуждаются звуковые возможности, доступные в JDK.
• Апплеты Java, описывающий API, доступный только для апплетов.
• Основные классы, охватывающие множество тем, включая свойства и стандартные потоки ввода-вывода.
• Документация JavaFX, в которой описывается, как создавать пользовательские интерфейсы с помощью JavaFX.
• Бонусная тропа содержит
  Полноэкранный эксклюзивный режим API, урок, в котором описывается, как использовать API, представленный в v1.4, для визуализации графики непосредственно на экране.

Разработка графического интерфейса Java

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

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

Типовые элементы

Графический интерфейс пользователя включает в себя ряд элементов пользовательского интерфейса — что означает просто все элементы, которые отображаются, когда вы работаете в приложении. Они могут включать:

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

Графические интерфейсы Java: Swing и JavaFX

Java включила Swing, API для создания графических интерфейсов пользователя, в стандартную версию Java, начиная с Java 1.2 или 2007. Он разработан с модульной архитектурой, так что элементы легко подключаются и могут быть настроены. Java-разработчики уже давно предпочитают этот API при создании графических интерфейсов пользователя.

JavaFX также существует уже давно — Sun Microsystems, которая владела Java до нынешнего владельца Oracle, выпустила первую версию в 2008 году, но на самом деле она не набирала обороты, пока Oracle не приобрела Java у Sun.

Oracle намеревается в конечном итоге заменить Swing на JavaFX. Java 8, выпущенная в 2014 году, была первым выпуском, включившим JavaFX в основной дистрибутив.

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

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

Дизайн и удобство использования

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

Например, является ли приложение интуитивно понятным и легким в навигации? Сможет ли ваш пользователь найти то, что ему нужно, в ожидаемых местах? Будьте последовательны и предсказуемы в том, где вы размещаете вещи — например, пользователи знакомы с элементами навигации на верхних панелях меню или на левой боковой панели. Добавление навигации на правой боковой панели или внизу только усложнит работу с пользователем.

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

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

Введение в программирование JFC и GUI на Java

В этом руководстве обсуждаются основы программирования с графическим интерфейсом пользователя (GUI) и базовые классы Java или JFC в Java:

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

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

=> Отметьте здесь, чтобы увидеть A – Z учебных пособий по Java.

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

Что такое графический интерфейс пользователя в Java

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

Мы можем использовать эти компоненты для взаимодействия с системой или даже с внешним миром. Java предоставляет множество API и классов многократного использования, с помощью которых мы можем разрабатывать приложения с графическим интерфейсом. Один из старейших наборов, предоставляемых Java, — это «Abstract Windowing ToolKit» или AWT. Все новые API или компоненты, такие как Swing; JavaFX и т. Д. Основаны на этом AWT.

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

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

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

Фреймворки

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

Java предоставляет следующие основные платформы.

Java предоставляет следующие структуры для программирования графического интерфейса пользователя:

1. Abstract Windowing Toolkit: Это самый старый фреймворк в Java, впервые представленный в JDK 1.0. Большинство компонентов AWT теперь устарели и заменены компонентами Java Swing.
2. Swing API: Это набор графических библиотек, разработанных на основе AWT framework и являющихся частью Java Foundation Classes (JFC). Swing имеет модульную архитектуру, в которой мы можем использовать plug-and-play для компонентов.
3. JavaFX: Последняя версия фреймворка доступна начиная с Java 8.

Существуют различные сторонние графические среды, такие как Standard Widget Toolkit (SWT) Eclipse или Google Web Toolkit (GWT), используемые на Android.

Базовые классы Java (JFC)

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

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

JFC содержит классы из пакетов java.awt и javax.swing. Помимо этого, он также содержит классы, связанные с Java 3D, Java 2D, Java Accessibility и т. Д.JFC синхронизирован с объектной и компонентной моделью Java и поэтому прост в использовании.

На следующей схеме показаны различные компоненты JFC.

Как показано выше, JFC содержит классы AWT, а также классы Swing. Мы обсудим каждый из них в ходе изучения руководств по Java AWT и Java Swing. JFC также предоставляет различные методы, которые мы можем использовать в нашем приложении.

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

Теперь давайте перейдем к обсуждению компонентов графического интерфейса на общем уровне.Затем в наших последующих руководствах мы конкретно обсудим пакеты AWT и Swing и их компоненты.

Компоненты окна

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

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

Эти оконные компоненты выглядят следующим образом:

• Информационные элементы: Элементы или компоненты, которые предоставляют нам такую ​​информацию, как ярлыки, значки, баннеры или диалоговые окна сообщений.
• Элементы управления вводом: Текстовые поля, кнопки, раскрывающиеся списки, флажки, переключатели и т. Д. Являются элементами управления вводом, которые позволяют нам считывать данные от пользователя.
• Навигационные компоненты: Компоненты, такие как меню, боковые панели, хлебные крошки и т. Д., Помогают нам перемещаться по приложению.

Давайте теперь опишем некоторые важные компоненты в графическом интерфейсе.

Фрейм

в Java

Рамка — это графическое окно, видимое на экране.Фрейм можно рассматривать как компонент, но поскольку он формирует физическое окно, которое мы можем видеть на экране, он обрабатывается иначе, чем другие компоненты. Фрейм может иметь другие графические компоненты, такие как кнопки, текстовые поля и т. Д., А также панели.

Frames также имеют методы, которые не поддерживаются другими компонентами. «Java.awt.Frame» представляет класс в AWT, а JFrame — это класс, содержащийся в пакете Java Swing, который представляет фрейм.

Таким образом, любое приложение с графическим интерфейсом пользователя будет начинаться с создания объекта JFrame, который формирует главное окно.После создания объекта JFrame мы можем установить для его свойства visible значение true, вызвав setVisible («true»). Затем мы можем перетащить другие компоненты в этот фрейм.

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

На следующем рисунке показано типичное окно фрейма в редакторе графического интерфейса.

Как видно из рисунка выше, самое внешнее окно в редакторе дизайна (помечено меньшей красной стрелкой) — это рамка.Внутри этого фрейма у нас есть различные другие компоненты или дочерние компоненты фрейма.

Это видно на панели слева, которая показывает древовидную структуру компонентов. Как отмечено большой красной стрелкой, JFrame является корневым компонентом, а все остальные компоненты — его дочерними компонентами.

JPanel в Java

Контейнер JPanel является частью пакета Swing в Java. JPanel хранит группу компонентов. JPanel организовал компоненты, используя заданный им макет.Различные макеты могут помочь JPanel лучше организовать компоненты.

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

На следующем изображении показан простой пример панели внутри рамки.

Как показано выше, контейнер Panel встроен в контейнер окна Frame.У нас может быть одна или несколько панелей или даже панель внутри панели. Затем мы можем применить к панели любой менеджер компоновки, который организует компоненты или элементы внутри панели. Диспетчер компоновки по умолчанию для JPanel — «FlowLayout».

Макеты графического интерфейса пользователя в Java

Java-контейнер использует автоматическое расположение компонентов на экране. Но о размере и расположении компонентов заботится «менеджер по расположению». Диспетчер компоновки устанавливается для контейнера во время разработки. Его также можно изменять динамически.

Общие макеты, используемые в графическом интерфейсе Java:

# 1) BorderLayout

Компоновка границы делит компонент на 5 областей, как показано ниже.

Из них 4 области, а именно «Север», «Юг», «Восток» и «Запад», не могут быть изменены. Размер области «Центр» можно изменять. Обратите внимание, что каждая область имеет ограничение только одним компонентом, и панели могут использоваться для хранения нескольких компонентов.

# 2) FlowLayout: Этот макет используется для хранения нескольких компонентов.Несколько компонентов расположены горизонтально, и они оборачиваются, если ширина контейнера исчерпана. Кроме того, компоненты отображаются в порядке слева направо.

# 3) BoxLayout: При использовании блочного макета компоненты располагаются либо вертикально, либо горизонтально. Такое расположение макета коробки не зависит от размера контейнера. Компоненты в контейнере устанавливаются таким образом, чтобы они заполняли контейнер и имели одинаковые размеры.

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

Часто задаваемые вопросы

Q # 1) Что такое программирование GUI?

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

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

Q # 2) Какой графический интерфейс использовать с Java?

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

• JavaFX.
• Swing GUI Java.
• AWT: набор абстрактных окон.
• SWT — Стандартный набор инструментов виджетов.
• Apache Pivot.
• SwingX.
• JGoodies.
• QtJambi.

Q # 3) Каковы преимущества графического интерфейса пользователя?

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

Q # 4) Что такое JavaFX API?

Ответ: JavaFX — это последняя библиотека Java, написанная на собственном Java-коде и содержащая классы и интерфейсы. JavaFX можно использовать для разработки приложений с графическим интерфейсом пользователя в версиях Java, более поздних, чем Java 8.

Q # 5) Подходит ли Java для графического интерфейса пользователя?

Ответ: Хотя в Java есть больше инструментов для разработки приложений с графическим пользовательским интерфейсом, а также лучшая поддержка, она не такая быстрая и эффективная, как библиотека MFC C ++, которая имеет почти все функции для разработки расширенных приложений с графическим интерфейсом.

Заключение

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

=> Отметьте ВСЕ учебные пособия по Java здесь.

Программирование событий графического интерфейса пользователя Java

Разработка графического интерфейса Java с использованием SWT / Swing в MyEclipse

1. Что такое SWT / Swing Designer?

SWT / Swing Designer — это конструктор графического интерфейса пользователя Java, который упрощает создание приложений графического интерфейса пользователя Java, не тратя много времени на написание кода для отображения простых форм.Вы можете создавать сложные окна за считанные минуты с помощью визуального конструктора WYSIWYG, а код Java создается для вас. Вы можете легко добавлять элементы управления с помощью перетаскивания, добавлять обработчики событий к элементам управления, изменять различные свойства элементов управления с помощью редактора свойств, интернационализировать свое приложение и многое другое. Сгенерированный код не требует дополнительных пользовательских библиотек для компиляции и запуска, а SWT может реконструировать большую часть написанного вручную кода проектирования графического интерфейса пользователя Java.

Редактор состоит из следующих компонентов:

• Design View — основная область визуального макета.
• Представление исходного кода — напишите код и просмотрите сгенерированный код
• Представление структуры — состоит из дерева компонентов и панели свойств.
  Дерево компонентов — показывает иерархические отношения между всеми компонентами.
  Панель свойств — отображает свойства и события выбранных компонентов.
• Палитра — обеспечивает быстрый доступ к компонентам набора инструментов.
• Панель инструментов — обеспечивает доступ к часто используемым командам.
• Контекстное меню — обеспечивает доступ к часто используемым командам.

Редактор также предлагает следующие основные функции:

• Генерация двунаправленного кода — чтение и запись практически любого формата и обратное проектирование самого написанного вручную кода
• Интернационализация (i18n) / Локализация — экстернализация строки компонентов, создавать пакеты ресурсов и управлять ими.
• Пользовательские композиты и панели — создавайте пользовательские компоненты многократного использования.
• Фабрики — создание собственных фабричных классов и методов.
• Visual Inheritance — создавать иерархии визуальных компонентов.
• Обработка событий — добавьте обработчики событий к вашим компонентам.
• Редактирование меню — визуальное создание и редактирование строк меню, пунктов меню и всплывающих меню.
• Morphing — преобразование одного типа компонента в другой.

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

Swing Designer

2. Создание элемента пользовательского интерфейса

Работа с SWT / Swing Designer начинается с создания нового класса элемента пользовательского интерфейса как части вашего проекта. Выберите «Файл»> «Создать»> «Другое», разверните WindowBuilder и выберите один из множества компонентов. Продолжайте работу с мастером, чтобы завершить детализацию элемента.

Выбор элемента пользовательского интерфейса для создания

После завершения работы мастера и создания элемента пользовательского интерфейса открывается Swing Designer, в котором можно спроектировать элемент, используя либо представление «Дизайн», либо представление «Исходный код».

2.1 Выбор диспетчера макетов

При написании приложений Java вы можете использовать макеты, чтобы придать вашим окнам особый вид. Макет контролирует положение и размер дочерних элементов в контейнере. Классы макета являются подклассами абстрактного класса Layout. И SWT, и Swing предоставляют несколько стандартных классов макета, и вы можете писать собственные классы макета. Другие инструменты пользовательского интерфейса включают неявные менеджеры компоновки в каждый тип панели.

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

Менеджер компоновки устанавливает размеры и расположение компонентов на основе различных факторов, таких как:

• Правила компоновки менеджера компоновки
• Настройки свойств менеджера компоновки, если есть
• Данные компоновки, связанные с каждым компонентом
• размер контейнера

Каждый верстальщик имеет характерные достоинства и недостатки.Макеты на основе сетки и макеты на основе ограничений являются наиболее полезными и мощными из стандартных макетов, но они также являются наиболее сложными. При использовании представления «Дизайн» вы можете изменить макет в любое время. Инструмент корректирует код по мере необходимости на лету. Измените макет, либо явно добавив диспетчер макета в исходный код для контейнера, либо выбрав макет для компоновки на поверхности конструктора с помощью инструмента «Макет» на палитре.

3. Представление «Дизайн»

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

Редактирование дизайна формы

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

Щелкните компонент правой кнопкой мыши, чтобы получить доступ к тому же контекстному меню, которое доступно в дереве компонентов. Вы можете добавлять компоненты, выбирая их на палитре, и удалять их, нажимая кнопку Delete .

3.1 Выбор компонентов

Используйте инструмент «Выделение» на палитре, чтобы выбрать один или несколько виджетов.Удерживайте нажатой клавишу Shift или CTRL , чтобы выбрать несколько виджетов.

Выбор компонентов

Используйте инструмент «Область» на палитре, чтобы выбрать несколько виджетов с помощью резиновой ленты. Удерживая нажатой клавишу ALT , перетащите, чтобы автоматически активировать инструмент Marquee.

Выбор с помощью инструмента «Область»

3.2 Редактирование текста компонента

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

Редактирование текста компонента

3.3 Перемещение компонентов

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

Перемещение компонентов в макете, ориентированном по осям x, y

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

Перемещение компонентов в макете, ориентированном на сетку

3.4 Изменение размера компонентов

При изменении размера компонента в представлении «Дизайн» предоставляется обратная связь по размеру, зависящая от диспетчера макета. В макете с ориентацией x, y, таком как абсолютный макет, контур нового размера отображается с всплывающей подсказкой, показывающей его текущий размер. Предусмотрены точки динамической привязки / выравнивания, чтобы было удобно выровнять компонент с другими компонентами или с краем окна. При изменении размера компонента также выполняется привязка к предпочтительному размеру компонента с измененным размером или к размеру (вертикальному или горизонтальному) любого другого компонента того же родителя.

Изменение размера в макете с ориентацией по осям x, y

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

Изменение размера в сеточном макете

4. Представление исходного кода

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

• Подсветка синтаксиса
• Поддержка содержимого / кода
• Форматирование кода
• Помощь при импорте
• Быстрое исправление
• Встроенные функции отладки

Представление исходного кода

Параметр «Макет редактора» управляет положением представления «Код» относительно представления «Дизайн».По умолчанию они находятся на отдельных вкладках, помеченных как «Источник» и «Дизайн» (вы можете выбрать, какая страница будет первой). Предусмотрены дополнительные параметры для отображения представлений «Исходный код» и «Дизайн» рядом или одно над другим.

Виды бок о бок

Виды с накоплением

Чтобы получить доступ к настройкам макета редактора, выберите «Окно»> «Настройки» и выберите «WindowBuilder».

Установка предпочтения макета редактора

5. Представление структуры

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

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

Настройка позиции стыковки

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

Позиции для стыковки

Представление структуры также доступно как отдельное представление. Выберите «Окно»> «Показать представление»> «Другое», разверните WindowBuilder и выберите «Структура» или щелкните правой кнопкой мыши представление «Структура» и выберите «Извлечь как представление». Закрытие автономного представления структуры возвращает представление в положение по умолчанию, встроенное в редактор.

Отделение представления структуры

5.1 Дерево компонентов

Дерево компонентов показывает иерархические отношения между всеми компонентами в представлении «Дизайн».

Дерево компонентов

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

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

Разверните компоненты в дереве с помощью значка «Развернуть все» и сверните их с помощью значка «Свернуть все».

Щелкните правой кнопкой мыши запись в дереве, чтобы получить доступ к тому же контекстному меню, которое доступно в представлении «Дизайн». Вы можете расположить компоненты в дереве путем перетаскивания и удаления, используя клавишу Delete .

Вы можете выбрать несколько компонентов в дереве, удерживая нажатой клавишу CTRL для добавления отдельных выборок или SHIFT для добавления смежных выборок.

5.2 Представление «Свойства»

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

Представление «Свойства»

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

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

Свойство можно выбрать, щелкнув заголовок или значение свойства.Когда свойство выбрано, вместо значения отображается редактор, поэтому вы можете изменить его значение. В большинстве редакторов свойств Enter следует использовать для применения значения и ESC для возврата к предыдущему значению. Если вы выбрали свойство, вы можете использовать клавиши со стрелками для перехода между свойствами.

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

• Дважды щелкните заголовок или значение свойства
• Щелкните знак плюса или минуса
• Выберите свойство и нажмите кнопку «плюс», чтобы развернуть, или кнопку «минус», чтобы свернуть

Некоторые свойства, такие как строки, цвета, шрифты и изображения, предоставляют настраиваемый редактор свойств, доступ к которому можно получить, нажав кнопку «Дополнительно».

Состояние свойства (развернуто или свернуто) сохраняется между выборками элементов управления. Если вы развернете свойство «стиль» для одного элемента управления, а затем выберите другой элемент управления, свойство «стиль» останется развернутым, поэтому вы можете быстро изменить значение стиля для нескольких свойств без необходимости расширять его снова и снова. Как только вы решите, что менять стиль не нужно, вы можете свернуть свойство «стиль» и оставить место для других свойств.

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

• Дважды щелкните значение свойства, чтобы изменить значение на следующее значение в списке (или первое значение, если текущее значение является последним)
• Выберите свойство и нажмите Пробел , чтобы развернуть список, а затем использовать стрелки для изменения значения.
• Выберите свойство и нажмите Удалить , чтобы изменить значение на значение по умолчанию.

Щелкните правой кнопкой мыши представление «Свойства», чтобы получить доступ к контекстному меню панели свойств.

6. Палитра инструментов

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

Чтобы добавить компоненты в представление «Дизайн», вы можете:

• Выберите его на палитре и перетащите на холст дизайна или дерево компонентов, щелкнув в нужном месте.
• Используйте команду «Выбрать компонент», чтобы выбрать тип виджета в окне «Выбор компонента».

Вы можете добавить несколько виджетов одного типа в представление «Дизайн», удерживая нажатой клавишу CTRL при выборе виджета на палитре.

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

Следующие команды являются общими для каждой палитры:

• Выбор
• Область
• Выбрать компонент
• Порядок вкладок

Общие команды палитры

Положение палитры можно настроить с помощью перетаскивания или справа -Щелкнув заголовок палитры и выбрав Dock On из меню.Палитру можно прикрепить к левой или правой стороне представления «Дизайн».

Изменение положения палитры

Палитру также можно свернуть или развернуть.

Свернутая палитра

Палитра также доступна как отдельное представление. Выберите «Окно»> «Показать вид»> «Другое», разверните WindowBuilder и выберите «Палитра» или щелкните правой кнопкой мыши палитру и выберите «Извлечь как представление». Закрытие автономного представления палитры возвращает представление в положение по умолчанию, встроенное в редактор.

Отсоединение палитры

Java Swing GUI Developer Jobs, Employment

Swing GUI Toolkit Group

Группа Swing состоит из
разработчики, участвующие в разработке, внедрении и обслуживании
Swing GUI Toolkit.

Введение

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

Архитектура

Компоненты Swing — это Java Beans,
и построены на основе Model-View-Controller
(MVC) парадигма программирования. Эта парадигма разделяет
бизнес-логики приложения из его пользовательского интерфейса, чтобы они
могут развиваться независимо.

JComponent — это ядро ​​ Контроллер
класс, который координирует модели и представления для отображения конечного пользователя
компонент. Все компоненты Swing унаследованы от
JComponent . Обратите внимание, что компоненты могут иметь разные
представления представлены разными пользовательскими интерфейсами.

Пакет javax.swing.plaf содержит
ComponentUI , который является основным классом для
Просмотр и шаблон для других компонентов, которые
унаследовать от него. ComponentUI отвечает за
окончательная закрашивание пикселей на экране.

A Модель управляет данными в компонентах, начиная с
от простых вещей, таких как состояние флажка, до более сложных
структуры данных строк и столбцов, используемые для таблицы.
ComboBoxModel и TableModel являются примерами
модельные классы.

Исходная структура

Весь основной исходный код Swing находится в java.desktop
модуль, то есть под java.desktop . Итак, последующие пути
данные ниже относятся к этой базе. За некоторыми исключениями из этого
см. конец этого раздела. Большая часть источника находится под
share / classes каталог. В этом каталоге источник
файлы организованы по иерархии пакетов; например,
исходный код javax.swing.JButton можно найти в
доля / классы / javax / качели / JButton.Java .

Пакет javax.swing содержит несколько
подпакетов:

• javax.swing.border — специализированные бордюры для Swing
  компоненты
• javax.swing.colorchooser — классы и интерфейсы
  для JColorChooser
• javax.swing.doc-files — вспомогательные файлы javadoc
  для качелей
• javax.swing.event — события, специфичные для Swing
• javax.swing.filechooser — классы и интерфейсы
  для JFileChooser
• javax.swing.plaf — базовые классы пользовательского интерфейса и
  реализации для независимого от платформы Look and Feels
• javax.swing.table — классы и интерфейсы для
  J Таблица
• javax.swing.text — классы и интерфейсы для
  редактируемые и нередактируемые текстовые компоненты
• javax.swing.tree — классы и интерфейсы для
  JTree
• javax.swing.undo — обеспечивает поддержку отмены / повтора
  операции

По историческим причинам некоторые (традиционно) закрытые
классы реализации находятся в пакете, начинающемся с «sun».В
источник для этих классов можно найти в
доля / классы / солнце / качели .

Внешний вид и ощущения от платформы

можно найти в
каталог share / classes / com / sun / java / swing / plaf. Эти
не являются общедоступными классами реализации.

GTK Look and Feel содержит собственный код, реализующий gtk.
рендеринг с использованием системных библиотек gtk 2 и gtk 3:

• unix / native / libawt_xawt / awt / swing_GTKEngine.c
• unix / native / libawt_xawt / swing_GTKStyle.с
• unix / native / libawt_xawt / gtk2_interface.h
• unix / native / libawt_xawt / gtk2_interface.c
• unix / native / libawt_xawt / gtk3_interface.h
• unix / native / libawt_xawt / gtk3_interface.c

, а также частично в:

• unix / native / libawt_xawt / awt_UNIXToolkit.c

Исключения

Помимо java.desktop есть еще два модуля, для которых
Swing group отвечает

• jdk.доступность , большая часть из которых - Java Access
Поддержка мостов для программ чтения с экрана, таких как JAWS. В
API-интерфейсы javax.accessibility интегрированы в Swing, поэтому
подпадает под Swing
• jdk.unsupported.desktop , который предоставляет некоторые
поддержка взаимодействия между Swing и набором инструментов OpenJFX.

Здание Источник

Файлы make

Swing можно найти по адресу:

• сделать / модули / java.desktop

Сообщество

.