Проектирование графического интерфейса пользователя. Какие ЭИ создать? Создание внешнего вида интерфейса

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

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

1. Одно или несколько окон для вывода графических результатов расчета.

2. Несколько редактируемых окон, с помощью которых задаются и/или изменяются значения параметров задачи.

3. Управляющие кнопки, которые позволяют запускать и останавливать процесс расчета, перерисовывать результаты, выходить из задачи.

4. Поясняющие надписи (статический текст).

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

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

Рис. 8. Простейщий графический интерфейс пользователя для решения задачи “Биения”

9.1. Создание внешнего вида интерфейса

В этом параграфе мы рассмотрим использование MATLAB для разработки внешнего вида графического интерфейса (GUI -GraphicsUserInterface) с использованием средств графического (визуального) программирования. Для вызова визуального редактора необходимо в командном окнеMATLAB набрать командуguide . По истечении определенного времени, определяемого быстродействием вашего компьютера, появятся два новых окна, показанные на рис.9 . Одно из них – панель управления (Control Panel , на рисунке слева) и форма или область рисования (Figure , на рисунке справа). Эти окна могут перекрываться, но мы для ясности изложения расположили их рядом. Показанная выше картинка появится на экране в том случае, если перед вызовомguide отсутствует какой-либо открытый рисунок. В случае же если функцияguide вызывается после отрисовки какого-либо рисунка, то он открывается вместо пустого. Мы же рассмотрим создание графического интерфейса с самого начала.

Перед созданием графического интерфейса желательно “разработать проект” того, что вы хотите иметь в качестве интерфейса. Мы рассмотрим пример вывода трех разных сигналов в трех подокнах, что в терминах графики высокого уровня определялось бы операторами subplot(3,1,k), где k - номер графика. Кроме того,

вывода графиков (axes в терминах панели управления), три статических надписи N,R,C (text ), три окна ввода/редактирования данных (edit ) и две кнопки (push ).

Для создания подокон, в которые будут выводиться графики, ис- пользуется кнопка, показанная справа на рисунке (окно и оси). Щелк-нув по этому элементу на панели управления и переведя мышь на панель рисунка, необходимо поместить крест, котрый будет на кончике мыши, в то

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

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

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

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

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

Построенные таким образом окна вывода и редактирования, окна статического текста и кнопки, а также другие объекты можно выровнять и установить определенные промежутки между ними с помощью панели выравнивания (Alignment Tools ).

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

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

При работе с графическими объектами на панели рисунка желательно раскрыть (с помощью соответствующей кнопки окна Windows) панель рисунка на весь экран и выбрать размер всех объектов на панели рисунка.

Поскольку по умолчанию размеры всех объектов задаются в пикселях, это может привести к тому, что при изменении размера окна вывода кнопки и/или окна могут наехать друг на друга. Для избежания такого нежелательного явления необходимо задать единицы размера всех объектов в безразмерных переменных – долях размера окна. Этот размер называется normalized . Для этого необходимо вызвать редактор свойст щелкнув на панели управления на кнопке с над-

писью Property editor . Выделив в верхнем окне редактора свойств все введенные нами объекты (с помощью удерживаемой клавишиCtrl и выделения объектов левой кнопкой мыши), в нижнем окне редактора свойств находим свойствоUnits (единицы измерения) и выбираем его щелчком левой кнопки мыши. После этого в средней части редактора в специальном окне слева появится свойствоUnits , а справа - окно выбора значений, в котором имеется раскрывающийся список с допустимыми значениями свойства. Для свойстваUnits необходимо выбрать значениеnormalized . Анологично надо задать значение свойстваFontUnits – единицы измерения размера шрифтов. Это обеспечивает изменение размера шрифта при изменении размера окна.

Для размещения надписей на кнопках и в области статического текста необходимо выделить соответствующий объект (либо двойным щелчком прямо в области рисунка, либо в верхнем окне редактора свойств) и в нижнем окне редактора свойств найти свойство String , и после его выделения вписать между кавычками требуемый текст (например, ’Пуск’ на соответствующей кнопке). Для задания надписей над каждым из окон вывода необходимо выделить соответствующее окно и вызвать редактор свойств8 , в нижнем окне которого надо найти свойствоTitle .

8 Редактор свойств можно вызвать не только с помощью кнопки на панели управления, но

и двойным щелчком на соответствующем объекте.

Традиционный графический подход к интерфейсу с пользователем связан с работами Сазерленда, Ньюмена и др. , в котором взаимодействие базируется на использовании графического дисплея с регенерацией и светового пера. Дальнейшее развитие графического диалога связано с прогрессом в области систем интерактивной машинной графики, который привел к регламентации в виде международных стандартов.
GKS - первый международный графический стандарт. В нем впервые зафиксированы концепции "рабочих станций" и логических устройств ввода (клавиатура, выбор, локатор, валюатор, указатель, ввод последовательности координат). К сожалению задуман во время превосходства парадигмы векторного рисования. Отсюда слабость поддержки диалога: отсутствие возможности ввода новых устройств или видоизменения изображения устройства на экране даже из прикладной программы (пользователя графического пакета), что приводит к необходимости использования в основном символьного ввода при организации диалога. Реализация диалога в GKS прерогатива прикладной программы, возможности раздельного проектирования не предполагается.
Второе направление графики - растровая графика оказала чрезвычайно большое влияние на все последующее развитие интерактивных систем. Все основные черты интерфейса с пользователем на современных рабочих станциях суть производные от работ Xerox PARC: управление окнами

• использование графических символов ("икон") для представления объектов
• стиль взаимодействия, называемый непосредственным манипулированием
• популярность "мыши" как устройства позиционирования на экране
• объектно-ориентированный стиль программирования.

1. системы управления окнами (WMS - Window Manager System);
2. специализированный инструментарий;
   • обычный (MacIntosh, SunView . . .)
   • объектно-ориентированный (Smalltalk-80, Andrew, InterView)
3. системы управления пользовательским интерфейсом.

Системы управления окнами (WMS)

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

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

Инструментарий создания пользовательского интерфейса

Стандарт GUI.

Одно из важнейших изменений в компьютерной индустрии – появление графического интерфейса. Поэтому возникла необходимость принять стандарты GUI, которые определяют, как должны выглядеть приложения под Windows? Macintosh и т.д. Существуют даже сертификационные программы к требованbям которых продавцы приспосабливают свои приложения, чтобы получить значок Windows. Это делается по нескольким причинам.

Одно из достоинств Windows или Mac – их стандартный вид. Когда вы научились работать в одном из них, считайте, что владеете и остальными. Большинство приложений под Windows используют одни и те же соглашения, поэтому вы знаете как открыть, сохранить, распечатать, закрыть и скопировать файл в любом из них. Стандартный интерфейс очень удобен для пользователей. Нужно стараться, чтобы ваши приложения были похожи на другие приложения под Windows с которыми пользователи уже научились работать. Есть семь общих принципов разработки GUI. Если вы изучите их и будете им следовать, с дизайном ваших приложений будет все в порядке.

Семь принципов разработки GUI.

Семь общих принципов разработки GUI взяты из руководства по интерфейсу Micrisoft Windows. Они формируют схему, на основании которой вы можете создавать собственные стандарты. Эта схема дает разработчикам и пользователям два существенных преимущества. Во-первых, приложения выглядят профессионально. Во-вторых, они функциональны, согласуются с другими приложениями и легко осваиваются пользователями.

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

1. Позволяйте пользователю контролировать приложение.

2. Следуйте парадигме объект/действие.

3. Будьте последовательны.

4. Сделайте работу с приложениями простой и очевидной.

5. Стремитесь к гармонии.

6. Обеспечьте пользователю обратную связь.

7. Будьте снисходительны

Принцип первый: дайте возможность пользователю контролировать приложение.

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

Допустим пользователь хочет добавить нового клиента В примере, пользователь должен для этого перейти в модуль ACCOUNTS RECCIEVAble и затем добавить откуда нового клиента. Откуда ему знать, что нужно делать? Вероятно, из своего опыта работы с этим приложением. А в мире GUI пользователь просто выбирает в меню сначала команду New (Новый), потом Customer (Клиент), как показано на рис. В этой современной системе можно добавить нового клиента, продавца или пункт инвентаризационной записи посредством меню File (Файл). Это позволяет изменить запись клиента, находясь в экране продавца, и наоборот. Пользователю не нужно больше разбираться в сложном и запутанном иерархическом меню.

Принцип второй: следуйте парадигме объект/действие.

Парадигма объект/действие гласит, что над всеми объектами системы можно выполнить какую-либо операцию. Наиболее простой и очевидный пример – экран поддержки базы клиентов (рис). Экран содержит набор кнопок и каждая из низ позволяет произвести некоторое действие над информацией о выбранном клиенте. Можно удалить ее, отредактировать, распечатать и т.д. Действия, которые можно выполнить над определенным клиентом, должны быть доступны или недоступны в соответствующие моменты времени. Например, когда запись покупателя находится в режиме редактирования, кнопки Delete (Удалить) и New (Новый) следует деактивировать.

Принцип третий: будьте последовательны.

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

Таким образом, создавая новые приложения, будьте последовательны. Если для добавления новой записи употреблена команда New (Новый), используйте ее везде. Не следует заменять это слово другими – например, словом Add 9добавить). Благодаря вашей последовательности пользователи будут знать: где им ни встретилась команда New (Новый), е можно использовать для добавления новой записи.

Принцип четвертый: сделайте работу с приложением простой и очевидной.

Можно выразить эту мысль и так: не употребляйте жаргона. Есть экран с двумя кнопками. На одной из них написано «Упаковать базу данных», а на другой – «Убрать записи с пометкой на удаление». Вторая запись наверняка будет более понятна пользователю.

При разработке приложений часто возникает соблазн применить в интерфейсе программистский сленг. Старайтесь по возможности избегать этого.

Принцип пятый: стремитесь к гармонии

Даже в черно белом виде этот экран имеет существенный эстетический недостаток: белый фон и на нем контрастные объекты. На рис. Тот же самый экран выглядит хорошо сбалансированным в цветовом отношении.

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

Принцип шестой. Обеспечивайте пользователю обратную связь.

Представьте себе, что в вашем приложении есть процесс, который долго выполняется. В течение этого времени на экран можно выводить сообщение примерно такого содержания: «Программа работает, подождите пожалуйста». Удобное решение; но откуда пользователю знать, что она не зависла? Поэтому весьма вероятно, что он отдаст приложению «салют тремя пальцами» (Ctrl+Alt+Del), хотя с программой все будет в порядке.

Лучше показать пользователю, какая часть процесса выполнена. Тогда он не прервет программу понапрасну, сможет оценить, как далеко продвинулась работа, и заняться другими делами, пока процесс не завершится. Таким образом, производительность труда пользователя повысится примерно на 25 процентов. Этого результата можно достичь простым выводом измерителя на экран. Обычно выводятся сообщения типа «10 из 100 записей обработано» или «40% завершено». Еще лучше показать как число обработанных записей, так и их процент»

Принцип седьмой: будьте снисходительны

Каждый из нас иногда удалял запись, нечаянно нажав не ту кнопку. Поэтому оставьте пользователю возможность передумать или отменить только что произведенные действия. Если процесс занимает длительное время, изменяет большой объем данных или требует, чтобы пользователь создал резервную копию данных перед выполнением действия, необходимо выдать соответствующее предупреждение, Мне приходилось видеть приложения, которые требуют подтверждения дважды, а потом еще спрашивают пароль. Нужны ли вашим программам защиты такого уровня? Возможно. Задача разработчика – помочь пользователю, если тот сделал ошибку на любом этапе работе.

Важность соглашений по стандарту GUI.

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

Предоставлено Салимом Гулом (Saleem Gul) и Томасом Павеком (Tomas Pavek)

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

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

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

Предполагаемая продолжительность: 20 минут

Упражнение 1: Создание проекта

Первым действием является создание проекта среды IDE для разрабатываемого приложения. Дадим проекту имя NumberAddition .

1. Выберите "Файл" > "Создать проект" . Также можно щелкнуть значок "New Project" на панели инструментов среды IDE.
2. В области "Categories" выберите узел "Java". В области "Projects" выберите "Java Application". Нажмите кнопку "Далее".
3. Введите NumberAddition в поле Project Name ("Имя проекта") и укажите путь, например, в вашем основном каталоге, как местоположение проекта.
4. Установите флажок "Использовать отдельную папку для хранения библиотек" и укажите местоположение папки библиотек (необязательно). Дополнительная информация приведена в статье Предоставление доступа к библиотеке другим пользователям в документе Разработка приложений с помощью NetBeans IDE .
5. Удалите флажок "Create Main Class", если он установлен.
6. Нажмите кнопку "Готово".

Упражнение 2: Создание внешнего интерфейса

Для продолжения процесса создания интерфейса необходимо создать контейнер Java, в который будут помещены другие требуемые элементы графического интерфейса. В этом действии контейнер будет создан с помощью элемента JFrame . Контейнер будет помещен в новый пакет, который будет отображаться в узле "Source Packages".

Создание контейнера JFrame

1. В окне "Проекты" щелкните правой кнопкой мыши узел NumberAddition и выберите Создать > Другие.
2. В диалоговом окне создания файла выберите категорию Swing GUI Forms и тип файла JFrame Form . Нажмите кнопку "Далее".
3. Введите NumberAdditionUI в качестве имени класса.
4. Выберите пакет my.numberaddition .
5. Нажмите кнопку "Готово".

Среда IDE создает форму NumberAdditionUI и класс NumberAdditionUI в приложении NumberAddition и открывает форму NumberAdditionUI в GUI Builder. Пакет my.NumberAddition заменяет собой пакет по умолчанию.

Добавление элементов: создание внешнего интерфейса

Далее с помощью окна "Palette" внешний интерфейс приложения заполняется панелью JPanel. После этого добавляются три элемента JLabel (текстовые подписи), три элемента JTextField (текстовые поля) и три элемента JButton (кнопки). Если до этого работа с конструктором графического интерфейса пользователя не выполнялась сведения о размещения компонентов см. в разделе Разработка графического пользовательского интерфейса Swing в IDE NetBeans .

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

Если в правом верхнем углу среды IDE отсутствует окно Palette ("Палитра"), выберите Window ("Окно") > Palette ("Палитра").

1. Для начала выберите панель из категории Swing Containers ("Контейнеры Swing") в палитре и перетащите ее на JFrame.
2. Панель JPanel будет выделена. Перейдите к окну "Properties" и нажмите кнопку с многоточием (...) рядом с полем "Border" для выбора стиля границы.
3. В диалоговом окне "Border" выберите "TitledBorder" из списка и введите Number Addition в поле "Title". Для сохранения изменений и закрытия диалогового окна нажмите кнопку "OK".
4. Теперь на экране должен отображаться пустой элемент "JFrame" с заголовком "Number Addition", как показано на рисунке. Согласно рисунку добавьте к нему три метки JLabel, три текстовых поля JTextField и три кнопки JButton.

Переименование элементов

На этом этапе будет выполнено переименование элементов, которые были добавлены к элементу JFrame.

1. Дважды щелкните jLabel1 и измените ntrcn (свойство "text") на First Number .
2. Дважды щелкните jLabel2 и измените текст на Second Number .
3. Дважды щелкните jLabel3 и измените текст на Result .
4. Удалите стандартный текст из jTextField1 . Отображаемый текст можно преобразовать в редактируемый. Для этого щелкните правой кнопкой мыши текстовое поле и выберите "Редактировать текст" во всплывающем меню. При этом может потребоваться восстановить первоначальный размер поля jTextField1 . Повторите это действие для полей jTextField2 и jTextField3 .
5. Измените отображаемый текст jButton1 на Clear . (Для изменения текста кнопки щелкните кнопку правой кнопкой мыши и выберите "Edit Text". В качестве альтернативы можно щелкнуть кнопку, выдержать паузу и щелкнуть еще раз.)
6. Измените отображаемый текст jButton2 на Add .
7. Измените отображаемый текст jButton3 на Exit .

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

Упражнение 3: Добавление функциональности

В этом упражнении будет добавлена необходимая функциональность к кнопкам "Add", "Clear" и "Exit". Поля jTextField1 и jTextField2 будут использоваться для ввода значений пользователем, а jTextField3 - для вывода результата работы программы. Создаваемая программа представляет собой простейший калькулятор. Итак, приступим!

Добавление функциональности к кнопке "Exit"

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

1. Щелкните правой кнопкой мыши кнопку "Exit". Во всплывающем меню выберите Events ("События") > Action ("Действие") > actionPerformed. Учтите, что меню содержит множество других событий, на которые может реагировать программа! При выборе события actionPerformed среда IDE автоматически добавит прослушиватель ActionListener к кнопке Exit ("Выход") и создаст метод обработчика для обработки метода прослушивателя actionPerformed.
2. В среде IDE автоматически открывается окно "Source Code", где отображается место вставки действия, которое должно выполняться кнопкой при ее нажатии (с помощью мыши или клавиатуры). Окно "Source Code" должно содержать следующие строки: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) { //TODO add your handling code here: }
3. Теперь добавим код действия, которое должна выполнять кнопка "Exit". Замените строку TODO на System.exit(0); . Готовый код кнопки "Exit" должен выглядеть следующим образом: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) { System.exit(0); }

Добавление функциональности к кнопке "Clear"

1. Щелкните правой кнопкой мыши кнопку "Clear" (jButton1). В появившемся меню выберите "Events > Action > actionPerformed".
2. Нажатие кнопки "Clear" должно приводить к удалению всего текста из всех текстовых полей "jTextField". Для этого следует добавить код, аналогичный приведенному выше. Готовый исходный код должен выглядеть следующим образом: private void jButton1ActionPerformed(java.awt.event.ActionEvent evt){ jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); }

Этот код удаляет текст из всех трех полей JTextField, оставляя их пустыми.

Добавление функциональности к кнопке "Add"

Кнопка "Add" должна выполнять три действия.

1. Сначала она принимает данные, введенные пользователем в полях jTextField1 и jTextField2 , и преобразовывает их из типа "String" в тип "Float".
2. Затем она выполнит сложение двух чисел.
3. И, наконец, она преобразует сумму в тип String и поместит ее в jTextField3 .

1. Щелкните вкладку "Design" в верхней части рабочей области для возврата к экрану "Form Design".
2. Щелкните правой кнопкой мыши кнопку "Add" (jButton2). Во всплывающем меню выберите Events ("События") > Action ("Действие") > actionPerformed.
3. Добавьте код действий, которые должна выполнять кнопка "Add". Готовый исходный код должен выглядеть следующим образом: private void jButton2ActionPerformed(java.awt.event.ActionEvent evt){ // First we define float variables. float num1, num2, result; // We have to parse the text to a type float. num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Now we can perform the addition. result = num1+num2; // We will now pass the value of result to jTextField3. // At the same time, we are going to // change the value of result from a float to a string. jTextField3.setText(String.valueOf(result)); }

Теперь программа полностью готова, и можно приступить к ее сборке и выполнению.

Упражнение 4: Выполнение программы

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

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

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

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

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

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

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

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

1. Вызовите командную строку или окно терминала.
2. В командной строке измените текущий каталог на каталог NumberAddition/dist .
3. В командной строке введите следующий оператор: java -jar NumberAddition.jar

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

Механизм обработки событий

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

1. Вернитесь к файлу NumberAdditionUI.java в редакторе. Щелкните вкладку "Design" для просмотра структуры графического интерфейса в GUI Builder.
2. Щелкните правой кнопкой мыши любой элемент графического интерфейса и выберите "Events" в появившемся меню. Теперь можно просто изучить содержимое меню, не выбирая каких-либо пунктов.
3. В качестве альтернативы можно выбрать "Properties" в меню "Window". В окне "Properties" щелкните вкладку "Events". Вкладка "Events" позволяет просмотреть и изменить обработчики событий, связанные с текущим активным элементом графического интерфейса.
4. Приложение также может реагировать на нажатие клавиш, одинарный, двойной или тройной щелчок мышью, перемещение указателя мыши, изменение размера окна и перемещение фокуса ввода. Меню "Events" позволяет автоматически создать обработчики событий для всех этих событий. Наиболее распространенным из них является событие "Action". (Для получения дополнительных сведений см. практические рекомендации по обработке событий в руководстве Sun Java Events Tutorial .)

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

1. Вернитесь к файлу NumberAdditionUI.java в редакторе. Щелкните вкладку "Source" для просмотра исходного кода графического интерфейса.
2. Выполните прокрутку вниз и просмотрите реализованные методы jButton1ActionPerformed() , jButton2ActionPerformed() и jButton3ActionPerformed() . Эти методы называются обработчиками событий.
3. Теперь перейдите к методу initComponents() . Если этот метод отсутствует, найдите строку Generated Code и щелкните знак + рядом с этой строкой для отображения скрытого метода initComponents() .
4. Обратите внимание на синий блок, окружающий метод initComponents() . Этот код был автоматически создан средой IDE и не может быть изменен пользователем.
5. Теперь посмотрите на сам метод initComponents() . Помимо прочего, он содержит код, инициализирующий элементы графического интерфейса и помещающий их в форму. Этот код создается и обновляется автоматически при размещении и изменении элементов в режиме проектирования.
6. В методе initComponents() найдите следующий фрагмент: jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton3ActionPerformed(evt); } });

   В этом месте к элементу графического интерфейса, в данном случае к jButton3 , добавляется объект прослушивания событий "ActionListener". Интерфейс "ActionListener" имеет метод "actionPerformed" объекта "ActionEvent", который реализуется путем простого вызова обработчика событий jButton3ActionPerformed . Теперь эта кнопка реагирует на события действий. Каждый раз при нажатии кнопки создается событие "ActionEvent", которое передается в метод "actionPerformed" интерфейса прослушивания событий, исполняющий код, предусмотренный разработчиком для этого события в обработчике событий.

7. Учебная карта по приложениям с графическим интерфейсом Java