Текст книги "Java: руководство для начинающих (ЛП)"

Автор книги: Герберт Шилдт

сообщить о нарушении

Текущая страница: 29 (всего у книги 36 страниц)

// int i = (Integer) raw.getobO; В этом операторе присваивания в объекте raw определяется значение переменной ob, которое приводится к типу Integer. Но дело в том, что в объекте raw содержится не целое число, а значение типа Double. На стадии компиляции этот факт выявить невозможно, поскольку тип объекта raw неизвестен. Следовательно, ошибка возникнет на стадии выполнения программы. В следующих строках кода ссылка на объект класса Gen базового типа присваивается переменной strOb (ссылки на объект типа Gen).

strOb = raw; // Допустимо, но потенциально ошибочно. // String str = strOb.getob(); // Ошибка при выполнении программы. Само по себе присваивание синтаксически правильно, но логически сомнительно. Переменная strOb ссылается на объект типа Gen, а следовательно, она должна содержать ссылку на объект, содержащий значение типа String, но после присваивания объект, на который ссылается переменная strOb, содержит значение типа Double. Поэтому при выполнении программы, когда предпринимается попытка присвоить переменной str содержимое объекта, на который ссылается переменная strOb, возникает ошибка. А причина ее заключается в том, что переменная strOb ссылается в этот момент на объект, содержащий значение типа Double. Таким образом, присваивание ссылки на объект базового типа переменной ссылки на объект обобщенного типа делается в обход механизма типовой безопасности. В следующих строках кода демонстрируется ситуация, обратная предыдущей:

raw = iOb; // Допустимо, но потенциально ошибочно. // d = (Double) raw.getobO; // Ошибка при выполнении программы. В данном случае ссылка на объект обобщенного типа присваивается переменной базового типа. И это присваивание синтаксически правильно, но приводит к ошибке, возникающей во второй строке кода. В частности, переменная raw указывает на объект, содержащий значение типа Integer, но при приведении типов предполагается, что он содержит значение типа Double. И эту ошибку также нельзя выявить на стадии компиляции, а проявляется она при выполнении программы. В связи с тем что использование базовых типов сопряжено с потенциальными ошибками, проявляющимися при выполнении программы, компилятор javac выводит в подобных случаях сообщения, предупреждающие об отсутствии проверки типов, когда базовый тип используется в обход механизма типовой безопасности. Такие сообщения будут получены и при компиляции рассматриваемой здесь программы. Причиной их появления станут следующие строки кода:

Gen raw = new Gen(new Double(98.6));

strOb = raw; // Допустимо, но потенциально ошибочно. В первой из этих строк кода содержится обращение к конструктору класса Gen без указания аргумента типа, что приводит к выдаче компилятором соответствующего предупреждения. А при компиляции второй строки предупреждающее сообщение возникнет из-за попытки присвоить переменной, ссылающейся на объект обобщенного типа, ссылки на объект базового типа. На первый взгляд может показаться, что предупреждение об отсутствии проверки типов может вызвать и приведенная ниже строка кода, но этого не произойдет,

raw = iOb; // Допустимо, но потенциально ошибочно. В этом случае компилятор не предупреждает пользователя, потому что такое присваивание не приводит к еще большей потере типовой безопасности по сравнению с той, которая произошла при создании переменной raw базового типа. Из всего изложенного выше можно сделать следующий вывод: пользоваться базовыми типами следует весьма ограниченно и только в тех случаях, когда устаревший код требуется объединить с новым, обобщенным кодом. Базовые типы – лишь средство для обеспечения совместимости с устаревшим кодом. Они не должны присутствовать во вновь разрабатываемом коде. ## Выводимость типов с помощью ромбовидного оператора Начиная с версии JDK 7 появилась возможность сократить синтаксис, применяемый для создания экземпляра обобщенного типа. В качестве примера обратимся к классу TwoGen, представленному в начале этой главы. Ниже для удобства приведена часть его объявления. Обратите внимание на то, что в нем определяются два обобщенных типа данных.

class TwoGencT, V> { Т obi; V ob2; // передать конструктору ссылку на объект типа Т. TwoGen(Т о1, V о2) { obi = ol; оb2 = о2; } // ... } До появления версии JDK 7 для создания экземпляра класса TwoGen приходилось прибегать к оператору присваивания, аналогичному приведенному ниже.

TwoGen tgOb = new TwoGencinteger, String>(42, "testing"); Здесь аргументы типа (в данном случае – Integer и String) указываются дважды: сначала при объявлении переменной tgOb, а затем при создании экземпляра класса TwoGen с помощью оператора new. Начиная с версии JDK 5, в которой были внедрены обобщения, подобная форма создания объектов обобщенного типа требовалась при написании всех программ на Java, вплоть до появления версии JDK 7. И хотя в этой форме, по существу, нет ничего ошибочного, все же она выглядит несколько многословной. Ведь в операторе new типы аргументов могут быть выведены без особого, труда, и поэтому нет никаких оснований указывать их еще раз. И для этой цели в версии JDK 7 внедрен специальный синтаксический элемент. В версии JDK 7 приведенное выше объявление может быть переписано следующим образом:

TwoGen tgOb = new TwoGen<>(42, "testing"); Как видите, в той части, где создается экземпляр объекта обобщенного типа, просто указываются угловые скобки (< >), обозначающие пустой список аргументов типа. Это так называемый ромбовидный оператор, предписывающий компилятору вывести типы аргументов, требующиеся конструктору в операторе new. Главное преимущество такого синтаксиса выведения типов состоит в том, что он позволяет сделать более краткими те операторы объявления, которые порой выглядят слишком длинными и громоздкими. Это оказывается особенно удобным для объявления обобщенных типов, определяющих границы наследования в иерархии классов Java. Приведенную выше форму объявления экземпляра класса можно обобщить. Для выведения типов служит следующая общая синтаксическая форма объявления обобщенной ссылки и создания экземпляра объекта обобщенного типа:

class-namе<аргументытипа> имяпеременной = new class-name< >(аргументы_конструктора) ; Здесь список аргументов типа в операторе new указывается пустым. В операторах объявления выведение типов может, как правило, применяться и при передаче параметров. Так, если объявить в классе TwoGen следующий метод:

boolean isSame(TwoGen о) { if(obi == о.obi && ob2 == o.ob2) return true; else return false; } то приведенный ниже вызов окажется вполне допустимым в версии JDK 7.

if(tgOb.isSame(new TwoGen<>(42, "testing"))) System.out.println("Same"); В данном случае опускаются аргументы типа, которые должны передаваться методу isSame (). Их типы могут быть выведены автоматически, а следовательно, указывать их еще раз не нужно. Ромбовидный оператор является новым языковым средством в версии JDK 7, но непригодным для компиляции кода, написанного в предыдущих версиях Java. Поэтому в примерах программ, приведенных далее в этой книге, будет использоваться прежний несокращенный синтаксис объявления экземпляров обобщенных классов, чтобы эти программы можно было скомпилировать любым компилятором Java, поддерживающим обобщения. Кроме того, несокращенный синтаксис объявления экземпляров обобщенных классов яснее дает понять, что именно создается, и благодаря этому представленные в книге примеры становятся более наглядными и полезными. Разумеется, в своих программах на Java вы вольны пользоваться синтаксисом выведения типов, чтобы упростить их объявления. ## Стирание Как правило, программирующему на Java совсем не обязательно знать во всех подробностях, каким образом компилятор преобразует исходный код программы в объект– ный. Но что касается обобщенных типов, то важно иметь хотя бы общее представление о процессе их преобразования. Это помогает лучше понять, почему обобщенные классы и методы действуют именно так, а не иначе, и почему их поведение порой ставит в тупик непосвященных. Поэтому ниже поясняется вкратце, каким образом обобщенные типы реализуются в Java. При внедрении обобщенных типов в Java пришлось учитывать следующее важное условие, накладывавшее определенные ограничения на их реализацию: совместимость с предыдущими версиями Java. Иными словами, обобщенный код должен был быть совместим с предыдущими версиями кода, на момент написания которого обобщенные типы еще не были доступны. Таким образом, любые изменения в синтаксисе языка Java или механизме JVM не должны были оказывать влияние на уже существующий код. Поэтому для реализации обобщенных типов с учетом указанных ограничений был выбран механизм, получивший название стирание. Механизм стирания действует следующим образом. При компиляции кода, написанного на Java, все сведения об обобщенных типах удаляются, т.е. стираются. Это означает, что параметры типа заменяются верхними границами их типа, а если границы не указаны, то их функции выполняет класс Object. После этого производится приведение типов, определяемых аргументами типа. Подобная совместимость типов соблюдается компилятором. Благодаря такому подходу к реализации обобщений параметры типа при выполнении программы вообще отсутствуют, но действуют только на стадии компиляции исходного кода. ## Ошибки неоднозначности Появление обобщенных типов стало причиной возникновения новой разновидности ошибок, связанных с неоднозначностью. Ошибки неоднозначности возникают в тех случаях, когда в результате стирания два, на первый взгляд, отличающихся объявления обобщенных типов преобразуются в один тип, вызывая тем самым конфликтную ситуацию. Рассмотрим пример, в котором используется перегрузка методов.

// Неоднозначность, вызванная стиранием перегруженных методов, class MyGenClass { Т obi; V ob2; // ... // Два следующих метода конфликтуют друг с другом, // поэтому код не компилируется. // Эти методы существенно неоднозначны. void set(T о) { obi = о; } void set(V о) { ob2 = о; }

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

MyGenClass obj = new MyGenClass() В данном случае типы Т и V заменяются типом String. В результате оба варианта метода set () становятся совершенно одинаковыми, что, безусловно, считается ошибкой. Второе, более серьезное затруднение возникает в связи с тем, что при стирании обобщенных типов оба варианта метода set () преобразуются в следующий вид:

void set(Object о) { // ... Таким образом, попытка перегрузить метод set () в классе MyGenClass является существенно неоднозначной. В качестве выхода из этого затруднительного положения может стать отказ от перегрузки и использование двух разных имен методов. ## Ограничения, накладываемые на обобщения На обобщения накладывается ряд ограничений, которые следует учитывать при их употреблении в программах на Java. К числу подобных ограничений относится создание объектов, определяемых параметром типа, использование статических членов класса, генерирование исключений и обращение с массивами. Рассмотрим все эти ограничения более подробно. ### Невозможность получить экземпляры параметров типа Экземпляр параметра типа получить невозможно. Рассмотрим в качестве примера следующий класс:

// Экземпляр типа Т получить нельзя, class Gen { Т ob; Gen () { ob = new T(); // Недопустимо!!! } } В данном примере любая попытка получить экземпляр типа т приводит к ошибке. Ее причину понять нетрудно: компилятору ничего не известно о типе создаваемого объекта, поскольку тип Т является заполнителем, который стирается во время компиляции. ### Ограничения, накладываемые на статические члены класса В статических членах нельзя использовать параметры типа, объявленные в содержащем их классе. Так, все объявления статических членов в приведенном ниже классе недопустимы.

class Wrong { // Статическую переменную типа Т создать нельзя, static Т ob; // В статическом методе нельзя использовать тип Т. static Т getob() { return ob; } // Статический метод не может обращаться к объекту типа Т. static void showob() { System.out.println(ob); }

} Несмотря на наличие описанного выше ограничения, допускается все же объявлять обобщенные статические методы, в которых используются собственные параметры типа. Примеры таких объявлений приводились ранее в этой главе. ### Ограничения, накладываемые на обобщенные массивы На массивы обобщенного типа накладываются два существенных ограничения. Во– первых, нельзя получить экземпляр массива, тип элементов которого определяется параметром типа. И во-вторых, нельзя создать массив обобщенных ссылок на объекты конкретного типа. Оба эти ограничения демонстрируются в приведенном ниже кратком примере программы.

// Обобщенные типы и массивы, class Gen { T ob; T vals[]; // Допустимо. Gen(T о, T[] nums) { ob = о; // Следующее выражение недопустимо: // vals = new Т[10]; // Нельзя создать массив типа Т. // Следующее выражение составлено верно. vals = nums; // Переменной допускается присваивать ссылку // на существующий массив. }

}

class GenArrays { public static void main(String args[]) { Integer n[] = { 1, 2, 3, 4, 5 }; Gen iOb = new Gen(50, n); // Нельзя создать массив обобщенных ссылок // на объекты конкретного типа. // Gen gens[] = new Gen[10]; // Ошибка! // Следующее выражение составлено верно. Gen gens[] = new Gen[10]; }

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

Т vals[]; // Допустимо. Но получить экземпляр самого массива типа т нельзя. Именно поэтому приведенная ниже строка кода закомментирована.

// vals = new Т[10]; // Нельзя создать массив типа Т. В данном случае ограничение на массив типа т состоит в том, что компилятору не известно, какого типа массив следует создавать на самом деле. Но в то же время конструктору Gen () можно передать ссылку на массив совместимого типа при создании объекта, а также присвоить это значение переменной vals. Примером тому может служить следующая строка кода:

vals = nums; // Переменной допускается присваивать ссылку // на существующий массив. Это выражение составлено верно, поскольку тип массива, передаваемого конструктору Gen () при создании объекта, известен и совпадает с типом Т. В теле метода main () содержится выражение, демонстрирующее невозможность объявить массив обобщенных ссылок на объекты конкретного типа. Поэтому приведенная ниже строка кода не будет скомпилирована.

// Gen gens[] = new Gen[10] ; // Ошибка! ### Ограничения, накладываемые на обобщенные исключения Обобщенный класс не может расширять класс Throwable. Это означает, что создавать обобщенные классы исключений нельзя. ### Дальнейшее изучение обобщений Как пояснялось в начале этой главы, приведенных в ней сведений достаточно для того, чтобы эффективно пользоваться обобщениями в создаваемых на Java программах. Но у обобщений имеется немало особенностей, которые не нашли отражения в этой главе. Читатели, которых заинтересовала эта тема, вероятно, захотят узнать побольше о томвлиянии, которое обобщения оказывают на иерархию классов и, в частности, каким образом осуществляется сравнение типов при выполнении программы, как переопределяются методы и т.д. Все эти и многие другие вопросы употребления обобщений подробно освещены в книге Java. Полное руководство, 8-е издание, ИД “Вильямс”, 2012 г. ## Упражнение для самопроверки по материалу главы 13 1. Обобщения очень важны, поскольку они позволяют создавать код, который: a) обеспечивает типовую безопасность; b) пригоден для повторного использования; c) отличается высокой надежностью; d) обладает всеми перечисленными выше свойствами. 2. Можно ли указывать простой тип в качестве аргумента типа? 3. Как объявить класс FlightSched с двумя параметрами типа? 4. Измените ваш ответ на вопрос 3 таким образом, чтобы второй параметр типа обозначал подкласс, производный от класса Thread. 5. Внесите изменения в класс FlightSched таким образом, чтобы второй параметр типа стал подклассом первого параметра типа. 6. Что обозначает знак ? в обобщениях? 7. Может ли метасимвольный аргумент быть ограниченным? 8. У обобщенного метода My Gen () имеется один параметр типа, определяющий тип передаваемого ему аргумента. Этот метод возвращает также объект, тип которого соответствует параметру типа. Как должен быть объявлен метод My Gen () ? 9. Допустим, обобщенный интерфейс объявлен так, как показано ниже. interface IGenIF { // ... ``` Составьте объявление класса MyClass, который реализует интерфейс iGenlF.

Допустим, имеется обобщенный класс Counter. Как создать объект его базового типа?

Существуют ли параметры типа на стадии выполнения программы?

Видоизмените ответ на вопрос 10 в упражнении по материалу главы 9 таким образом, чтобы сделать класс обобщенным. По ходу дела создайте интерфейс стека iGenStack, объявив в нем обобщенные методы push () и pop ().

Что обозначают угловые скобки (< >)?

Как упростить приведенную ниже строку кода в версии JDK 7?MyClass obj = new MyClass(1.1,"Hi");

Глава 14 Апплеты, события и прочее

Основные навыки и понятия

Представление об апплетах

Архитектура апплетов

Создание заготовок апплетов

Инициализация и завершение апплетов

Перерисовка содержимого окон апплетов

Вывод данных в окне состояния

Передача параметров апплетам

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

Применение модели делегирования событий

Описание остальных ключевых слов Java

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

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

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

Апплеты существенно отличаются от всех программ, примеры которых были рассмотрены в предыдущих главах. Как пояснялось в главе 1, апплеты – это небольшие прикладные программы, предназначенные для передачи через Интернет и выполнения в веббраузере. В виртуальной машине Java поддерживаются все типы программ на Java, в том числе и апплеты, что дает возможность обеспечить достаточный уровень безопасности при динамической загрузке апплетов и последующем их выполнении в веб-браузере.

Прежде всего, апплеты подразделяются на две категории: те, что создаются на основе библиотеки Abstract Window Toolkit (AWT), и те, что создаются на основе библиотеки Swing. В апплетах обеих категорий поддерживается графический пользовательский интерфейс. Причем AWT позволяет работать с обычными элементами пользовательского интерфейса, a Swing – с альтернативными им упрощенными компонентами. В этой главе рассматриваются апплеты, создаваемые на основе библиотеки AWT, тогда как библиотеке Swing посвящена глава 15. Следует, однако, иметь в виду, что в апплетах на основе Swing используется та же самая архитектура, что и в апплетах на основе AWT. Более того, библиотека Swing построена на основе библиотеки AWT. Поэтому сведения и приемы программирования, представленные в этой главе, в равной степени относятся к обеим категориям апплетов.

Перед тем как приступить к подробному изложению теоретических вопросов, рассмотрим простой пример апплета. Он выполняет лишь одно действие: отображает в окне строку "Java makes applets easy" (Java упрощает создание апплетов). // Апплет с минимальными функциональными возможностями, import java.awt.*; // Обратите внимание на эти операторы. import java.applet.*; public class SimpleApplet extends Applet { public void paint(Graphics g) { // Вывод символьной строки в окне апплета. g.drawstring("Java makes applets easy.", 20, 20); } }

В начале апплета находятся два оператора import. С помощью первого из них импортируются классы из библиотеки Abstract Window Toolkit. Благодаря тому что в состав этой библиотеки входят средства поддержки оконного графического пользовательского интерфейса, апплеты (прямо или косвенно) взаимодействуют с пользователями именно через такой интерфейс, а не через консольный ввод-вывод. Как и следовало ожидать, размеры библиотеки AWT достаточно велики, поэтому подробное обсуждение всех ее возможностей выходит за рамки этой книги. Но поскольку в этой главе речь идет о создании лишь самых простых апплетов, то средства AWT будут использоваться в ней очень ограниченно. Во втором операторе import импортируется пакет applet, в который входит класс Applet. Любой апплет должен быть (прямо или косвенно) подклассом, производным от этого класса.

В следующей строке кода объявляется класс SimpleApplet, который должен быть открытым (public), поскольку доступ к нему будет осуществляться извне.

В классе SimpleApplet объявляется метод paint (). Этот метод является членом класса Component из библиотеки AWT, являющегося суперклассом по отношению к классу Applet, и должен переопределяться в апплете. Метод paint () вызывается всякий раз, когда в апплете должны быть обновлены выводимые данные. Такой вызов может быть сделан по разным причинам. Например, окно, в котором присутствует апплет, может быть перекрыто другим окном, а затем снова переведено на передний план. Окно может быть также свернуто, а затем развернуто до обычных размеров. Метод paint () всегда вызывается в начале выполнения апплета. Этому методу передается один параметр, который представляет собой объект типа Graphics. В этом объекте содержится графический контекст, описывающий среду, в которой выполняется апплет. Этот контекст используется в тех случаях, когда требуется вывести данные в окне апплета.

В теле метода paint () вызывается метод drawstring (), который является членом класса Graphics. Этот метод служит для вывода текстовой строки в окне апплета, начиная с точки с координатами X,Y. Общая форма его объявления имеет следующий вид: void drawString(String сообщение, int х, int у) 1

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

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

Исходный код класса SimpleApplet компилируется таким же образом, как и примеры предыдущих программ. А запуск апплета на выполнение осуществляется иначе: средствами браузера или инструментального средства разработки, специально предназначенного для просмотра апплетов. Такое инструментальное средство входит в стандартный пакет JDK и называется appletviewer. Именно им следует пользоваться для выполнения апплетов, примеры которых приведены в этой главе. Разумеется, ничто не мешает вам употреблять для этой цели браузер, но на стадии разработки пользоваться средством просмотра appletviewer намного удобнее.

Для выполнения апплета (средствами браузера или appletviewer) можно, в частности, составить небольшой файл HTML-документа, который содержит дескриптор для загрузки апплета. В настоящее время компания Oracle рекомендует использовать для этой цели дескриптор APPLET. (С той же целью можно также воспользоваться дескриптором OBJECT или другими доступными методиками развертывания прикладных программ. За более подробными сведениями по данному вопросу обращайтесь к документации на Java.) Ниже приведен код из HTML-документа, с помощью которого запускается апплет SimpleApplet.

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

Для того чтобы запустить апплет SimpleApplet на выполнение средствами appletviewer, последнему нужно передать для открытия файл соответствующего HTML-документа. Так, если приведенный выше код HTML находится в файле StartApp. html, то для запуска апплета SimpleApplet в командной строке необходимо ввести следующее: С:>appletviewer StartApp.html

И хотя пользоваться отдельным файлом HTML-документа для запуска апплета вполне допустимо, существует и более простой способ добиться той же самой цели. Для этого достаточно ввести в самом начале исходного кода Java строку комментариев и указать в ней дескриптор APPLET. Если обратиться к примеру апплета SimpleApplet, то его исходный код будет выглядеть следующим образом: import java.awt.*; import java.applet.*; // Следующий код HTML используется в appletviewer для запуска апплета. /* */ public class SimpleApplet extends Applet { public void paint(Graphics g) { g.drawString("Java makes applets easy.", 20, 20); } }

Теперь апплет можно запустить на выполнение, передав имя его исходного файла средству просмотра applet viewer. Для запуска на выполнение апплета SimpleApplet в командной строке нужно ввести следующее: С:>appletviewer SimpleApplet.j ava

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

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

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

Каждый апплет является подклассом, производным от класса Applet.

Для выполнения апплета метод main () не требуется.

Апплет должен выполняться средствами специальной программы просмотра или совместимого с Java веб-браузера.

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

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

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

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

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

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