Java приложение с графическим интерфейсом. Краткий обзор GUI-фреймворков для Java и мое первое простенькое GUI-приложение на Swing. Визуальные библиотеки на практике
Предуведомление
В отличие от предыдущих занятий, где мы в основном действовали по принципу «делай как я» и рассказывали о концепциях и технических деталях что называется «на пальцах», стиль изложения, начиная с этого занятия несколько изменится и будет более техническим.
Этого, увы, не избежать, т.к. рано или поздно мы должны будем прийти к такой точке, после которой подход «на пальцах» становится уже несостоятельным. Сейчас такой момент наступает. Так что давайте соберемся с духом, засучим рукава и приступим.
На предыдущем занятии () мы сформировали и вывели на экран монитора графическое окно и попутно решили некоторые задачи, касающиеся его внешнего вида и расположения. Теперь мы обсудим то, что осталось «за кадром».
Вы, вероятно, обратили внимание на то, что в начале исходного кода есть две следующие строчки:
import java.awt.*;
import javax.swing.*;
Здесь надо немного задержаться. Вспомним, что ранее мы упоминали о том, что среда программирования Java включает в себя множество библиотек, предназначенных для поддержки сети, графики, работы с базами данных, обмена сообщениями и т.д. Именно библиотеки доставляют Java всю мощь и универсальность.
В Java вместо термина «библиотека» используется понятие «пакет». Указанные выше строки как раз и подключают необходимые пакеты для формирования графического интерфейса. Позже вы увидите, что мы будем использовать и другие пакеты, но сейчас нам достаточно указанных двух.
Пакеты включают в себя необходимые классы и интерфейсы (об интерфейсах мы расскажем в свое время), обеспечивающие ту или иную функциональность будущего приложения. Наличие звездочки («*») указывает на то, что программист импортирует все содержимое пакета, без точного указания входящих в него классов или интерфейсов. Может показаться, что в случае больших пакетов, итоговый объектный код может оказаться чересчур большим, но беспокоиться не стоит: компилятор Java достаточно «умен», чтобы использовать только то, что действительно необходимо вашей программе; все, что программе не нужно, компилятор включать в объектный код попросту не станет. Если хотите, вы можете использовать несколько иную форму подключения пакетов, например,
import java.awt.Window;
import javax.swing.JFrame;
но это предполагает, что программист уже хорошо знает структуру и возможности этих пакетов. Мы будем пользоваться более простой формой подключения пакетов, указанной ранее.
Импортирование (подключение) пакета к разрабатываемой программе производится ключевым словом import, после которого идет имя пакета. Каждый пакет должен импортироваться отдельно (т.е. нельзя написать import java.awt.*, javax.swing.*;). Конечно, объем исходного кода при этом несколько увеличивается, но очень незначительно. Все классы и интерфейсы, составляющие вашу программу, должны располагаться строго после конструкций import, иначе компилятор сгенерирует сообщение об ошибках компиляции.
Первый пакет (начинающийся с java.awt) обеспечивает прежде всего взаимодействие программ на Java с графической подсистемой операционной системы. Вспомните, что Java является кроссплатформенным языком программирования и генерирует единый объектный код вне зависимости от операционной системы, на которой этот код будет выполняться. Поэтому Java «вынуждена» обращаться к ресурсам, предоставляемым той операционной системой, которая установлена на компьютере пользователя. Один из таких ресурсов - графика (кроме графики Java обращается к «услугам» операционной системы для доступа к файловой системе и другим ресурсам). Так вот, пакет java.awt.* позволяет графическим интерфейсам, написанным на Java задействовать графические возможности операционной системы и отображаться графическим объектам, созданным в программах Java, на экране монитора. Здесь мы немного задержимся.
Все графические компоненты в Java подразделяются на две категории: легковесные (lightweight) и тяжеловесные (heavyweight). Подавляющее большинство графических компонентов (кнопки, списки, деревья, метки, таблицы и т.д.) являются легковесными. Это означает, что операционная система абсолютно ничего о них не знает и даже не «подозревает» об их существовании. Легковесные компоненты принадлежат окнам (подобных тому, что мы выводили на предыдущем занятии) и отображаются в этих окнах.
Если мы хотим отобразить в окне кнопку, то нам достаточно определить ее кодом, подобным следующему
JButton buttonPressMe = new JButton («Нажми меня»);
и разместить ее в указанном месте окна (соответствующие детали будут описаны позже). Кнопка – легковесный объект и операционная система не имеет о кнопке никаких сведений (для операционной системы кнопка вообще не существует). О кнопке «знает» только окно, в котором она размещена. Окно отрисовывает кнопку, перехватывает события, происходящие с кнопкой, перерисовывает кнопку если она была чем-либо заслонена и т.д. А вот само окно как таковое – о нем операционная система осведомлена и именно потому, что окно – тяжеловесный компонент. Только окно имеет доступ к ресурсам операционной системы (в частности – графическим).
Посмотрите на исходный код. Когда мы вычисляли координаты верхнего левого угла окна перед выводом его на экран, нам нужно было узнать разрешение экрана
Dimension sSize = Toolkit.getDefaultToolkit ().getScreenSize ()
Что может предоставить такую информацию? Операционная система и только она! Далее, мы использовали код
try {UIManager.setLookAndFeel
(UIManager.getSystemLookAndFeelClassName ());
catch (Exception lfe) {}
для того, чтобы внешний вид окна соответствовал стандарту, принятому в конкретной операционной системе. Что может предоставить такую информацию? Опять же – операционная система! Так что для создания графических интерфейсов без пакета java.awt.* нам не обойтись.
При выводе окна на экран операционная система выделяет окну необходимые ресурсы (прежде всего – память) и окно становится видимым. Дальше в дело вступают легковесные компоненты и вся дальнейшая работа осуществляется практически только с ними.
Второй импортируемый пакет (начинающийся с javax.swing) отвечает за формирование легковесных графических интерфейсов (есть и другие пакеты, но этот – самый важный и практически всегда используемый). Изучать и осваивать этот пакет мы будем постепенно, т.к. он весьма большой и достаточно сложный. Этим мы начнем заниматься на следующем занятии, а пока обратимся к следующей строке исходного кода:
public class MoneyForNothing extends JFrame {
Здесь новыми являются два элемента: ключевое слово extends и слово JFrame.
Ключевое слово extends (в переводе означает «расширить», но по смыслу близко к слову «наследует» или к словосочетанию «заимствовать свойства и поведение») выражает фундаментальную концепцию объектно-ориентированного программирования (или проще говоря, программирования, основанного на классах). Эта концепция носит название «наследование». С этим надо хорошенько разобраться.
Помните, на одном из первых занятий () мы обсуждали концепцию классов и в качестве примера использовали двигатель автомобиля. При всем разнообразии двигателей и их конструкций (речь, разумеется, идет о двигателях внутреннего сгорания), почти все эти двигатели похожи друг на друга: в каждом из них есть цилиндры, поршни, коленвалы, клапаны и т.д.
Конечно, громадный дизель для танкера не сравнить с крошечным спиртовым двигателем для авиамодели, но они (если так можно выразиться) – пусть и дальние, но родственники. У них общий предок – некий абстрактный двигатель, а сами двигатели – его потомки (пусть даже очень и очень дальние).
В программировании такой предок обычно называется «родитель» или «суперкласс», т.е. класс, от которого произошли другие классы. Имя суперкласса указывается непосредственно после extends. Таким образом, в переводе на обычный язык, вышеприведенный фрагмент кода можно прочитать так: «класс... расширяет класс JFrame», «класс... наследует класс JFrame» или «класс... заимствует свойства и поведение класса JFrame». В классе JFrame определены основные свойства и поведение «стандартных» графических окон. Сам класс JFrame находится в пакете javax.swing.* и именно его мы и импортировали в начале программы.
JFrame – это родитель (в терминологии Java – суперкласс) графических окон (есть еще и другие окна, например, диалоговые, но о них мы поговорим в свое время). Если обратиться к документации по Java , то в ней вы обнаружите, что в классе JFrame имеются несколько конструкторов, полей и около двух десятков методов, которые определяют поведение некоего «стандартного» окна. Таким образом, наш класс с именем MoneyForNothing является наследником класса JFrame (обычно говорят не о наследниках, а о потомках или о дочерних классах).
Обратите внимание, что класс JFrame сам в свою очередь является наследником нескольких классов (большая часть которых принадлежит уже знакомому нам пакету java.awt.*):
Чтобы уже не возвращаться к этому вопросу, обращаем ваше внимание на то, что в вершине иерархии наследования Java лежат классы из пакета java.lang.*. Это единственный пакет из JDK, который не нужно явно импортировать – он всегда импортируется автоматически. Судя по этой «лесенке», класс JFrame является пра-пра-правнуком java.lang.Object (картинка, приведенная выше по-научному называется иерархией классов).
Все компоненты графического пользовательского интерфейса (сокращенно GUI, от Graphical User Interface), которые, напомним, являются легковесными элементами, должны быть размещены внутри основного окна – наследника JFrame. Сейчас у нас никаких компонентов нет, но скоро они появятся – обещаем.
А теперь «пробежимся» напоследок по нашему исходному коду, который выглядит так:
// Конструктор
public MoneyForNothing () {
setTitle ("Добро пожаловать в Money for Nothing");
setSize (new Dimension (600, 400));
Dimension sSize = Toolkit.getDefaultToolkit ().getScreenSize (),
fSize = getSize ();
if (fSize.height > sSize.height) {fSize.height = sSize.height;}
if (fSize.width > sSize.width) {fSize.width = sSize.width;}
setLocation ((sSize.width - fSize.width)/2,
(sSize.height - fSize.height)/2);
setDefaultCloseOperation (EXIT_ON_CLOSE);
setVisible (true);
Прежде всего, мы задаем заголовок окна (метод setTitle («...»)). Затем задаются размеры окна по горизонтали и вертикали (метод setSize (...)). После определения разрешения экрана монитора расчитываются координаты верхнего левого угла нашего окна и окно выводится (метод setLocation (...)) в указанном месте экрана.
После этого мы определяем что нужно делать при закрытии окна в системном меню; в данном случае видно, что приложение должно завершить свою работу (EXIT_ON_CLOSE). За этой короткой и простой строчкой на самом деле скрывается удивительно интересный и интригующий мир обработки событий. Скажем сразу: понимание механизма обработки событий в Java – ключевой момент в разработке графических приложений и начиная со следующего занятия мы займемся как раз именно этим.
Наконец, последняя строка (метод setVisible (true)) делает окно видимым.
Конечно, некоторые детали мы не опустили, но наша цель состоит не в том, чтобы досконально рассказать все и обо всем – для этого есть документация, справочники и учебники. Наша цель – дать общее направление, исходную точку, отталкиваясь от которой вы (при желании и достаточном упорстве) сможете сами развивать свои программы в нужных направлениях и наполнять их необходимой функциональностью.
На этом наше занятие подходит к концу. Самое важное, что вы должны извлечь из него – концепция наследования (заимствования). Это, действительно, основополагающая концепция. Без нее в Java нельзя создать сколько нибудь сложную и полезную программу, так что не торопитесь двигаться дальше, а еще раз внимательно просмотрите и обдумайте все, что мы к этому моменту изучили.
Удачи и до скорой встречи!
Итак, логика Game of Life реализована. Хотелось бы насладиться процессом созерцания многообразия форм «Жизни» на экране своего монитора. Что для этого понадобится?
Само окно с меню и кнопками, а также его поведение будут создаваться с помощью библиотеки Swing. Прорисовка же процесса эволюции нашей «Жизни» — посредством библиотеки AWT (точнее, Java 2D). Это два основных пакета для создания графических интерфейсов на Java.
Работа AWT изначально основана на так называемых peer-интерфейсах. Суть состоит в том, что при необходимости вывода на экран объекта Java, операционной системой создается парный ему графический объект, который, собственно, и отображается. Эти два объекта взаимодействуют между собой во время работы программы. Такая реализация приводит к тому, что для каждой платформы приходится выпускать собственный JDK.
Позднее в AWT были созданы компоненты, не использующие peer-интерфейсы — «легкие» (lightweight) компоненты. Библиотека этих компонентов была названа Swing. То есть Swing, по сути, является расширением AWT.
Сама же AWT была дополнена новыми средствами рисования и вывода изображений, получившими название Java 2D.
Перечислю с коротким описанием основные элементы Swing.
Базовым строительным блоком всей библиотеки визуальных компонентов Swing является JComponent . Это суперкласс каждого компонента. Он является абстрактным классом, поэтому в действительности вы не можете создать JComponent, но он содержит буквально сотни функций, которые каждый компонент Swing может использовать как результат иерархии классов.
JFrame (окно приложения) — основной контейнер, позволяющий добавлять к себе другие компоненты для их организации и предоставления пользователю. JFrame выступает в качестве моста между независимыми от ОС Swing-частями и реальной ОС, на которой они работают. JFrame регистрируется как окно в ОС и таким образом получает многие из знакомых свойств окна операционной системы.
JMenu/JMenuItem/JMenuBar — предназначены для разработки системы меню в JFrame. Основой любой системы меню является JMenuBar, каждый JMenu и JMenuItem создается с ним. JMenu является подклассом JMenuItem. Однако по внешнему виду они имеют отличие: JMenu используется для содержания других JMenuItem и JMenu; JMenuItem при выборе активизирует действие.
JLabel (метка) — предназначен для описания (текстового или графического) других элементов.
JButton (кнопка) — основной активный компонент, позволяющий выполнить какие-либо действия при ее нажатии. Кроме стандартных методов, управляющих отображением компонента, содержит группу методов для управления своим состоянием (активная/неактивная, выбранная/не выбранная, мышка сверху/мышки нет, нажата/отжата).
JTextField (текстовое поле) — позволяет пользователю вводить текстовые данные, которые могут быть обработаны в программе.
JTextArea развивает JTextField, позволяя вводить несколько строк.
JPasswordField (поле для ввода пароля) — разновидность JTextField, позволяющая скрывать вводимые символы.
JComboBox (комбинированный список) — позволяет пользователю выбрать элемент из существующего списка (или добавить к списку новый элемент).
JCheckBox (флажок)и JRadioButton (переключатель) — предоставляют пользователю варианты для выбора. JRadioButton обычно группируются вместе для предоставления пользователю вопроса с принудительным ответом (ответы взаимоисключающие — может быть только один ответ на вопрос). Как только вы выбрали JRadioButton, вы не можете снять его отметку до тех пор, пока не выберете другой вариант из группы. JCheckBox работает иначе. Он позволяет отмечать/снимать отметку с варианта в любое время и выбирать несколько ответов на вопрос. Классом, который позволяет группировать вместе компоненты JCheckBox или JRadioButton, является класс ButtonGroup .
JSlider — элемент для выбора числового значения из графически представленного диапазона.
JSpinner — предназначен для выбора из группы значений. В этом он аналогичен JComboBox, хотя их использование не должно быть взаимозаменяемо. Вы должны использовать JSpinner только для логически последовательных вариантов — числа и даты идеально подходят для этого. JComboBox, с другой стороны, более хороший выбор для представления кажущихся случайными вариантов, которые не имеют взаимосвязи между собой.
JToolBar выступает как контейнер для других компонентов (JButtons, JComboBoxes и т.д.), которые совместно образуют панели инструментов, встречающиеся в большинстве приложений. Панели инструментов позволяют программе размещать часто используемые команды в удобном месте и группировать их. Обычно кнопки панели инструментов соответствуют командам в меню.
JToolTip — это небольшие «пузырьки», которые всплывают, когда вы наводите и держите курсор мышки над чем-нибудь. Они могут быть очень полезны в приложениях, предоставляя подсказки для элементов, детализируя информацию или даже показывая полный текст элемента в сжатых UI. Они активизируются в Swing, если оставить курсор мышки над компонентом на определенное количество времени; обычно они появляются примерно через секунду после остановки мышки и остаются видимыми до тех пор, пока курсор остается над компонентом.
JOptionPane — класс для предоставления UI-разработчикам способа выдачи простых сообщений (об ошибке или другой информации) и быстрого получения данных (например, имени или номера).
JScrollPane — Swing-компонент для обработки всех действий по прокрутке.
JList является полезным компонентом для предоставления пользователю многих вариантов для выбора. Вы можете представлять его как расширение JComboBox. JList предоставляет больше вариантов и добавляет возможность выбора нескольких вариантов. Выбор между JList и JComboBox часто заключается в следующем: если вам требуется возможность множественного выбора или имеется более 15 вариантов (хотя это число не является общим правилом), вы должны всегда выбирать JList. Вы должны использовать JList совместно с JScrollPane, поскольку он может предоставлять больше вариантов, чем помещается в видимой области. JList имеет также модель выбора, которую вы можете установить в различные типы выбора вариантов. Такими типами являются: одиночный выбор (вы можете выбрать только один вариант), одиночный интервал (вы можете выбрать смежные варианты, но в любом их количестве) и множественный интервал (вы можете выбрать любое число вариантов в любых комбинациях).
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Размещено на http://www.allbest.ru/
ВВЕДЕНИЕ
Последние несколько лет разработчики прилагали массу усилий, чтобы интегрировать графику и анимацию в свои апплеты и приложения Java. Используя интерфейсы прикладного программирования java.awt и javax.swing, разработчики могут реализовывать гораздо более сложные графические приложения, включая игры, хранители экрана, экранные заставки и трехмерный графический пользовательский интерфейс.
Цель работы.Расчетно-графическая работа посвящена построению приложений с использованием графического интерфейса библиотек java.awt и javax.swing.
Актуальность.На сегодняшний деньграфика имеет немаловажное значение для языков программирования. Она позволяет визуализировать любые программы, что придает яркость и удобство для использования тех или иных программ. Позволяет создавать яркие и интересные Web-страницы, удобна при разработке баз данных, написании мобильных и компьютерных игр.
1. ПОСТАНОВКА ЗАДАЧИ
Графический пользовательский интерфейс (GUI) - основной способ взаимодействия конечных пользователей с java-приложением. Для разработки прикладного программного обеспечения на языке Java, а точнее графического интерфейса приложений, обычно используются пакеты AWT и Swing.
AWT (для доступа загружается пакет java.awt) содержит набор классов, позволяющих выполнять графические операции и создавать оконные элементы управления, подобно тому, как это делается в VBA и Delphi;
Swing (для доступа загружается пакет javax.swing) содержит новые классы, в основном аналогичные AWT. К именам классов добавляется J (JButton, JLabel и др.).
На данный момент основные классы для построения визуальных интерфейсов содержатся в пакете Swing. Из пакета AWT используются классы для обработки сообщений. Простейшее графическое приложение приведено ниже.
import javax. swing.*;
public final class HelloWorld implements Runnable {
public static void main(String args) {
//Swing имеет собственный управляющий поток (т.н. dispatching thread),
//который работает параллельно с основным (в котором выполняется main())
//потоком. Если основной поток закончит работу (метод main завершится),
//поток отвечающий за работу Swing-интерфейса может продолжать свою работу.
//И даже если пользователь закрыл все окна, программа продолжит свою работу
//(до тех пор, пока жив данный поток). Начиная с Java 6, когда все
//компоненты уничтожены, управляющий поток останавливается автоматически.
//Запускаем весь код, работающий в управляющем потоке, даже инициализацию:
SwingUtilities.invokeLater (new HelloWorld());
public void run() {
// Создаем окно с заголовком "Hello, World!"
Frame f = new JFrame ("Hello, World!");
// Ранее практиковалось следующее: создавался listener и регистрировался
// на экземпляре главного окна, который реагировал на windowClosing()
// принудительной остановкой виртуальной машины вызовом System.exit()
// Теперь же есть более "правильный" способ задав реакцию на закрытие окна.
// Данный способ уничтожает текущее окно, но не останавливает приложение. Тем
// самым приложение будет работать пока не будут закрыты все окна.
f.setDefaultCloseOperation (JFrame. DISPOSE_ON_CLOSE);
// однако можно задать и так:
// f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
// Добавляем на панель окна нередактируемый компонент с текстом.
// f.getContentPane().add (new JLabel("Hello, World!")); - старый стиль
f.add(new JLabel("Hello World"));
// pack() "упаковывает" окно до оптимального размера
// всех расположенных в нем компонентов.
// Показать окно
f.setVisible(true);
Технология Swing предоставляет механизмы для управления следующими аспектами представления:
Клавиатура (Swing предоставляет способ перехвата пользовательского ввода);
Цвета (Swing предоставляет способ менять цвета, которые вы видите на экране);
Текстовое поле для ввода (Swing предоставляет текстовые компоненты для обработки всех повседневных задач).
JComponent
Базовым классом всей библиотеки визуальных компонентов Swing является JComponent. Это суперкласс других визуальных компонентов. Он является абстрактным классом, поэтому в действительности вы не можете создать JComponent, но он содержит сотни функций, которые каждый компонент Swing может использовать как результат иерархии классов. Класс JComponent обеспечивает инфраструктуру окрашивания для всех компонентов, он знает, как обрабатывать все нажатия клавиш на клавиатуре, его подклассы, следовательно, должны только прослушивать определенные клавиши. Класс JComponent также содержит метод add(), который позволяет добавить другие объекты класса JComponent, так можно добавить любой Swing-компонент к любому другому для создания вложенных компонентов (например, JPanel, содержащую JButton, или даже более причудливые комбинации, например JMenu, содержащее JButton).
JLabel
Самым простым и в то же время основным визуальным компонентом в библиотеке Swing является JLabel, или «метка». К методам этого класса относится установка текста, изображения, выравнивания и других компонентов, которые описывает метка:
get/setText() - получить/установить текст в метке;
get/setIcon() - получить/установить изображение в метке;
get/setHorizontalAlignment - получить/установить горизонтальную позицию текста;
get/setDisplayedMnemonic() - получить/установить мнемонику (подчеркнутый символ) для метки;
get/setLabelFor() - получить/установить компонент, к которому присоединена данная метка; когда пользователь нажимает комбинацию клавиш Alt + мнемоника, фокус перемещается на указанный компонент.
JButton
Основным активным компонентом в Swing является Jbutton.
Методы, используемые для изменения свойств JButton, аналогичны методам JLabel (вы обнаружите, что они аналогичны для большинства Swing-компонентов). Они управляют текстом, изображениями и ориентацией:
get/setText() - получить/установить текст в кнопке;
get/setIcon() - получить/установить изображение в кнопке;
get/setHorizontalAlignment() - получить/установить горизонтальную позицию текста;
get/setVerticalAlignment() - получить/установить вертикальную позицию текста;
get/setDisplayedMnenomic() - получить/установить мнемонику (подчеркнутый символ), которая в комбинации с кнопкой Alt вызывает нажатие кнопки.
JFrame
Класс JFrame является контейнером, позволяющим добавлять к себе другие компоненты для их организации и предоставления пользователю.
JFrame выступает в качестве моста между независимыми от конкретной операционной системы Swing-частями и реальной операционной системой, на которой они работают. JFrame регистрируется как окно и таким образом получает многие свойств окна операционной системы: минимизация/максимизация, изменение размеров и перемещение. Хотя выполнении лабораторной работы достаточно считать JFrame палитрой, на которой вы размещаете компоненты. Перечислим некоторые из методов, которые вы можете вызвать в JFrame для изменения его свойств:
get/setTitle() - получить/установить заголовок фрейма;
get/setState() - получить/установить состояние фрейма (минимизировать, максимизировать и т.д.);
is/setVisible() - получить/установить видимость фрейма, другими словами, отображение на экране;
get/setLocation() - получить/установить месторасположение в окне, где фрейм должен появиться;
get/setSize() - получить/установить размер фрейма;
add() - добавить компоненты к фрейму.
Схемы, модели и события
При построении визуальных приложений в Java нельзя просто случайно разместить их на экране и ожидать от них немедленной работы. Компоненты необходимо разместить в определенные места, реагировать на взаимодействие с ними, обновлять их на основе этого взаимодействия и заполнять данными. Для эффективной работы с визуальными компонентами необходима установка следующих трех архитектурных составляющих Swing.
Схемы (layout). Swing содержит множество схем, которые представляют собой классы, управляющие размещением компонентов в приложении и тем, что должно произойти с ними при изменении размеров окна приложения или при удалении или добавлении компонентов.
События (event). Программа должна реагировать на нажатия клавиш, нажатия кнопки мыши и на все остальное, что пользователь может сделать.
Модели (model). Для более продвинутых компонентов (списки, таблицы, деревья) и даже для некоторых более простых, например, JComboBox, модели - это самый эффективный способ работы с данными. Они удаляют большую часть работы по обработке данных из самого компонента (вспомните MVC) и предоставляют оболочку для общих объектных классов данных (например, Vector и ArrayList).
Особое внимание, в связи с необходимостью изображения динамических сцен на визуальных компонентах необходимо уделить классу Graphics 2D.
Индивидуальное задание расчетно-графической работы: Изобразить в окне приложения отрезок, вращающийся в плоскости фрейма вокруг точки, движущейся по отрезку.
графический интерфейс java компонент
2. РЕАЛИЗАЦИЯ ЗАДАЧИ НА ЯЗЫКЕ ВЫСОКОГО УРОВНЯ JAVA
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
* Задача 4. Изобразить в окне приложения (апплета ) отрезок , вращающийся в
* плоскости фрейма вокруг точки движущейся по отрезку .
public class LB4 extends java.applet.Applet implements Runnable {
private static final long serialVersionUID = 1L;
private int w, h;
private BufferedImage bi;
private Graphics2D big;
private boolean stop = false;
private Thread timer = null;
private Color fonColor = Color.WHITE ;
private Color segmentColor = Color.LIGHT_GRAY ;
private Color pointColor = Color.GREEN ;
private Segment segment;
// начальное расположение рисунка
private double lengthSegment;
// направление смещения оси вращения
private double movePoint = -1;
private double shift = 0;
private double speedPoint = 1;
// скорость изменения положения в пространстве
private int speedRepaint = 30;
// угол на который происходит изменения положения отрезка
private int grad = 15;
/** Этот метод будет вызван после загрузки апплета */
public void init() {
// Создаем объекты и устанавливаем начальные значения .
Dimension dim = getSize();
// Создаем Segment, задавая длину
lengthSegment = (double) Math.min (w, h) / 3;
segment = new Segment(lengthSegment, lengthSegment / 2, grad,
segmentColor, pointColor, fonColor);
bi = (BufferedImage) createImage(w, h);
big = bi.createGraphics();
big.setRenderingHint(RenderingHints.KEY_ANTIALIASING ,
RenderingHints.VALUE_ANTIALIAS_ON );
// Создаем поток , который будет периодически вызывать метод update.
timer = new Thread(this);
} catch (Exception e) {
System.out .println(e);
} // end init
// Этот метод выполняет перерисовку окна апплета
public void update(Graphics g) {
// Получаем указатель на объект Graphics2D
Graphics2D g2 = (Graphics2D) g;
// Рисуем готовое изображение на экране
g2.drawImage(bi, 0, 0, this);
} catch (Exception error) {
System.out .println(error.getMessage());
private void grawSegment() {
* //Очищаем рисунок big.setBackground(Color.BLUE); big.clearRect(0, 0,
// Рисуем отрезок
shift += movePoint * speedPoint;
if (shift < -lengthSegment / 2) {
movePoint *= -1;
shift = -lengthSegment / 2;
} else if (shift > lengthSegment / 2) {
movePoint *= -1;
shift = lengthSegment / 2;
segment.setPos(shift, speedPoint);
segment.rotate();
big.drawImage(segment.getSegment(), null, 0, 0);
// Этот метод выполняется в отдельном потоке (timer).
// Он вызывает перерисовку окна апплета каждую секунду .
public void run() {
Thread.currentThread ();
Thread.sleep (speedRepaint);
} catch (Exception err) {
// Этот метод выполняется если пользователь покинул страницу
// с апплетом . Он останавливает поток (timer) и, соответственно ,
// перерисовку окна апплета.
public void stop() {
// Этот метод выполняется когда пользователь попадает на страницу
// с апплетом. Он запускает парралельный поток (timer).
public void start() {
if (timer == null) {
timer = new Thread(this);
// Этот метод выполняется при закрытии страницы с апплетом.
public void destroy() {
super.destroy();
Thread.currentThread ();
// Ждем пока парралельный поток (timer) завершит работу.
Thread.yield ();
} // end destroy
} // end public class RotatingSegment
// создание отрезка
private static double x = 0;
final double RAD = 10;
private double length;
private BufferedImage segment;
private Color segmentColor;
private Color pointColor;
private Color backGroundColor;
private Rectangle2D.Double r;
private Ellipse2D.Double p;
private double rotationAxis;
private Point2D.Double center;
private double shift;
// угол на который происходит изменения положения отрезка
private int grad;
Segment(double length, double posPointRotating, int grad,
Color segmentColor, Color pointColor, Color backGroundColor)
throws Exception {
// проверяем параметры
if (length <= 0 || posPointRotating < 0 || length < posPointRotating)
throw new Exception(
"Ошибка: неверно задан параметр в классе Segment");
this.grad = grad;
this.segmentColor = segmentColor;
this.pointColor = pointColor;
this.backGroundColor = backGroundColor;
this.length = length;
// создаем рисунок
segment = new BufferedImage((int) length * 3, (int) length * 3,
BufferedImage.TYPE_INT_ARGB );
center = new Point2D.Double(length, 3 * length / 2);
// создаем отрезок
rotationAxis = center.x + posPointRotating - RAD / 2;
p = new Ellipse2D.Double(rotationAxis, center.y, RAD, RAD);
// устанавливаем цвет отрезка
g2.setColor(segmentColor);
// рисуем отрезок
// устанавливаем цвет точки
g2.setColor(pointColor);
// рисуем точку
// смещает точку вращения
public void setPos(double shiftX, double shiftY) {
// создаем отрезок
this.shift = shiftX;
center.y = center.y + shiftY * Math.sin (Math.toRadians (grad * x ));
r = new Rectangle2D.Double(center.x, center.y, length, RAD);
p = new Ellipse2D.Double(rotationAxis + shift, center.y, RAD, RAD);
// вращает отрезок
public void rotate() {
AffineTransform at = AffineTransform.getRotateInstance (
Math.toRadians (grad * (++x )), rotationAxis + RAD / 2 + shift,
// получаем графический контекст
Graphics2D g2 = segment.createGraphics();
// закрашиваем все заданным цветом
g2.setBackground(backGroundColor);
g2.clearRect(0, 0, (int) (3 * length), (int) (3 * length));
g2.setTransform(at);
g2.setColor(segmentColor);
// рисуем отрезок
// устанавливаем цвет точки
g2.setColor(pointColor);
// рисуем точку
// Возвращает изображение
public BufferedImage getSegment() {
3. ПРИМЕР РАБОТЫ ПРОГРАММЫ
Результат выполнения программы:
Рисунок 1. Результат выполнения программы
Рисунок 2. Результат выполнения программы
Рисунок 3. Результат выполнения программы
ЗАКЛЮЧЕНИЕ
Этим завершается наше рассмотрение графики на Java. В этой работе мы представили краткий обзор средств программирования двухмерной графики на Java. Мы представили приложение, которое демонстрируют использование геометрических фигур, текстур.
Мы обсудили некоторые графические возможности Java. Мы начали с краткого знакомства с фундаментальными основами графики, такими как системы координат и графические контексты. Затем мы обсудили средства Java 2D. Мы также вкратце рассказали, как использовать графические эффекты.
Вторая половина нашего знакомства с графическим программированием на Java. Используя графический интерфейс библиотек java.awt и javax.swing мы создали простой графический редактор, который вращает двумерный объект вокруг своей оси.
СПИСОК ЛИТЕРАТУРЫ
1. Х. М. Дейтел, П.Дж. Дейтел, С.И. Сантри - Технологии программирования наJava, книга 1 (графика, JAVABEANS, интерфейс пользователя)
2. Джуди Бишоп - Эффективная работа Java
3. James Gosling, Bill Joy, Guy Steele, Gilad Bracha - The Java Language Specification, Second Edition.
4. Tim Lindholm, Frank Yellin - The Java Virtual Machine Specification, Second Edition.
5. Гослинг Дж., Арнольд К. - Язык программирования Java
6. Информация с сайта www.ibm.com
7. Информация с сайта www.mexmat.sgu.ru
8. Информация с сайта www.uic.rsu.ru
Размещено на Allbest.ru
...Подобные документы
Структура организации графического интерфейса, объявление и создание слушателей событий с помощью анонимных классов. Представление данных для таблицы – класс AbstractTableModel. Визуализация ячеек таблицы. Два основных типа потоков ввода-вывода в Java.
лекция , добавлен 01.05.2014
Разработка графического редактора для рисования двухмерной и трехмерной графики, используя язык программирования Java и интерфейсы прикладного программирования Java 2D и Java 3D. Создание графического редактора 3D Paint. Основные методы класса Graphics.
курсовая работа , добавлен 19.11.2009
Описание пакета прикладной программы Net Beans 8.1. Разработка пользовательского интерфейса апплета. Создание рамочных окон на базе фреймов библиотеки java.swing. Изменение цвета текстовых данных. Проектирование и создание инфологической модели апплета.
контрольная работа , добавлен 11.07.2016
Сетевые возможности языков программирования. Преимущества использования Java-апплетов. Классы, входящие в состав библиотеки java.awt. Создание пользовательского интерфейса. Сокетное соединение с сервером. Графика в Java. Значения составляющих цвета.
курсовая работа , добавлен 10.11.2014
Java Foundation Classes, основные концепции. Исходная иерархия классов Abstract Window Toolkit. Представители пользовательского интерфейса. Обработка событий в JavaBeans. Элементы управления, многострочное поле JText. Листинг программы TextEditor.
курсовая работа , добавлен 26.06.2013
Выполнение Java-программы. Набор программ и классов JDK. Объектно-ориентированное программирование в Java. Принципы построения графического интерфейса. Компонент и контейнер графической системы. Апплеты как программы, работающие в среде браузера.
курсовая работа , добавлен 08.02.2011
Диаграмма консольного приложения табулирования функции. Отличие консольного приложения и приложения и GUI. Диаграмма классов для JFrameи JPanel. Создание простейшего фрейма в Java. Компоновка элементов интерфейса внутри фрейма. Цикл обработки событий.
лекция , добавлен 01.05.2014
Понятие и общая характеристика языка программирования РНР, принципы и этапы его работы, синтаксис и ассоциируемые массивы. Обработка исключений в языке Java. Работа с базами данных с помощью JDBC. Изучение порядка разработки графического интерфейса.
презентация , добавлен 13.06.2014
Разработка логической схемы базы данных автомобилестроительного предприятия. Инфологическое моделирование системы. Создание графического интерфейса пользователя для базы данных средствами языка программирования Java. Тестирование программных средств.
курсовая работа , добавлен 16.12.2013
Создание консольных приложений с использованием графического интерфейса пользователя. Содержание палитры компонентов программы С++ Builder. Использование возможностей объектно-ориентированного программирования, особенности редактора кода и форм в С++.
Описание презентации Создание графического интерфейса на Java Графические библиотеки по слайдам
Графические библиотеки Java В Java есть следующие пакеты для создания графических интерфейсов: Abstract Windows Toolkit (AWT) — поставляется с JDK, каждый AWT-компонент имеет свой визуальный компонент (peer) для конкретной ОС, переносимость обеспечивается пакетом java. awt. peer; ограничен набор графических компонентов; внешний вид зависит от ОС. Standard Widget Toolkit (SWT) – поставляется отдельно для конкретных ОС, включена в среду Eclipce, взаимодействуют с ОС с помощью peer-интерфейсов, в отличии от AWT, расширен ассортимент компонентов. Swing – поставляется с JDK, расширяет классы AWT, не зависит от peer-компонентов ОС. Java 3 D – трехмерная графика.
Тяжело- и легковесные компоненты Тяжеловесные (heavyweight) компоненты – Отрисовываются операционной системой – Большинство AWT -компонент Легковесные (ligntweight) компоненты – Отрисовываются java -кодом – Все Swing -компоненты, кроме окон верхнего уровня (окно приложения) Тяжеловесные компоненты всегда отрисовываются поверх легковесных
Архитектура Модель-Представление-Контроллер(MVC) Шаблон проектирования MVC предполагает разделение данных приложения, пользовательского интерфейса и управляющей логики на три отдельных компонента: модель, представление и контроллер – таким образом, что модификация каждого компонента может осуществляться независимо. Модель (model) хранит данные компонента и позволяет легко, не обращаясь к самому компоненту, изменять или получать эти данные. Вид (view) выводит данные на экран для представления их пользователю. Контроллер (controller) определяет, как должны реагировать вид и данные модели в ответ на действия пользователя.
Преимущества MVC К одной модели можно присоединить несколько видов, при этом не затрагивая реализацию модели. Например, некоторые данные могут быть одновременно представлены в виде электронной таблицы, гистограммы и круговой диаграммы. Не затрагивая реализацию видов, можно изменить реакции на действия пользователя (нажатие мышью на кнопке, ввод данных), для этого достаточно использовать другой контроллер. Ряд разработчиков специализируется только в одной из областей: либо разрабатывают графический интерфейс, либо разрабатывают бизнес-логику. Поэтому возможно добиться того, что программисты, занимающиеся разработкой бизнес-логики (модели), вообще не будут осведомлены о том, какое представление будет использоваться.
Взаимодействия между моделью, видом и контроллером Классическая модель Тесная связь между контроллером и моделью и контроллером и видом. Представление (вид) сопоставлено с единственным Контроллером и каждый Контроллер с единственным Представлением. Представление и Контроллер имеют прямую ссылку на Модель.
Пример MVC public class Model { private int int. Array = {1, 2, 3, 4, 5}; public String get. String. Array() { return «int. Array=» + Arrays. to. String(int. Array); } public void set. Int. Array(int index, int value) { this. int. Array = value; } } public class Controller { Model model = new Model(); View view = new View(); Controller(){ update. View(); } void set. Array. Value(int index, int value) { model. set. Int. Array(index, value); update. View(); } void update. View() { view. show. Array(model. get. String. Array()); } } public class View { public void show. Array(String array. String){ System. out. println(«View»); System. out. println(array. String); System. out. println(); } } public class User { public statc void main(String args) { Controller controller = new Controller(); controller. set. Array. Value(1, 4); } }
Модель Swing упрощает реализацию Модель не знает, с каким UI-представителем она сотрудничает и какой компонент ее использует устанавливает внешний вид и поведение для всех компонентов библиотеки связывается с моделью только через класс компонента. Представление-контроллер обрабатывает события пользователя и рисуют компонент на экране Кнопки, списки, таблицы, текстовые поля …
Компоненты интерфейса Button — кнопка; JCheck. Box — кнопка-флажок; JCombo. Box — выпадающий список; JLabel — метка, надпись; JList — список; JPassword. Field — текстовое поле для скрытого ввода; JProgress. Bar — компонент для отображения числа в некотором диапазоне; JRadio. Button — преключатели, радио-кнопки, обычно используется с компонентом Button. Group; JSlider — компонент позволяющий выбрать значение из заданного диапазона; JTable — таблица; JText. Field — однострочное текстовое поле; JText. Area — многострочное текстовое поле; JTree — дерево.
Контейнеры интерфейса Части пользовательского интерфейса, содержащие другие компоненты Контейнеры верхнего уровня: Frame, JFrame — окно приложения; JDialog — диалог приложения; JColor. Chooser — диалог выбора цвета; JFile. Chooser — диалог выбора файлов и директорий; File. Dialog — диалог выбора файлов и директорий (awt компонент). Простые контейнеры: JPanel — простая панель для группировки элементов, включая вложенные панели; JTool. Bar — панель инструментов (обычно это кнопки); JScrool. Pane — панель прокрутки, позволяющая прокручивать содержимое дочернего элемента; JDesktop. Pane — контейнер для создания виртуального рабочего стола или приложений на основе MDI (multple-document interface); JEditor. Pane , JText. Pane — контейнеры для отображения сложного документа как HTML или RTF; JTabbed. Pane — контейнер для управления закладками;
Создание окна import java. awt. *; class Too. Simple. Frame extends Frame{ public statc void main(String args){ Frame fr = new Too. Simple. Frame(); fr. set. Size(400, 150); // размер окна fr. set. Visible(true); // визуализация окна } // кнопка закрытия не работает } Swing
Окно с нестандартной иконкой import javax. swing. *; public class Frame. Closing extends JFrame { public Frame. Closing() { super(«Заголовок Окна»); // операция при закрытии окна set. Default. Close. Operaton(EXIT_ON_CLOSE); // при закрытии окна – выход // значок для окна set. Icon. Image(get. Toolkit(). get. Image(«icon. gif»)); //C: / icons / icon. png // вывод на экран set. Size(300, 100); // размеры окна ширина и высота set. Visible(true); // визуализация окна } public statc void main(String args) { new Frame. Closing(); } } Swing
Стандартные диалоговые окна Тип диалогового окна Описание NFORMATION_MESSAGE Диалоговое окно выводит информацию общего назначения со значком соответствующего вида WARNING_MESSAGE Диалоговое окно выводит на экран предупреждающую информацию со значком соответствующего вида QUESTION_MESSAGE Диалоговое окно вопроса для ввода информации ERROR_MESSAGE Диалоговое окно выводит на экран информацию об ошибке со значком соответствующего вида PLAIN_MESSAGE Указывает, что диалоговое окно не принадлежит ни к одному из вышеперечисленных типов. Выводится на экран без стандартного значка. Диалоговые окна могут быть модальными или немодальными Диалоговые окна могут быть модальными (фокус на окне, пока не нажата кнопка) или немодальными
Окна ввода и сообщений import java. awt. *; import javax. swing. *; public class Soluton { public static void main(String args) { JOpton. Pane. show. Message. Dialog(null , «Hello, World»); String s = JOpton. Pane. show. Input. Dialog(«Введите ваше имя»); } } Swing
Стандартные компоновщики Java 1. Компоновщик Border. Layout (полярное размещение). 2. Компоновщик Flow. Layout (последовательное размещение). 3. Компоновщик. Grid. Layout (табличное размещение). 4. Компоновщик Spring. Layout (относительное размещение). 5. Компоновщик Box. Layout (блочное размещение).
Полярное расположение (компоновщик Border. Layout) Значение Border. Layout. NORTH или строка «North» - компонент располагается вдоль верхней (северной) границы окна и растягивается на всю его ширину. Обычно так размещается панель инструментов. Значение Border. Layout. SOUTH или строка «South» - компонент располагается вдоль нижней (южной) границы и растягивается на всю ширину окна. Такое положение идеально для строки состояния. Значение Border. Layout. WEST или строка «West» - компонент располагается вдоль левой (западной) границы окна и растягивается на всю его высоту, однако при этом учитываются размеры северных и южных компонентов (они имеют приоритет). Значение Border. Layout. EAST или строка «East» - компонент располагается вдоль правой (восточной) границы окна. В остальном его расположение аналогично западному компоненту. Значение Border. Layout. CENTER или строка «Center» - компонент помещается в центр окна, занимая максимально возможное пространство.
Пример использования компоновщика Border. Layout import javax. swing. *; import java. awt. *; public class Border. Layout. Sample extends JFrame { public Border. Layout. Sample() { super(«Border. Layout. Sample»); set. Size(400, 300); set. Default. Close. Operaton(EXIT_ON_CLOSE); // получаем панель содержимого класса JFrame Container c = get. Content. Pane(); // По умолчанию в Swing используется менеджер Border. Layout // добавляем компоненты в панель, используя строковые константы c. add(new JButton(«Север»), «North»); c. add(new JButton(«Юг»), «South»); // или константы из класса Border. Layout // JLabelэлемент для отображения текста c. add(new JLabel(«Запад»), Border. Layout. WEST); c. add(new JLabel(«Восток»), Border. Layout. EAST); // если параметр не указывать вовсе, компонент автоматически добавится в центр c. add(new JButton(«Центр»)); // выводим окно на экран set. Visible(true); } public statc void main(String args) { new Border. Layout. Sample(); } } Swing
Последовательное размещение (компоновщик Flow. Layout) Компоновщик размещает компоненты слева направо, сверху вниз (по умолчанию в панелях Jpanel). import javax. swing. *; import java. awt. *; public class Flow. Layout. Sample extends JFrame { public Flow. Layout. Sample() { super(«Flow. Layout 1»); set. Size(400, 200); set. Default. Close. Operaton(EXIT_ON_CLOSE); // получаем панель содержимого Container c = get. Content. Pane(); // устанавливаем последовательное расположение с выравниванием компонентов по центру c. set. Layout(new Flow. Layout(Flow. Layout. CENTER)); // добавляем компоненты c. add(new JButton(«Один»)); c. add(new JButton(«Два»)); c. add(new JButton(«Три»)); // выводим окно на экран set. Visible(true); } public statc void main(String args) { new Flow. Layout. Sample(); } } import java. awt. *; import javax. swing. *; public class Soluton { public static void main(String args) { JOpton. Pane. show. Message. Dialog(null , «Hello, World»); } } Swing
Табличное расположение (компоновщик Grid. Layout) все компоненты имеют одинаковый размер. Доступное пространство разбивается на одинаковое количество ячеек, в каждую из которых помещается компонент; все компоненты всегда выводятся на экран, как бы ни было велико или мало доступное пространство. import java. awt. *; import javax. swing. *; import java. utl. *; class Grid. Test extends JFrame { Grid. Test(String s){ super(s); Container c = get. Content. Pane(); // 4 строки 4 столбца расстояния между строками и столбцами в пикселях c. set. Layout(new Grid. Layout(4, 4, 5, 5)); String. Tokenizer st = new String. Tokenizer(«7 8 9 / 4 5 6 * 1 2 3 — 0. = +»); while(st. has. More. Tokens()) c. add(new Button(st. next. Token())); set. Size(200, 200); set. Visible(true); } public statc void main(String args){ new Grid. Test(» Менеджер Grid. Layout»); } } Swing
Табличное расположение придаст кнопкам одинаковый размер, а последовательное расположение не даст им «расплыться» и заодно выровняет их по правому краю I mport java. awt. *; import javax. swing. *; public class Command. Buttons extends JFrame { public Command. Buttons() { super(«Command. Buttons»); set. Size(350, 250); set. Locaton(150, 100); set. Default. Close. Operaton(EXIT_ON_CLOSE); // создаем панель с табличным расположением для выравнивания размеров кнопок JPanel grid = new JPanel(new Grid. Layout(1, 2, 5, 0)); // 1 строка, 2 столбца, промежутки 5 пикс. по гориз, 0 по верт. // добавляем компоненты grid. add(new JButton(«OK»)); grid. add(new JButton(«Отмена»)); // помещаем полученное в панель с последовательным расположением, выровненным по правому краю JPanel flow = new JPanel(new Flow. Layout(Flow. Layout. RIGHT)); flow. add(grid); // получаем панель содержимого Container c = get. Content. Pane(); // помещаем строку кнопок вниз окна c. add(flow, Border. Layout. SOUTH); // выводим окно на экран set. Visible(true); } public statc void main(String args) { new Command. Buttons(); } } Swing
Блочное расположение (компоновщик Box. Layout) Менеджер блочного расположения выкладывает компоненты в контейнер блоками: столбиком (по оси Y) или полоской (по оси X), при этом каждый отдельный компонент можно выравнивать по центру, по левому или по правому краям, а также по верху или по низу.
Пример блочного размещения import java. awt. *; import javax. swing. *; public class Box 1 extends JFrame { public Box 1() { super(«Box 1 — Y»); set. Size(400, 200); set. Default. Close. Operaton(EXIT_ON_CLOSE); // получаем панель содержимого Container c = get. Content. Pane(); // устанавливаем блочное расположение по оси Y (столбиком) Box. Layout boxy = new Box. Layout(c, Box. Layout. Y_AXIS); c. set. Layout(boxy); // добавляем компоненты c. add(new JButton(«Один»)); c. add(new JButton(«Два»)); c. add(new JButton(«Три»)); // выводим окно на экран set. Visible(true); } statc class Box 2 extends JFrame { public Box 2() { super(«Box 2 — X»); // устанавливаем размер и позицию окна set. Size(400, 200); set. Locaton(100, 100); set. Default. Close. Operaton(EXIT_ON_CLOSE); // получаем панель содержимого Container c = get. Content. Pane(); // устанавливаем блочное расположение по оси X (полоской) Box. Layout boxx = new Box. Layout(c, Box. Layout. X_AXIS); c. set. Layout(boxx); // добавляем компоненты c. add(new JButton(«Один»)); c. add(new JButton(«Два»)); c. add(new JButton(«Три»)); // выводим окно на экран set. Visible(true); } } public statc void main(String args) { new Box 1(); new Box 2(); } } Swing 5 В этом примере создаются два окна. В одном из них реализовано блочное расположение по оси Y, в другом - блочное расположение по оси X.
Мы догадываемся, что порядком утомили вас, рассказывая все время о программах вывода текстовых сообщений на консоль. На этом занятии эта «унылая» череда примеров будет, наконец, прервана: мы покажем как на Java создаются окна и вы убедитесь, что это простая задача. Вот наш код (обсуждать его мы начнем на следующем занятии, т.к. в нем много-много особенностей, знать которые действительно нужно):
import java.awt.*;
import javax.swing.*;
public class MoneyForNothing extends JFrame {
// Конструктор
public MoneyForNothing () {
setTitle ("Добро пожаловать в Money for Nothing");
setSize (new Dimension (600, 400));
setDefaultCloseOperation (EXIT_ON_CLOSE);
setVisible (true);
public static void main (String args) {
MoneyForNothing mfn = new MoneyForNothing ();
А вот этот же код в окне редактирования FAR-а:
Кстати, рекомендуем сразу набирать исходные коды программ в кодировке CP1251 (или в просторечии, в кодировке Windows): переключение кодировок осуществляется клавишей F8, а текущая кодировка высвечивается в строке состояния над областью редактирования.
Точка входа осталась без изменений, а вот остальной код порядком изменился (но не будем забегать вперед). После компиляции и запуска вы должны увидеть следующее:
Поздравляем – всего в несколько строк вы создали настоящее графическое окно! Его можно перетаскивать, изменять размеры, сворачивать, разворачивать и закрывать. Правда, окно у нас получилось какое-то блеклое, прямо сказать - «страшненькое». Кроме того, окно выводится в левом верхнем углу экрана, а хотелось бы в центре – там им удобнее пользоваться, да и выглядит такой вывод приятнее. Так что давайте займемся небольшой «полировкой».
Сначала решим вторую задачу – центровка окна. Тут мы рекомендуем остановиться и подумать – как бы вы это сделали?
Подскажем, что в графической библиотеке Java есть есть метод setLocation, которому в качестве параметров передаются координаты верхнего левого угла окна (именно от этого угла производится размещение других графических элементов внутри окна). Но если задать эти параметры «в лоб», то почти наверняка ничего путного не получится т.к. на другом мониторе с другим разрешением окно окажется совсем не там, где вы рассчитывали. Следовательно, координаты нужно задавать умнее.
Все, что нужно для размещения окна по центру, это знать размеры самого окна (они, кстати, заданы в конструкторе и составляют прямоугольник 600 на 400 пикселей) и разрешение экрана, а потом, путем нехитрой арифметики, вычислить необходимые координаты левого верхнего угла. Это достигается путем размещения следующего кода
Dimension sSize = Toolkit.getDefaultToolkit ().getScreenSize (),
fSize = getSize ();
if (fSize.height > sSize.height) {fSize.height = sSize.height;}
if (fSize.width > sSize.width) {fSize.width = sSize.width;}
setLocation ((sSize.width - fSize.width)/2,
(sSize.height - fSize.height)/2);
непосредственно за строкой setSize (new Dimension (600, 400)); в конструкторе. Внесите необходимые изменения в исходный код, откомпилируйте программу и запустите на исполнение; окно должно появиться в центре экрана монитора.
Теперь несколько слов о внешнем виде окна. Его странный вид объясняется тем, что разработчики Java стремились добиться того, чтобы вне зависимости от аппаратной платформы и программной «начинки», все графические элементы (окна, кнопки, списки и проч.) имели единую отрисовку и единую цветовую гамму. Для этого они разработали специальный стиль, который назвали «METAL». Если разработчик не предпримет специальных усилий, то элементы графического интерфейса в его программах будут выглядеть именно в этом стиле, без учета особенностей конкретных компьютеров и их программного обеспечения. В отдельных случаях в этом есть смысл, но все-таки, согласитесь, что гораздо лучше, если программа, запущенная на Windows будет похожа на windows-программу, а запущенная на LINUX будет похожа на linux-программу. Добиться этого легко. Все, что нужно - включить в точку входа, перед созданием экземпляра класса следующий код:
try {UIManager.setLookAndFeel
(UIManager.getSystemLookAndFeelClassName ());
catch (Exception lfe) {}
Так мы и поступим. Теперь, после компиляции обновленной версии нашей программы и запуска ее на исполнение, графическое окно будет выглядеть гораздо «пристойнее»:
В зависимости от настройки свойств экрана вашего монитора отображение окна будет отличаться; мы используем классическую тему Windows XP. У вас это же окно может выглядеть, например, так:
Убедитесь, что все работает как ожидалось: окно выводится в центре экрана и его внешний вид соответствует ожидаемому.
На этом мы закончим наше первое занятие, посвященное графическим интерфейсам. В нем мы показали «фасад», однако совершенно оставили «за бортом» множество вопросов, которые чрезвычайно важны и без которых невозможно программирование на Java вообще и графических интерфейсов в частности. Мы начнем заниматься этими вопросами на следующем занятии, а пока – поиграйтесь с тем исходным кодом, который есть.
В качестве упражнения, рассчитайте, к примеру, координаты вывода нашего окна в правом нижнем углу экрана и проверьте результат.
Другое упражнение проще по исполнению, но вам нужно будет воспользоваться документацией (надо же когда-то начинать, в самом деле): сделайте так, чтобы нельзя было изменять размеры окна, т.е. чтобы область системных кнопок выглядела так, как на рисунке
(подсказка: ищите информацию по ключевым словам javax и JFrame). Так что, засучите рукава и удачи!
Замечание
Может случиться, что сформированное окно будет полностью или частично невидимо (из-за того, что вы неправильно рассчитали координаты его вывода на экран). Кнопки управления окна могут также оказаться недоступными. Как же прервать работу приложения не снимая задачу в «Диспетчере задач» или не перезагружая компьютер?
Поскольку мы запускаем программы на исполнение из FAR-а, то прерывание исполнения программы на Java достигается нажатием комбинации клавиш Control-C (здесь «C» - латинская буква, не путайте ее со сходной по начертанию буквой кириллической).
