Java — В Java можно ли создать окно без рамки, меню и кнопок


Содержание

Java Eclipse пример оконного приложения — создание окна, задание размеров, добавление надписей и кнопок, вывод сообщения

Primary tabs

Forums:

Далее пример урока 8 по программированию на Java.

Это пример содержит 5 классов (в проекте вам надо будет создать пять классов), предварительно создав два пакета пакета.

пакет TestForm

Этот пакет содержит два класса.

класс FormStart (создаёт «рамку», задаёт её размеры и запрашивает холст):

класс MainFormAppearance ( в одном своём методе задаёт внешность холста и возвращает ссылку на холст):

В этом пакете будут расположены 3 класса-действия (действий), которые мы будем «прикреплять» к создаваемым кнопкам (см. класс выше MainFormAppearance)

Класс CsvListener:

класс ParceListener:


Класс TestActionListener:

Могу ли я создать окно в Java без кнопок заголовков?

Можно ли создать в Java какой-либо объект Window, имеющий рамку и границу, но без кнопок заголовков (свернуть, восстановить, закрыть).

Естественно, я не могу использовать undecorated установка. Далее в окне необходимо:

  • Иметь визуализированную платформу границу
  • Есть заголовок
  • Не имеют заголовков кнопок. Если понадобится, я позабочусь об утилизации окна программно.
  • Использовать по умолчанию или System Смотри и чувствуй

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ссылки

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

Начинаем программировать на языке Java

Занятие четвертое Контейнеры Использование компонентов интерфейса Классы элементов меню Сегодня мы рассмотрим самый большой и, наверное, самый полезный раздел языка Java, связанный с реализацией пользовательского интерфейса. Для этого мы изучим базовые классы упаковки java.awt (Abstract Window Toolkit).

Занятие четвертое

Сегодня мы рассмотрим самый большой и, наверное, самый полезный раздел языка Java, связанный с реализацией пользовательского интерфейса. Для этого мы изучим базовые классы упаковки java.awt (Abstract Window Toolkit).


Итак, что же такое awt? Это набор классов Java, каждый из которых отвечает за реализацию функций и отображение того или иного элемента графического интерфейса пользователя (GUI). Практически все классы визуальных компонентов являются потомками абстрактного класса Component. Лишь визуальные элементы меню наследуются от другого класса — MenuComponent. Управляющие элементы представлены следующими классами: Button (кнопка), Checkbox (кнопка с независимой фиксацией), Choice (раскрывающийся список Windows), Label (строка), List (список выбора Windows) и Scrollbar (полоса прокрутки). Это достаточно простые классы, наследуемые от абстрактного класса Component напрямую.

Однако в составе java.awt имеются классы интерфейсных элементов, имеющие промежуточного предка. Хорошим примером тому является класс Panel для создания различных панелей. У него имеется промежуточный абстрактный класс-предок Container, служащий родоначальником многих классов-контейнеров, способных содержать в себе другие элементы интерфейса. От этого же класса наследуется класс окна Window, представляющий на экране простейшее окно без меню и рамки. У этого класса есть два часто используемых потомка: Dialog, название которого говорит само за себя, и Frame — стандартное окно Windows. Еще один промежуточный класс TextComponent порождает два полезнейших в работе класса — TextField (аналог строки ввода Windows) и многострочное окно текстового ввода TextArea. Особняком от всех элементов стоит класс Canvas. Его визуальное представление — пустой квадрат, на котором можно выполнять рисование и который может обрабатывать события нажатия кнопок мыши.

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

изменение шрифта — методы getFont, setFont, getFontMetrics;

изменение цвета шрифта — методы setForeground(Color) и getForeground() — для установки и чтения цвета самого шрифта, а также setBackground(Color) и getBackground() для установки, а также чтения цвета фона, на котором отображается текст;

размер и позиция на экране — методы preferredSize() и minimumSize() сообщают менеджеру раскладок о предпочтительном и минимальном размерах компонента, соответственно;

отображение компонента — методы paint(), update() и repaint();

обработка сообщений — методы handleEvent(), action(), keyDown(), keyUp(), mouseDown(), mouseUp(), mouseDrag(), mouseMove(), mouseEnter() и mouseExit().

Контейнеры

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

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

Все достаточно просто. Лишь поясним метод add(). Этим методом и производится собственно добавление элемента интерфейса в окно контейнера. В нашем примере мы использовали самый простой вариант этого метода, принимающий единственный аргумент-ссылку на вставляемый объект. Но есть еще два варианта метода add() с двумя аргументами. В первом из них передаются порядковый номер в списке управляющих элементов контейнера, куда будет вставлен добавляемый элемент, и ссылка на вставляемый объект. Во втором варианте первый аргумент — строка, указывающая место в окне, где должен быть размещен вставляемый объект интерфейса, а второй — ссылка на вставляемый объект. Строк, допустимых в качестве первого аргумента, всего пять: North, South, East, West и Center. Подробнее мы рассмотрим их в разделе, посвященном раскладкам.

Само собой разумеется, коли есть методы для добавления визуальных элементов, имеются и противоположные им методы, удаляющие элементы из окна контейнера. Их два: метод удаления конкретного элемента remove(), принимающий в качестве параметра ссылку на удаляемый объект, и метод удаления всех визуальных компонентов removeAll().

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

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

Label

С помощью класса Label можно создавать текстовые строки в окне Java-программ и аплетов. По умолчанию текст будет выровнен влево, но, используя метод setAlignment с параметрами Label.CENTER и Label.RIGHT, можно выровнять строку по центру или по правому краю. Вы можете задать выводимый текст либо при создании объекта класса Label, либо создать пустой объект и уже затем определить его текст вызовом метода setText(). То же касается и выравнивания, для управления которым имеется метод setAlignment(). Вот примеры использования трех различных конструкторов для объекта класса Label:

Вы можете узнать о текущем тексте и его выравнивании, вызвав методы getText() и getAlignment() соответственно.

Button

Класс Button представляет на экране кнопку. У этого класса имеется два типа конструктора. Первый из них создает кнопку без надписи, второй — с надписью:

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

Checkbox

Класс Checkbox отвечает за создание и отображение кнопок с независимой фиксацией. Это кнопки, имеющие два состояния: «включено» и «выключено». Щелчок на такой кнопке приводит к тому, что ее состояние меняется на противоположное. Если разместить несколько кнопок с независимой фиксацией внутри элемента класса CheckboxGroup, то вместо них мы получим кнопки с зависимой фиксацией, то есть группу кнопок, среди которых в один и тот же момент может быть включена только одна. Если нажать какую-либо кнопку из группы, то ранее нажатая кнопка будет отпущена. Вы наверняка сталкивались с такими группами в различных Windows-программах.

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

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

Choice

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

Полезные методы класса Choice:

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

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

Полезные методы класса List:

  • getItem(int) — считать текст пункта выбора;
  • countItems() — посчитать количество пунктов выбора в списке;
  • replaceItem(String, int) — заменить элемент выбора в указанной позиции;
  • clear() — очистить список;
  • delItem(int) — убрать из списка определенный пункт;
  • delItems(int, int) — убрать элементы выбора с номерами, входящими в интервал от номера, указанного первым параметром, до номера, указанного вторым параметром;
  • getSelectedIndex() — узнать порядковый номер выделенного пункта; если возвращается -1, то выбрано несколько пунктов;
  • getSelectedIndexes() — возвратить массив индексов выделенных пунктов;
  • getSelectedItem() — прочитать текст выделенного пункта выбора;
  • getSelectedItems() — возвратить массив строк текста выделенных пунктов;
  • select(int) — выделить пункт с определенным номером;
  • deselect(int) — снять выделение с определенного пункта;
  • isSelected(int) — возвратить значение true, если пункт с указанным номером выделен, иначе возвратить false;
  • getRows() — возвратить количество видимых в списке строк выбора;
  • allowsMultipleSelections() — возвратить true, если список позволяет множественный выбор;
  • setMultipleSelections() — включить режим разрешения множественного выбора;
  • makeVisible(int) — сделать элемент с определенным номером видимым в окне списка;
  • getVisibleIndex() — возратить индекс элемента выбора, который последним после вызова метода makeVisible() стал видимым в окне списка.

    Scrollbar

    Класс Scrollbar представляет на экране знакомую всем полосу прокрутки. С помощью этого элемента можно прокручивать изображение и текст в окне либо устанавливать некоторые значения. Чтобы создать полосу прокрутки, необходимо вызвать конструктор объекта класса Scrollbar. Это можно сделать тремя способами:

    Третий конструктор создает объект класса Scrollbar, сразу задавая все необходимые параметры:

    — ориентация полосы, задаваемая константами Scrollbar.HORIZONTAL и Scrollbar.VERTICAL;

    -начальное значение, в которое помещается движок полосы прокрутки;

    — сколько пикселов прокручиваемой области видно, и насколько эта область будет прокручена при щелчке мышью на полосе прокрутки;

    — минимальная координата полосы прокрутки;

    — максимальная координата полосы прокрутки.


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

    TextField и TextArea

    Два родственных класса, TextField и TextArea позволяют отображать текст с возможностью его выделения и редактирования. По своей сути это маленькие редакторы: однострочный (TextField) и многострочный (TextArea). Создать объекты этих классов очень просто: нужно лишь передать размер в символах для класса TextField и размер в количестве строк и символов для класса TextArea:

    Можно запретить редактировние текста в окне:

    Полезные методы классов TextField и TextArea:

  • getText() — считать текст;
  • setText() — отобразить текст;
  • selectAll() — выделить весь текст;
  • getSelectedText() — считать выделенный текст;
  • isEditable() — проверить, разрешено ли редактирование текста;
  • getSelectionStart() — возвратить начало выделения;
  • getSelectionEnd() — возвратить окончание выделения;
  • select() — выделить текст между начальной и конечной позициями;
  • getColumns() — возвратить количество символов в строке редактирования.

    В свою очередь, класс TextField имеет дополнительные методы:

  • setEchoChar() — установить символ маски; применяется при введении паролей;
  • char getEchoChar() — узнать символ маски;
  • echoCharIsSet() — узнать, установлен ли символ маски.

    Для класса TextArea добавляются другие методы:

  • int getRows() — считать количество строк в окне;
  • insertText(String, int) — вставить текст в определенной позиции;
  • replaceText(String, int, int) — заменить текст между заданными начальной и конечной позициями.

    Panel

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

    Создание объекта класса Panel элементарно:

    Как и в случае с другими контейнерами, элементы интерфейса могут быть добавлены методом add().

    Frame

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

    Полезные методы класса Frame:

  • pack() — изменить размер компонентов в окне так, чтобы их размер был максимально приближен к желаемому;
  • getTitle() — возвратить заголовок окна;
  • setTitle(String) — установить заголовок окна;
  • getIconImage() — возвратить пиктограмму окна;
  • setIconImage(Image) — установить пиктограмму окна;
  • getMenuBar() — возвратить объект меню окна;
  • setMenuBar(MenuBar) — установить меню окна;
  • remove(MenuComponent) — убрать определенный компонент из меню окна;
  • isResizable() — возвратить true, если размер окна можно изменять, иначе — false;
  • setResizable(boolean) — разрешить изменение размеров окна;
  • getCursorType() — возвратить текущий тип курсора мыши для окна;
  • setCursor(int) — установить тип курсора мыши для окна.

    Dialog

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

    class NewDialog extends Dialog

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

    Помимо общих для всех окон методов getTitle(), setTitle(), isResizable() и setResizable() у класса Dialog имеется метод isModal(), возвращающий true, если диалоговая панель модальна.

    Классы элементов меню

    Едва ли какое-то современное приложение сможет обойтись без полосы меню в окне. Поэтому в языке Java имеются сразу несколько классов для создания меню, унаследованных от класса MenuComponent. Первый из них, MenuBar, это основной класс всей системы меню, служащий контейнером для других классов. Когда вы создаете окно, то в качестве ссылки на добавляемое меню нужно передать ссылку на класс MenuBar.

    Следующий класс Menu на полосе меню отображается как пункт выбора, который, если по нему щелкнуть, раскрывается в виде странички с пунктами выбора (pop-up menu). Сами же элемены выбора меню обычно реализуются как экземпляры классов MenuItem (простой элемент выбора) и CheckboxMenuItem (отмечаемый элемент выбора). Взгляните на пример создания полнофункциональной полосы меню:

    Как видите, создание меню хотя и муторный, но вовсе не сложный процесс. Если вы обратили внимание, то во второе меню добавляется не пункт выбора класса MenuItem, а меню класса Menu. Это приводит к тому, что при нажатии на пункт 2 полосы меню рядом появляется следующее меню, выбрав из которого Next Level Menu получили очередное меню. Таким способом в Java реализовано каскадирование меню.

    Canvas

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

    Создание любого наследника от Canvas сводится к реализации методов paint() для прорисовки изображения и текста на рабочей поверхности и методов minimumSize() и preferredSize(), управляющих ее размерами.

    Раскладки



    Остался один вопрос, которого мы с вами не коснулись, — раскладки компонентов. Для того чтобы управлять расположением элементов внутри окон-контейнеров, в Java существует менеждер раскладок (layout manager). От него наследуются пять классов, определяющих тот или иной тип расположения компонентов пользовательского интерфейса в окне. Когда вам требуется изменить тип расположения, вы создаете тот или иной класс раскладки, отвечающий вашим запросам, и передаете его в вызываемый метод setLayout(), изменяющий текущую раскладку:

    Дадим краткую характеристику классам-раскладкам.

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

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

    BorderLayout. Эта раскладка размещает элементы либо рядом с выбранным краем окна, либо в центре. Для этого после установки BorderLayout добавление элементов в окно-контейнер производится методом add() с дополнительным параметром, задаваемым строками North, South, East, West и Center. Каждая из них означает тот край окна, к которому необходимо прижать вставляемый элемент.

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

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

    Java/Первое окно

    1. Python
      1. tkinterСтандратный модуль для создания приложений с GUI интерфейсом.
    2. VBA
      1. VBAGUI в среде MS Excel.
    3. HTML
      1. HTML bookОбзор GUI в HTML.
    4. Pascal
      1. Windows FormsИнтерфейс (API) для создания GUI-приложений.

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

    Содержание

    Начнем с простого [ править ]

    Вот у нас и получилось ничего не делающее приложение!

    Делаем что-то полезное [ править ]

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

    Дизайн [ править ]

    Это то, что мы примерно хотим увидеть:

    Вороносчет
    Ворон на заборе : 666
    Ворона прилетела Ворона улетела

    Скелет программы [ править ]

    После компиляции и запуска — получится что-то такое:

    Добавляем функциональность [ править ]

    Пришло время добавить немного интерактивности. Нам нужно сделать 3 вещи:

    1. Научить кнопку addCrow добавлять 1 к переменной voron.
    2. Научить кнопку removeCrow вычитать 1 из переменной voron.
    3. Научить countLabel — обновлять свое значение в зависимости от содержимого переменной voron.

    Прикладное программирование с нуля.

    AVR, STM, Android, IoT. Встраиваемые системы.

    Шаг №45. Создаем оконное приложение на Java для логгера

    Всем привет. Как Вы помните в предыдущей статье мы перешли на язык Java для написания небольших приложений по обработки данных, на компьютере, полученных с устройств на микроконтроллере. Также мы условились, что дальнейший материал требует знание начального уровня java. Если его нет, то не расстраивайтесь, самые основы похожи на Си, но объектно-ориентированную часть придется подучить. Литературу я приводил в предыдущей статье.

    import java.awt.*; /*Подключаем библиотеку для создания апплетов и независимых
    приложений с графическим интерфейсом.*/
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;

    public class logWindow extends Frame < /*Создаем подкласс logWindow класса Frame*/
    public logWindow () /*Конструктор класса*/
    <
    super («Логгер»); /*Вызываем конструктор суперкласса и передаем ему параметр, в данном случае имя программы*/
    setSize (200,200); /*Метод суперкласса для установкиразмеров окна, в пикселях*/
    //Создаем объекты
    Button myButton = new Button («Мониторинг»); /*Создаем кнопку и надпись на ней*/
    Label myLabel = new Label («Данные логгера»); / Создаем текстовое поле и надпись в нем*/
    add (myLabel, BorderLayout.NORTH); /* С помощью менеджера размещения, располагаем текстовое поле в северной части окна*/
    add (myButton, BorderLayout.SOUTH); /*Кнопку в южной части*/
    myButton.addActionListener (new ActionListener () < /*Для кнопки выбираем событие слушателя, и создаем новое событие в скобках.*/
    public void actionPerformed (ActionEvent e) <
    myLabel.setText («Мониторинг»); /*Выполняется действие, т.е. при нажатии на кнопку в поле выводится сообщение «Мониторинг» */
    >
    >);
    >
    public static vo > //Точка входа программы
    logWindow log = new logWindow (); //Создаем объект класса
    log.setVisible (true); //Устанавливаем видимость окна
    /*Наше окно запускается и отображается, при нажатии на кнопку меняется надпись в текстовом поле. Что бы закрыть окно необходимо добавить код обработки события, который работает следующим образом: мы вызываем для объекта log метод addWindowListener для того, чтобы назначить слушателя оконных событий. В качестве параметра создаем объект абстрактного класса WindowAdapter, в котором создаем класс и переопределяем метод для обработки события закрытия окна — dispose.*/
    log.addWindowListener (new WindowAdapter () <
    public vo >// в качестве аргумента передаем событие
    e.getWindow ().dispose (); // уничтожает объект Frame
    >
    >);
    >
    >

    Слева на рисунке внешний вид нашего простого оконного приложения на java. На данный момент нас устроит простое меню с одной кнопкой для дальнейших эксперементов. В следующей статье мы научимся мониторить COM — порт, для приема информации с наших устройств, в данном случае такой же строки, которую мы вывели на терминал в статье №42. На этом все. Всем пока.

    JButton кнопка — обработка нажатия

    Каждое приложение, которое имеет графический интерфейс пользователя не может обходиться без кнопок. В Java Swing кнопка представлена классом JButton. У кнопки имеются различные методы для ее конфигурирования — установка надписи на JButton, установка иконки, выравнивание текста, установка размеров и так далее. Кроме всего прочего разработчику необходимо навесить на JButton слушателя, который будет выполняться как только пользователь нажмет на кнопку. Как это сделать? Поговорим об этом ниже.

    Ранее я писал, что все взаимодействия пользователя с приложением основано на событиях. Не является исключением и JButton. Как только пользователь нажимает кнопку, создается ActionEvent событие, которое передается слушателям кнопки. Для того, чтобы организовать слушателя Swing предоставляет интерфейс ActionListener, который необходимо реализовать. Интерфейс ActionListener требует только реализации одного метода — actionPerformed. Пример класса, реализующего интерфейс ActionListener представлен ниже.

    После того, как обработчик создан, его необходимо добавить к кнопке. Делается это при помощи метода addActionListener. В качестве параметра методу передается обработчик. Например, это можно сделать вот так:

    Здесь мы создаем сначала кнопку. Потом создаем экземпляр нашего слушателя TestActionListener, а затем добавляем его в качестве слушателя к кнопке с помощью вызова addActionListener и передаем ему экземпляр обработчика. Вообще слушателей может быть неопределенное количество. Если нам будет необходимо два или более слушателей, которые должны будут по-разному реагировать на нажатие кнопки, то для каждого из них вызовем addActionListener. Кроме того может когда-нибудь понадобиться отключить слушателя и сказать ему, чтобы он больше не прослушивал нажатие кнопки. Это можно сделать при помощи метода removeActionListener. Сюда в качестве параметра придется передать ссылку на слушателя, которого хотим удалить из списка слушателей кнопки JButton.

    Ну и напоследок пример приложения для демонстрации обработчиков нажатия кнопки JButton.

    Стоит сказать про несколько интересных на мой взгляд моментов. Первый — это использование action command. Можно заметить, что у кнопок вызывается метод setActionCommand, в который для каждой кнопки передает своё строковое значение. Таким образом в приложении можно понять, какая именно кнопка была нажата, если обработку нажатия нескольких кнопок выполняет один слушатель. Для того, чтобы узнать это у ActionEvent берется action command с помощью метода getActionCommand.

    Второй момент — для обработки события нажатия кнопки JButton можно создать анонимный класс, который реализует интерфейс ActionListener. Это можно наблюдать вот здесь:

    Окошко с кнопками на JavaFX:

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

    Что будет происходить?

    Так как цель у меня — разобраться с JavaFX, нужно придумать какую-то функцию у нашего окна. Идея такая: создадим набор людей (предположим, что они работают в какой-то компании), для каждого из которых будет известно имя, возраст, зарплата и семейное положение. Наше окно, во-первых, будет выводить информацию о каждом из них, во-вторых, изменять зарплату какого-либо сотрудника, в-третьих, иметь возможность добавлять нового сотрудника, и, наконец, в-четверных, будет способно фильтровать сотрудников в зависимости от значений их атрибутов. В результате должно получиться что-то по типу этого:

    Начинаем

    Перво-наперво создаем главный класс Company, откуда будет происходить запуск приложения:

    В этом классе будем расширять возможности класса Application. Из него нам нужен главным образом метод start(), в котором будет происходить основное действие (будем пропускать ошибки, возникающие в этом методе; другими словами, если что-то пойдет не так, наше окно не закроется, но в консоли появится StackTrace ошибки):
    Отлично. Для того, чтобы работать с представителями сотрудников компании, создадим класс User: объекты этого класса и будут выступать в роли сотрудников.

    Создаем

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

    Что мы только что сделали: мы добавили сцену (scene) размером , дали ей название «Company». На нашей сцене присутствует группа root, которая по своей сути является «контейнером», который будет содержать в себе все кнопки.


    Добавим выпадающий список с нашими сотрудниками. Создадим HBox, в который положим наш выпадающий список ComboBox userBox и кнопку, которая будет выдавать информацию о сотруднике (сам HBox поместим в VBox):

    HBox — это набор кнопок, текстов, полей для ввода, каждый объект которого расположен последовательно горизонтально. Аналогичный ему, VBox является тем же самым, но хранит свои объекты (children) по вертикали. Мы будем использовать следующую схему: создатим VBox, в который будем класть несколько HBox’ов, в каждый из которых положим последовательность кнопок и полей.

    ComboBox — это сам просто выпадающий список.

    Теперь мы хотим создать кнопку, которая будет выдавать информацию о выбранном сотруднике. Добавим саму кнопку (Button) и текстовое поле (TextField), в которое будет выводиться текст. Эти два объекта добавим в HBox:

    Но пока эта кнопка ничего не делает. Чтобы она что-то делала, необходимо ей присвоить действие:

    Дальнейшие действия

    Абсолютно аналогичным образом добавляем еще два HBox’а: во втором будет происходить изменение зарплаты, в третьем — добавляние нового сотрудника. В силу того, что логика здесь абсолютно та же самая, пропустим объяснения этих моментов и сразу покажем результат:

    Фильтры

    Теперь добавим «фильтрацию» сотрудников по признакам. Опять же, списки для фильтров будем добавлять с использованием ComboBox по той же самой логике.

    Класс Company (главный)
    Класс User

    Что это было

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

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

    1. JavaFX 8 — Oracle Help Center
    2. Немного о создании и исторических модификациях JavaFX
    3. Замечательная статьяvedenin1980 про StreamAPI и -выражения

    Могу ли я создать окно в Java без кнопок заголовков?

    Можно ли создать в Java какой-либо объект Window, имеющий рамку и границу, но без кнопок заголовков (свернуть, восстановить, закрыть).

    Естественно, я не могу использовать undecorated установка. Далее в окне необходимо:

    • Иметь визуализированную платформу границу
    • Есть заголовок
    • Не имеют заголовков кнопок. Если понадобится, я позабочусь об утилизации окна программно.
    • Использовать по умолчанию или System Смотри и чувствуй

    Изучаем Java

    Вы здесь: Главная >> Java-самоучитель >> Формы и диалоговые окна в Java

    Обучающие курсы:

    Формы и диалоговые окна в Java

    Формы

    Формы (фреймовые окна) создаются на основе классов Frame и JFrame. Создать форму можно с помощью мастера (его значок Frame располагается на той же вкладке, что и значок Panel). Рассмотрим пример создания формы с помощью мастера.

    1. Создайте приложение с именем проекта и заголовком окна MyFrame.
    2. Выберите команду File — >New и в секции General выберите значок Frame Откроется окно, показанное на рис. 9.8.

    Рис 9.8. Диалоговое окно Frame Wizard

    3. Выберите все, как на рисунке, и щелкните на кнопке ОК.
    4. Измените компоновку формы 1 на XYLayout.
    5. Добавьте в форму 1 (главную форму —класс Framel) две кнопки JButton со значениями свойства Text, равными «Показать» и «Скрыть».
    6. Добавьте в конструктор класса Frame2 следующий код.
    this.setSize(new Dimension(300, 300));
    this.setTitle(«Новое окно»);
    В этом коде мы устанавливаем размер созданного окна, являющегося экземпляром класса Frame2, и определяем заголовок для этого окна.
    7. Теперь добавьте после объявления всех компонентов в классе Framel следующий код. private Frame2 myFrame = new Frame2();
    8. Создайте обработчики события actionPerformed для обеих кнопок в форме 1 (листинг 9.5).

    Листинг 9.5
    Создание обработчики события для кнопок в форме 1

    public void jButtonl_actionPerformed(ActionEvent e) <
    myFrame.setVisible(true);
    >
    public void jButton2_actionPerformed(ActionEvent e) <
    myFrame.setVisible(false);
    >

    Диалоговые окна, окна сообщений и окна запроса

    Альтернатива формам — диалоговые окна. Они создаются на основе классов Dialog (java.awt) и JDialog (javax.swing). Мастер для создания заготовки диалогового окна открывается так: выберите значок Dialog на вкладке General окна Object Gallery, которое открывается с помощью команды File -> New. Откроется следующее диалоговое окно (рис. 9.9).

    Рис 9.9 Диалоговое окно Dialog Wizard

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

    — JColorChooser. Окно выбора цвета. Его мы уже кратко рассматривали ранее (пакет javax.swing, секция Swing Containers)
    — JFileChooser. Окно выбора файла (пакет javax.swing, секция Swing Containers).
    — JOptionPane – набор диалоговых окон, которые представляют собой модальные окна (т.е. такие, которые не позволяют передавать фокус другим окнам приложения, пока в них не будут выполнены необходимые действия и они не будут закрыты): окна подтверждения, окна ввода и др. (пакет javax.swing, секция Swing Containers).

    Диалоговое окно JColorChooser вызывается с помощью метода showDialog. Вот как выглядит это диалоговое окно с заголовком «Выбор цвета текста».

    Рис. 9.10. Диалоговое окно JColorChooser с заголовком Выбор цвета текста

    Диалоговое окно JFileChooser предусматривает три метода для открытия данного окна в разных вариациях: showDialog — простое отображение этого окна (т.е. с установлением заголовка окна и имени кнопки), showCpenDialog — отображение окна открытия файла — значение строки заголовка окна и кнопки, равное Open (рис. 9.11).
    Метод showSaveDialog — отображение окна сохранения файла — значение строки заголовка окна и кнопки, равное Save (рис 9.12).

    Рис. 9.11. Диалоговое окно Open

    Рис. 9.12. Диалоговое окно Save

    Компонент JOptionPane.
    Можно создать свое диалоговое окно с помощью этого компонента, а можно использовать стандартные окна (два типа таких окон мы рассмотрим — окна сообщений и окна запроса).

    Приведем пример использования этого компонента.

    1. Создайте приложение с именем проекта JOptionPane и таким же заголовком окна.
    2. Измените компоновку на компоновку XYLayout.
    3. Добавьте компонент JOptionPane к значку UI в окне структуры.
    4. Добавьте в форму три компонента JButton со свойствами Text, равными «showMessageDialogs», showConfirmDialogs» и «showInputDialogs», и компонент JLabel со свойством Text, равным » «.
    5. Создайте для кнопок обработчики событий actionPerformed (листинг 9.6).

    Листинг 9.6.
    Создание обработчика событий

    Разберем этот код.
    Есть пять типов сообщений:

    ERROR_MESSAGE (сообщение об ошибке),
    INFORMAT10N_MESSAGE (информационное сообщение),
    PLAIN_MESSAGE (свое сообщение без каких-либо отличительных знаков — например, значка),
    QUESTI0N_MESSAGE (вопрос пользователю) и
    WARNING__MESSAGE (предупредительное окно).

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

    Далее представлены все диалоговые окна, которые появляются на экране, в качестве картинок из файлов my.gif и picture.gif. Также представлены измененные картинки «Водяные лилии» и «Закат», которые прилагаются к набору картинок WindowsХР (рис. 9.13- 9.21).

    Рис. 9.13. Информационное сообщение

    Рис. 9.14. Сообщение об ошибке

    Рис. 9.15. Сообщение с вопросом

    Рис. 9.16. Восклицательное сообщение

    Рис. 9.17. Сообщение прочего типа

    Рис. 9.18. Информационное окно с кнопками подтверждения или отказа

    Рис. 9.19. Окно с требованием обязательного выбора одного из двух вариантов

    Рис. 9.20. Окно с предложением выбрать значение из списка

    Рис. 9.21. Окно для ввода информации

    Сергей Владимирцев
    11.03.2011

    Цукерберг рекомендует:  Золотой запас Python
  • Понравилась статья? Поделиться с друзьями:
    Все языки программирования для начинающих