Основным средством создания базовых конструкций для World Wide Web приложений является HTML (Hype rText Markup Language) - язык разработки статических (plain and static) документов - как WWW страничек выполнения клиент-приложений. Некоторое "оживление" клиентских страничек привносило включение в документы видео- и аудиоприложений, графических файлов ( in-line images), включая анимационную графику, а также создание новых конструкций - таблиц (table) , кадров (frame) и других. Создание языка JavaScript продолжает традиции совершенствования WWW в целях повышения наглядности (come a live) HTML документов. Реализован язык JavaScript (первоначально как LiveScript) был в январе 1996 года для Net scape Navigator 2.0 и в настоящее время может применяться также и для Microsoft Explorer 3.0 и выше.

 

     JavaScript - компактный условно объектно-ориентированный (object-based) язык для разработки клиент-серверных Internet приложений. Начиная с Netscape Navigator 2.0 распознаются и выполняются операторы JavaScript, включенные непосредственно в HTML страницы в режиме интерпретации при загрузке страницы. В отличие от статического представления документов на языке HTML конструкции языка JavaScript вносят элемент интерактивности. В клиент приложениях для Navigator, операторы JavaScript распознаются и реагируют на действия пользователя такие как манипуляции с мышью, операции чтения введенной информации (form input) и управления страницами ( page navigation). Без сетевых обменов в страницах HTML операторы JavaScript могут анализировать введенный текст и выдавать нужные сообщения (alert) пользователю, выполнять также действия (включая исполнение аудио файлов) при открытии страницы либо по окончанию работы.

 

     Язык JavaScript поддерживает небольшое количество представлений типов данных -числовых, строковых (string) и логических ( Boolean), и не содержит строгого определения их типов. JavaScript поддерживает также функции (встроенные (built-in) и создаваемые пользователем) без специальных декларативных требований. Важными конструкциями языка JavaScript являются объекты (object), свойства объектов (properties) , методы объектов (method) и асинхронные драйверы-обработчики событий ( event handlers) .

 

     Программы на JavaScript, как и программы, написанные на языках различных интерпретаторов, часто называют скрипт-программами или просто скриптами ( script).

 

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

  

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

 

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

 

Была создана обширная библиотека "легких" компонент Java, названная Swing.

 

Swing – это стандартная библиотека, которая поставляется со всеми версиями Java2.

 

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

 

Есть и другая более старая библиотека классов для написания оконных интерфейсов. Это библиотека называется Abstract Windows Toolkit или  для краткости AWT. Swing можно рассматривать как усовершенствованную версию AWT. Однако  Swing не заменяет AWT. Пакет классов Swing добавлен к AWT, чтобы предоставить более богатую коллекцию классов, а AWT остается как необходимое дополнение к библиотеке Swing.

 

 

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

 

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

 

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

 

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

Компонент и контейнер

Основное понятие графического интерфейса пользователя (ГИП) — компонент (component) графической системы. В русском языке это слово подразумевает просто составную часть, элемент чего-нибудь, но в графическом интерфейсе это понятие гораздо конкретнее. Оно означает отдельный, полностью определенный элемент, который можно использовать в графическом интерфейсе независимо от других элементов. Например, это поле ввода, кнопка, строка меню, полоса прокрутки, радиокнопка. Само окно приложения — тоже его компонент. Компоненты могут быть и невидимыми, например, панель, объединяющая компоненты, тоже является компонентом.

Вы не удивитесь, узнав, что в AWT компонентом считается объект класса Component или объект всякого класса, расширяющего класс component. В классе component собраны общие методы работы с любым компонентом графического интерфейса пользователя. Этот класс — центр библиотеки AWT.

Каждый компонент перед выводом на экран помещается в контейнер (container) (см. рис. ниже). Контейнер "знает", как разместить компоненты на экране. Разумеется, в языке Java контейнер — это объект класса Container или всякого его расширения. Прямой наследник этого класса — класс jcomponent — вершина иерархии многих классов библиотеки Swing.

Создав компонент — объект класса Component или его расширения, следует добавить его к предварительно созданному объекту класса container или его расширения одним из методов add ().

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

 

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

• Строка заголовка (title bar), с левой стороны которой необходимо разместить кнопку контекстного меню, а с правой — кнопки сворачивания и разворачивания окна и кнопку закрытия приложения.
• Необязательная строка меню (menu bar) с выпадающими пунктами меню. 
• Горизонтальная и вертикальная полосы прокрутки (scrollbars).
• Окно должно быть окружено рамкой (border), реагирующей на действия мыши.

Окно с этими компонентами в готовом виде описано в классе Frame. Чтобы создать окно, достаточно сделать свой класс расширением класса Frame, как показано в листинге 8.1. Всего восемь строк текста и окно готово

import j ava.awt.*;

class TooSimpleFrame extends Frame{

  public static void main(String[] args){ 

    Frame fr = new TooSimpleFrame(); 

  fr.setSize(400, 150); 

  fr.setVisible(true); 

  } 

}

Иерархия классов AWT 

На рис. 8.2 показана иерархия основных классов AWT. Основу ее составляют готовые компоненты: Button, Canvas, Checkbox, Choice, Container, Label, List, Scrollbar, TextArea, TextField, Menubar, Menu, PopupMenu, Menultem, CheckboxMenuItem. Если этого набора не хватает, то от класса Canvas можно породить собственные "тяжелые" компоненты, а от класса Component — "легкие" компоненты.

Основные контейнеры — это классы Panel, ScrollPane, Window, Frame, Dialog, FileDialog. Свои "тяжелые" контейнеры можно породить от класса Panel, а "легкие" — от класса container.

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

На рис. 8.2 показаны и начальные классы иерархии библиотеки Swing — классы JComponent, JWindow, JFrame, JDialog, JApplet.

Рис. 8.2. Иерархия  основных классов AWT

 

 = = = = = = = = = = =

 

Инструментарий AWT (Abstract Windowing Toolkit) начал поставляться с самой первой версией Java. Он использует родные для платформ компоненты GUI (т.е. Win32 API для Windows и библиотеку Motif для Unix), обеспечивая, таким образом, переносную обертку. Это значит, что внешний вид и поведение AWT-программ будет отличаться на различных платформах, потому что именно они занимаются отрисовкой и управлением компонентов GUI. Это противоречит кросс-платформенной философии Java и может быть объяснено тем, что первая версия AWT была разработана за четырнадцать дней.

 

По этой и другим причинам AWT был дополнен инструментарием Swing. Swing использует AWT (и, следовательно, низкоуровневые библиотеки) только лишь для базовых операций: создания прямоугольных окон, управления событиями и отрисовки графических примитивов. Всем остальным, включая отрисовку компонентов GUI, занимается Swing. Это решает проблему отличающегося внешнего вида и поведения приложений на различных платформах. Но из-за реализации Swing-инструментария средствами Java его производительность оставляет желать лучшего. В результате Swing-программы медлительны не только во время интенсивных вычислений, но и при отрисовке элементов пользовательского интерфейса. Как уже говорилось, ничто не вызывает у пользователей такого раздражения, как большое время отклика интерфейса программ. Странно наблюдать за медлительностью перерисовки Swing -кнопки на современном оборудовании. Хотя с ростом производительности оборудования эта ситуация будет постепенно улучшаться, сложным пользовательским интерфейсам, созданным с помощью Swing, всегда будет свойственна медлительность.

 

   В программах Swing и большинстве других программ графических пользовательских интерфейсов (CUI) используются события и обработчики событий. События (event) в графическом пользовательском интерфейсе являются объектом, который представляет некоторое действие, такое как щелчок мыши, перемещение мыши, нажатие клавиши на клавиатуре, щелчок на кнопке закрытия окна или какие-нибудь другие ожидаемые действия. На самом деле событие представляет собой более широкое понятие и охватывает не только события графического пользовательского интерфейса. Например, сообщение от принтера операционной системе, из которого следует, что принтер готов к печати следующего документа, тоже может рассматриваться  как событие. Однако  единственные события, которые мы будем обслуживать, - события, генерируемые в графическом пользовательском интерфейсе.

   Когда объект генерирует событие, этот процесс обычно называют запуском или активизацией (firing) события. В Swing каждый объект, который может активизировать события (например, кнопка, на которой возможен щелчок), может иметь один или несколько объектов слушателей (listener object). Программист указывает, какие объекты являются объектами слушателей для всех заданных объектов, которые могут запустить событие. Например, при щелчке на кнопке, которая запускает некоторые события, это событие автоматически пересылается объекту слушателя, если с таковым связана эта кнопка. У объекта слушателя есть методы, которые определяют, что будет происходить, когда ему  будут пересылаться различного рода события. Методы, обрабатывающие эти события, называются обработчиками событий (event handler). Методы обработки событий определяются (или переопределяются) программистом.

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

   Объекты слушателей очень напоминают людей, сидящих в комнате и ожидающих телефонного звонка. Каждый человек имеет собственный телефон. Когда звонит какой-то телефон, человек с этим телефоном отвечает и выполняет приказ, отданный по телефону. Возможно, например, такое сообщение: «Джо, это звонит твоя мама, мне бы хотелось, чтобы ты закрыл окно в своей комнате». Затем Джо идет домой и закрывает окно в своей комнате. В графическом пользовательском интерфейсе подобное сообщение могло звучать как «закрыть окно», или «была нажата клавиша «А», или «мышь была перемещена» с одного места на другое. Если событие запущено, то одному или нескольким объектам слушателей для определенного объекта автоматически сообщается, что событие запущено. Затем объект слушателя вызывает соответствующий метод-обработчик для обработки этого события.

Один аспект вам может показаться странным: здесь программист пишет определения методов, к которым нет обращения ни в одной из программ. Это может показаться странным, поскольку метод теряет всякий смысл, если к нему не обращаются. Значит, к нему должен обращаться кто-то другой или что-то другое. На самом деле происходит следующее. Система Swing автоматически обращается к определенным методам, когда событие указывает на то, что требуется вызвать данный метод.

 

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

 

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

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

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

 

Инструкция по созданию простых оконных интерфейсов.

1. Обычный GUI – интерфейс состоит из некоторого оконного объекта, который является производным от класса JFrame и который содержит несколько таких компонентов, как надписи и кнопки.
2. Когда пользователь щелкает на кнопке закрытия окна, окно должно закрываться, но это не будет выполнено корректно, пока программа не зарегистрирует объект слушателя окна для его закрытия. Одним из способов решения этой задачи является добавление к определению GUI – класса внутри конструктора следующего оператора                                                    addWindowListener(newWindowDestroyer());                                                                           
3. Компоненты можно сгруппировать вместе, поместив их на панель JPanel и добавить панель к GUI – классу.
4. Для GUI – окна (т.е. объекта класса JFrame) и каждой панели в GUI – окне должен быть предоставлен диспетчер компоновки с помощью метода setLayout.
5. Если какой-либо из компонентов, как кнопка, генерирует события действия, то необходимо оформить GUI (или какой-то другой класс) как объект слушателя событий. Для каждого компонента, который генерирует события действия, должен быть зарегистрирован объект слушателя событий. Регистрация объекта слушателя выполняется с помощью метода  addActionListener.
6. Чтобы превратить оконный GUI – интерфейс (или какой-то другой класс) в объект слушателя событий, необходимо добавить в начало определения класса следующее предложение.                                                                                                                    implementsActionListener                                                                                                                 Кроме того, к определению класса следует добавить определение метода actionPerformed.

 

Аплет (applet) означает небольшое приложение (application), т.е. аплеты – это просто маленькие Java – программы. Но смысл, который вкладывается в слово маленькие, больше связан не с размером этих программ, а с тем, как и где они работают. Аплеты - это Java – программы, которые можно вставить в НТML – документ и запустить с помощью браузера, который просматривает этот документ. Аплет очень похож на GUI-программу, использующую библиотеку Swing.

     Аплет представляет собой класс, выделенный из класса JApplet  (на самом деле это может быть любой производный из класса JApplet). Класс JApplet входит в состав библиотеки Swing, поэтому, используя класс Jаpplet, необходимо вставить в программу следующего оператора импорта.

import javax. swing.*;

   При создании аплета вам может также понадобиться библиотека AWT.

  На рис. (см. ниже) показана часть иерархии классов, позволяющая понять место, занимаемое классом JApplet. Обратите внимание, что класс JApplet является потомком класса Container. Следовательно, в аплет можно добавлять компоненты точно так же, как и в любые другие контейнера, например в контейнер  JPanel.

   На рис. показан класс Applet. Класс Applet является более древним, чем класс JApplet, и он использовался для создания аплетов еще до появления класса JApplet.

  Разработка класса аплетов во многом схожа с разработкой оконной системы на основе библиотеке Swing. Главное различие состоит в том, что класс аплета выводится из класса JApplet, а не из класса JFrame. Другие различия между классом аплета и классом с окном Swing-интерфейсом связаны, в основном, с элементами, изъятыми из определения класса аплета.

   Аплеты не нуждаются в использовании метода setVisible. Аплеты встраиваются в НТML-документы, и функцию отображения аплета выполняет НТML-документ. По этой причине аплет не имеет метода main.

  

 

Аплеты не имеют заголовков, и поэтому в аплете не нужно использовать метод setTitle. Дело в том, что аплеты обычно входят в состав НТML-документов, и вы можете вставить заголовок в НТML-документ, который отображает это аплет. НТML-документ также определяет и размер аплета, поэтому вам не нужно беспокоиться о командах задания размеров для аплета.

   Аплеты обычно не используют конструкторы, но используют метод init, который выполняет аналогичную функцию. Создавая аплет, сформируйте все действия по инициализации (например, установка цветов, добавление кнопок, текстовый полей и т.д.) в методе init. Метод init не имеет параметров.

    Аплеты не закрываются объектами слушателей и поэтому не включают обращения к методу addWindowListener в своих init-методах. Аплеты закрываются автоматически при закрытии НТML-документа.

   Если в классе JApplet не задан диспетчер компоновки, то по умолчанию используется диспетчер BorderLayout. Если комплект добавляется без задания области, он по умолчанию попадает в область BorderLayout.CENTER.

 

Выполнение аплета

    Обычно аплет запускается из НТML-документа, но для тестирования можно запустить его с помощью визуализатора аплетов (applet viewer). Визуализатор аплетов представляет собой программу, которая автоматически помещает ваш аплет на простую НТML-страницу, а затем запускает ее оттуда. Однако  визуализатор аплетов создает впечатление, будто аплет выполняется подобно любой другой программе. Если вы используете какую-нибудь интегрированную среду, в меню которой есть команда, именуемая «Run Applet», «Run» или «Execute» (а может, еще как-нибудь), то вы можете выполнить аплет как обычную Java – программу, т.е. используя одну из перечисленных команд. В среде TextPad, а именно в меню Tools (сервис), предусмотрена команда Run Java Applet (Выполнить аплет).

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

 Appletyviewer<  имя НТML-документа >.html

   Но в этом случае вам придется самостоятельно создавать НТML-документ (в данном примере он называется AdderApplet. html) и поместить в него тестируемый аплет.

   Итак, аплет обычно выполняется из НТML-документа, но во время отладки тестируемый аплет, как правило, запускается с помощью визуализатора аплетов.

 

Размещение аплета в НТML-документе.

   Если поместить в некоторый НТML-документ следующую команду, то это документ отобразит окно арифмометра, создаваемое аплетом

<APPLET CODE=”AdderApplet.class” WIDTH=400 HEIGHT=200>

</APPLET>

   При задании это команды предполагается, что НТML-файл и файл AdderApplet. class находится в одном и том же каталоге (папке). Если они находятся в разных каталогах (папках), вам следует использовать абсолютное или относительное имя пути для класса AdderApplet. class. Предыдущее выражение часто называют тегом аплета.

 

Преобразование Swing – приложения в аплет

1. Сделайте класс аплета производным от класса JApplet, а не от класса JFrame, т.е. в первой строке определения класса замените фразу extends JFrame фразой extends JApplet.
2. Удалите метод main. В аплете не нужно выполнять некоторые действия, которые обычно приходится делать в main – методе. Аплет автоматически становится видимым, а его размер и расположение определяется НТML- страницей, из которой он запускается.
3. Замените конструктор методом init. Тело  метода init может во многом совпадать с телом удаленного конструктора, если удалить некоторые не нужные элементы, как описано в следующих пунктах.
4.  Удалите любые вызовы методом addWindowListener. (При закрытии НТML-документа аплет закрывается автоматически. Поэтому вам не нужен никакой объект слушателя окна, например объекта класса WindowDestroyer, описанный в главе 12.)
5. Удалите любые вызовы методом setTitle. (Аплеты не имеют заголовков, хотя ничего не мешает вам разместить заголовок на НТML- странице.)
6. Удалите любые вызовы методом setSize. (Размеры устанавливаются в НТML- странице, из которой запускается аплет.)
7. Создайте НТML- страницу с тегом APPLET, который указывает на аплет в виде байт-кода (файл с расширением . class).

 

 

 

   На рис. Показана часть иерархии Swing-классов. Обратите внимание, что классы JButton и JMenuItem выведены из класса AbstractButton.вот прочему объекты класса JButton и объекты класса JMenuItem так похожи между собой. Все методы, которые перечислены для класса JButton в табл. Унаследованы от класса AbstractButton. Класс JMenuItem также наследует все те же методы от класса AbstractButton, поэтому класс JMenuItem содержит все методы (отличные от конструкторов). (Некоторые из этих методов были унаследованы классом AbstractButton от класса JComponent, поэтому некоторые из этих методов «унаследованы от класса JComponent».)

   Метод AbstractButton – абстрактный класс. Из абстрактного класса нельзя создать объекты напрямую. Единственная причина определения класса AbstractButton – в возможности вывести их него такие классы, как JButton и JMenuItem. Это обеспечивает некоторое единообразие в отношении классов JButton и JMenuItem, означающее, что разработчики библиотеки Swing не должны дважды писать идентичный код, один для класса JButton, а другой для класса JMenuItem, поскольку они написали его один раз для класса AbstractButton.

   Классы JLabet и JButton также очень похожи. Однако они не столь идентичны, как классы JButton и JMenuItem. Эти степени идентичности также отражены в иерархии классов, показанной на рис.  Все эти три класса – потомки класса JComponent, но только классы JButton и JMenuItem являются потомками класса AbstractButton.

  В иерархии классов, показанной  на рис.     Можно увидеть и другие интересные моменты. Обратите внимание, что класс JMenu выведен из класса JMenuItem. Это означает, что меню также является элементом меню, и поэтому объект класса JMenu можно добавлять к другому объекту класса JMenuподобно тому, как более простой объект класса JMenuItem добавляется к объекту класса JMenu. Это позволяет создавать вложенные меню.

   Обратите внимание, что класс JMenuBar выделен из класса JComponent. Это означает, что объект класса JMenuBar можно добавлять в любой контейнер, например панель или панель содержимого JFrame-окна, подобно тому, как надпись или кнопка. Это означает, что, используя, подходящий диспетчер компоновки, можно использовать любое желаемое количество объектов класса JMenuBar и разместить их практически в любом месте контейнера.

 + + + + + + + + + + + + + + + +

   Java 2 Standard Edition (J2SE, стандартная редакция Java 2) — коллекция утилит и библиотек Java, созданная компанией Sun как стандарт, соответствующий требованиям большинства разработчиков приложений для Интернета.

 

Java 2D — группа классов Java, которая содержит некоторые дополнительные графические методы.

 

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

 

Java Foundation Classes (JFC, основные классы Java) — имя, присвоенное компанией Sun коллекции из пяти инструментальных пакетов (Swing, Java 2D, Accessibility, Drag & Drop и Application Services), предназначенной для создания дополнительных графических пользовательских интерфейсов на Java 2.

 

 Java Runtime Environment (JRE, среда исполнения Java) — коллекция программ и библиотек для конкретной операционной системы, которая позволяет выполнять программы Java. Состоит из виртуальной машины Java, основных классов Java и сопутствующих файлов. JRE не содержит компилятора, отладчика и других инструментов.

 

Java Virtual Machine (JVM, виртуальная машина Java) — виртуальный (в отличие от физического) компьютер, который является частью JRE и выполняет байт-коды Java, что обеспечивает мобильность приложений Java, то есть возможность их перенесения на многие платформы.

 

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

 

JavaScript — язык сценариев, разработанный компанией Netscape (исходное его название было LiveScript) для создания web-страниц. Позволяет контролировать способ представления web-страниц в браузере. До некоторой степени обеспечивает поддержку встроенных апплетов Java.

 

Java 2 Micro Edition (J2ME, редакция Java 2 Микро) — уменьшенная в объеме и упрощенная коллекция утилит и библиотек Java, специально подобранных компанией Sun для решения несложных задач.

 

Java 2 Microedition (J2ME) — подмножество технологий фирмы Sun Microsystems, основанное на концепции Java-платформы, и предназначенное для выполнении приложений, написанных на языке Java, на устройствах бытовой электроники, например мобильных телефонах, персональных органайзерах, цифровых телевизионных ресиверах и т. п. Основой J2ME является виртуальная машина, способная исполнять байт-код языка Java.

 

J2ME задумана для того, чтобы обеспечить эффективное исполнение Java-приложений на устройствах бытовой электроники, отличительной особенностью которых является ограниченная вычислительная мощность, ограниченный объём памяти, малый размер дисплея, питание от портативной батареи, а также низкоскроростные и недостаточно надежные коммуникационные возможности. Типичный современный мобильный телефон содержит внутри 32-разрядный RISC процессор с тактовой частотой 50 МГц, имеет объем оперативной памяти около 4 Мб, цветной дисплей размером 4 дюйма и имеет возможность GPRS соединения с Интернетом со скоростью максимум 172 Кб/с (которое при этом фундаментально ненадёжно, скорость передачи данных может неожиданно упасть или соединение может быть вообще полностью потеряно).

 

J2ME специфицирует две базовые конфигурации, которые определяют требования к виртуальной машине (иначе говоря, определяют подмножество стандартного языка Java, которое виртуальная машина способна выполнять), а также минимальный набор базовых классов. В настоящее время в J2ME имеется две конфигурации — CLDC (Connected Limited Device Configuration — конфигурация устройства с ограниченными коммуникационными возможностями) и CDC (Connected Device Configuration — конфигурация устройства с нормальными коммуникационными возможностями).

 

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

 

В настоящее время самой распространенной конфигурацией является CLDC, для которого разработан профиль MIDP (Mobile Information Device Profile — профиль для мобильного устройства с информационными функциями). MIDP определяет понятие мидлета (MIDlet) — компактного приложения на языке Java, имеющего небольшой размер (менее 100 килобайт), что делает его пригодным для передачи его по сети и установки на мобильном устройстве. Другим популярным профилем для J2ME/CLDC является DoJa, разработанный фирмой NTT DoCoMo для ее собственного сервиса iMode. iMode весьма распространен в Японии, и в меньшей степени в Европе и на Дальнем Востоке.

 

Конфигурация CLDC успешно используется в большинстве современных мобильных телефонах и портативных органайзерах. По данным компании Sun Microsystems к концу 2004 года в мире было выпущено более 570 миллионов мобильных устройств с поддержкой этой конфигурации Java. Это делает J2ME доминирующей технологией Java в мире. Объёмы производства мобильных телефонов значительно превышают количество других компьютерных устройств, способных исполнять приложения на Java (например, персональных компьютеров).

 

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

 

Java 2 Enterprise Edition (редакция Java 2 для корпоративных программных систем на базе Java) — наибольшая коллекция утилит Java, разработанная компанией Sun для создания базовых приложений, удобных для подключения к Интернету.

 

 

J2EE (от англ. Java 2 Enterprise Edition) — набор спецификаций и соответствующей документации для языка Java, описывающей архитектуру серверной платформы для задач средних и крупных предприятий.

 

Спецификации детализованы настолько, чтобы обеспечить переносимость программ c одной реализации платформы на другую. Основная цель спецификаций — обеспечить масштабируемость приложений и целостность данных во время работы системы. J2EE во многом ориентирована на использование её через веб как в интернете, так и на локальных сетях. Вся спецификация создается и утверждается через JCP (Java Community Process) в рамках инициативы Sun Microsystems Inc.

 

J2EE сервер (часто называемый J2EE контейнер) — это имплементация системы в соответствии с J2EE спецификацией, обеспечивающая работу модулей с логикой конкретного приложения. Включает в себя по крайней мере следующие сервисы:

 

    * EJB контейнер, который поддерживает автоматическую синхронизацию Java объектов с базой данных (CMP — container managed persistence);

    * JMS — сервис доставки сообщений между компонентами и серверами;

    * управление ресурсами (доступ к СУБД, файловой системе, почтовому серверу и т. д.);

    * безопасность и защита данных;

    * поддержка транзакций (в том числе и распределенных, двухфазных);

    * веб-сервер и сервлет-сервер;

    * поддержка веб-сервисов.

 

Разработчики J2EE приложений также пишут свои в соответствии с J2EE спецификациями, что обеспечивает их работу внутри таких серверов.

 

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

 

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +  + + + + + + + + + + + + +

 

 

 

SWT (или Standard Widget Toolkit) — это фреймворк с открытым исходным кодом для разработки графических интерфейсов пользователя на языке Java. Разработан фондом Eclipse, и лицензируется под Общей Публичной Лицензией. Он представляет собой альтернативу AWT и Swing для разработчиков, создающих приложения для рабочего места на Java. Написан на стандартной Java и получает доступ к платформно-специфичным библиотекам через Java Native Interface, который рассматривается в качестве сильного средства, несмотря на то, что это не является чистой Java.