Linuxformat - Вклад участника [ru]

LXF84:Opera 9

2008-04-04T06:36:44Z

Skryabin yuri: Текст

== Opera 9 ==
''Песенка коммерческой Opera уже спета, но шоу, тем не менее, продолжается.
'''Ричард Коббетт''' разбирается в деталях.''

{{врезка|Ширина=200px|left|
Заголовок=Вкратце...|
Содержание=Новейшая версия комплекта Opera "все-в-одном", с виджетами и поддержкой BitTorrent,
по-прежнему отличается высокой скоростью.}}
[[Image:Img_84_00_0.png|thumb|300px|Все, что нужно от браузера, если не вообще все, что нужно – добавка новой системы виджетов к прежде неизменной линейке Opera.]]
Вы жалели Opera. Не потому, что он остался в стороне от титанической схватки между Explorer и Firefox, и даже не потому, что это достойный претендент, так и не дождавшийся своего часа. А потому, что нет другого браузера с такой богатой историей первопроходца в самых крутых вещах — от жестов мышью до вкладок и ээ… Greasemonkey (хотя в Opera это уныло называлось User JS, потому-то он и не взлетел) — и тем не менее его вспоминают всего лишь как «браузер с баннерами».

Все, хватит. Теперь Opera 9 бесплатен, освобожден от прежних рекламных и лицензионных ключей, готов к действию. И вот вам факт — «на выходе из коробки» это самый вылизанный и функциональный браузер из
имеющихся. Пользоваться Opera не только просто, но и приятно. До всего, что вам нужно, дотянетесь мышью, и нет нужды ни в каких расширениях. Это полный web-пакет, справляющийся и с простейшим Интернет-серфингом, и с почтой (IMAP и POP3).

Звучит неплохо? Да. Но есть и недостатки. Если сайт построен в духе любимых Дэвидом Картрайтом [David Cartwright] web-стандартов, то проблем не возникнет — Opera 9 проходит тест Acid2 и превосходно обрабатывает большинство статических страниц. Но вот многие сайты на Ajax, созданные и тестированные
эксклюзивно под IE и Firefox — другое дело. Google Calendar более-менее совместим, но все еще отмечает Opera как неподдерживаемый браузер, а динамические ссылки в инструменте online-заметок Backpack ломаются. Может быть, посещаемых именно вами сайтов проблемы и не касаются — но некоторые страницы просто не работают.

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

=== Быстрее всех ===
{{врезка|Ширина=200px|left|
Заголовок=Грэм считает...|
Содержание=«Все мы любим Opera, но она предлагает недостаточно, чтобы превзойти способности
Firefox или живую многоплановость Konqueror».}}

{{врезка|Ширина=200px|left|
Заголовок=Свойства навскидку|
Содержание=
*BitTorrent
[[Image:Img_84_00_0.png|thumb|Загрузка через встроенный BitTorrent стремительна, как падение с дерева.]]
*Виджеты
[[Image:Img_84_00_0.png|thumb|Виджеты кросс-платформенные, хотя на Linux наблюдаются некоторые графические проблемы.]]
}}
В скорости Opera равных нет, если говорить о рендеринге страниц и времясберегающих функциях движка. Потребление памяти в нашем тесте составило 28 МБ — меньше, чем Firefox и Epiphany (оба потянули на
32 МБ). Усиленно рекламируемой на сайте Opera голосовой системы управления пока нет, но легкость доступа ко всем инструментам, и множество клавиатурных комбинаций делают эту нехватку несущественной. Один из самых полезных инструментов — диалоговое окно Site Preferences (Параметры сайтов), в котором можно отключить навязчивые cookies и встроенные фреймы или настроить обработку «правого» щелчка мыши, а также добавить собственную таблицу стилей или файл JavaScript, чтобы изменить поведение страницы.

Наиболее значительное дополнение — система виджетов (Widget). При работе Opera виджеты порхают друг над другом и над рабочим столом, и установка любого из них — дело одного щелчка. Не удивительно, что поисковый инструмент BitTorrent расположен выше всех; сразу за ним следуют напоминания и простые игры — их несложно создать, и они кросс-платформенны.

У Opera остались проблемы с просмотром web-сайтов, и вариант «все-в-одном» не похож на Firefox с миллионом расширений. Но это совершенно иной стиль браузера, при котором все инструменты работают совместно, а не явились со всех концов сети, и тут есть свои преимущества. Виджеты — превосходное дополнение, а солидный самостоятельный браузер позволяет немедленно окунуться в Сеть с головой.
{{врезка|Ширина=300px|
Заголовок=LinuxFormat Вердикт|
Содержание=
'''Opera 9'''

Developer: Opera Software

Web: http://www.opera.com

Price: Бесплатно по закрытой лицензии

*Функциональность 9/10
*Производительность 9/10
*Простота использования 9/10
*Документация 7/10

Хорош и для продвинутых пользователей, и для простых любителей
Интернета, но возможны проблемы с сайтами, использующими Ajax.

'''Рейтинг 8/10'''
}}

LXF84:AC3D 6

2008-04-04T06:15:32Z

Skryabin yuri: Врезки и вердикт

==AC3D 6==
''Linux не обижен инструментами 3D-моделирования, но почти все они – не для обычного
пользователя. '''Ник Вейч''' отыскал среди них не требующий семи пядей во лбу.''

{{врезка|Ширина=200px|left|
Заголовок=Вкратце...|
Содержание=Платный инструмент объемного моделирования со славной историей. Аналоги - Blender, Maya и Realsoft 3D.}}
[[Image:Img_84_00_0.png|thumb|300px|От простейших предметов до сложных игровых миров – AC3D умеет делать все.]]
Производители спецэффектов давно влюблены в платформу Linux – она экономит время и деньги в сравнении с другими, менее стабильными, системами. Но их фирменные приложения вряд ли доступны для эффективного использования непрофессионалами. Поприветствуем же AC3D, программу, достаточно простую для домашнего пользователя и, при этом, достаточно мощную по всем параметрам. Ныне она празднует свое десятилетие (первоначально AC3D создавалась для Unix и Windows), причем все это время она активно развивалась.
===Всеобщая совместимость===
AC3D гораздо лучше других Linux-инструментов справляется с открытием файлов 3D Studio Max, LightWave 3D, DXF (AutoCAD) и...
всех остальных. Огромное количество сред разработки, в которых теперь создаются 3D-объекты, а также проприетарная природа систем рендеринга привели к появлению множества разных форматов. Способность AC3D понимать их – одно из тех качеств программы, которые окупают расходы; вот только иногда в процессе трансляции теряются некоторые текстуры и объекты.

Благодаря кросс-платформенности AC3D можно работать даже с теми форматами, которые на Linux обычно не поддерживаются – например, MilkShape (эта программа часто используется для моделирования арены компьютерных игр). Возможность экспорта в эти форматы существенна, если необходимо включить в рабочий процесс другие закрытые программы. Фактически, AC3D может запросто обращаться ко многим рендерерам (по умолчанию – POV-Ray), хотя это более полезно для Windows/Mac версии.

===Интерфейс похорошел===
{{врезка|Ширина=200px|left|
Заголовок=Свойства навскидку|
Содержание=
*Ревизия интерфейса
[[Image:Img_84_00_0.png|thumb|В переработанном интерфейсе инструменты проще в использовании, да и на вид они проще!]]
*Подповерхности
[[Image:Img_84_00_0.png|thumb|С помощью «подповерхностей» значительно проще создавать «живые» фигуры.]]
}}
В версии 6 капитально обновился пользовательский интерфейс, основные инструменты получили цветные значки, теперь их нетрудно отыскать. По ощущению, программа стала значительно быстрее и отзывчивее, чем в предыдущей версии. Возможно, это просто следствие обновления наших компьютеров с тех пор, как мы в последний раз рассматривали AC3D – OpenGL-рендеринг видов тоже заметно порезвел.

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

AC3D довольно долго считалась инструментом доводки, ведь в ней отсутствовали многие сложные функции, доступные в других
платных программах. Это во многом справедливо: AC3D в основном полигональный/вершинный редактор без прихотливых режимов
моделирования; но теперь он поддерживает впечатляющую функцию работы с «подповерхностями» (соподчиненными поверхностями), которая существенно упрощает создание «органичных» фигур и плавных изгибов. Если у вас уже есть Maya, то вы, возможно, не захотите связываться с AC3D (при всем многообразии поддерживаемых форматов). Если же вы устали бороться с превосходным, но сложным Blender – загрузите (свободно) пробную версию AC3D, и попробуйте начать с нее.
{{врезка|Ширина=300px|
Заголовок=LinuxFormat Вердикт|
Содержание=
'''AC3D 6'''

Разработчик: Inivis

Сайт: http://www.ac3d.org

Цена: $69.95

*Функциональность 9/10
*Производительность 9/10
*Простота использования 8/10
*Цена 8/10

$69,95 – сущая безделица за такой
основательный, такой простой и такой
полезный товар.

'''Рейтинг 9/10'''
}}

Файл:Img 84 00 0.png

2008-04-04T05:57:55Z

Skryabin yuri: Врем. рис.

Врем. рис.

LXF84:AC3D 6

2008-04-04T05:50:29Z

Skryabin yuri: Текст

==AC3D 6==
''Linux не обижен инструментами 3D-моделирования, но почти все они – не для обычного
пользователя. '''Ник Вейч''' отыскал среди них не требующий семи пядей во лбу.''

Производители спецэффектов давно влюблены в платформу Linux – она экономит время и деньги в сравнении с другими, менее стабильными, системами. Но их фирменные приложения вряд ли доступны для эффективного использования непрофессионалами. Поприветствуем же AC3D, программу, достаточно простую для домашнего пользователя и, при этом, достаточно мощную по всем параметрам. Ныне она празднует свое десятилетие (первоначально AC3D создавалась для Unix и Windows), причем все это время она активно развивалась.
===Всеобщая совместимость===
AC3D гораздо лучше других Linux-инструментов справляется с открытием файлов 3D Studio Max, LightWave 3D, DXF (AutoCAD) и...
всех остальных. Огромное количество сред разработки, в которых теперь создаются 3D-объекты, а также проприетарная природа систем рендеринга привели к появлению множества разных форматов. Способность AC3D понимать их – одно из тех качеств программы, которые окупают расходы; вот только иногда в процессе трансляции теряются некоторые текстуры и объекты.

Благодаря кросс-платформенности AC3D можно работать даже с теми форматами, которые на Linux обычно не поддерживаются – например, MilkShape (эта программа часто используется для моделирования арены компьютерных игр). Возможность экспорта в эти форматы существенна, если необходимо включить в рабочий процесс другие закрытые программы. Фактически, AC3D может запросто обращаться ко многим рендерерам (по умолчанию – POV-Ray), хотя это более полезно для Windows/Mac версии.

===Интерфейс похорошел===
В версии 6 капитально обновился пользовательский интерфейс, основные инструменты получили цветные значки, теперь их нетрудно отыскать. По ощущению, программа стала значительно быстрее и отзывчивее, чем в предыдущей версии. Возможно, это просто следствие обновления наших компьютеров с тех пор, как мы в последний раз рассматривали AC3D – OpenGL-рендеринг видов тоже заметно порезвел.

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

AC3D довольно долго считалась инструментом доводки, ведь в ней отсутствовали многие сложные функции, доступные в других
платных программах. Это во многом справедливо: AC3D в основном полигональный/вершинный редактор без прихотливых режимов
моделирования; но теперь он поддерживает впечатляющую функцию работы с «подповерхностями» (соподчиненными поверхностями), которая существенно упрощает создание «органичных» фигур и плавных изгибов. Если у вас уже есть Maya, то вы, возможно, не захотите связываться с AC3D (при всем многообразии поддерживаемых форматов). Если же вы устали бороться с превосходным, но сложным Blender – загрузите (свободно) пробную версию AC3D, и попробуйте начать с нее.

LXF84:Google Earth

2008-04-04T04:36:04Z

Skryabin yuri: доб Вердикт LXF

== Google Earth ==
''Предвидя захват Земли хакерами, '''Грэм Моррисон''' рассматривает проект Google – никогда ещё виртуальная жизнь не была так хороша.''

{{врезка|Ширина=200px|left|
Заголовок=Вкратце...|
Содержание=Исследуйте Землю за своим рабочим столом с помощью спутниковых изображений и 3D-данных. См. также: Celestia или ожидаемый NASA World Wind 1.5.}}
[[Image:Img_84_08_1.png|thumb|300px|Пусть Большой Каньон находится на другой стороне планеты – исследовать фотогеничную американскую бездну можно, не выходя из-за компьютера.]]
Надо признать, что год назад, когда был выпущен Google Earth для Windows, впечатление было сильным. Мы завистливо наблюдали, как знакомые почитатели Windows и Mac запускают виртуальную планету Google и бороздят Тихий океан в поисках неисследованных территорий
или просто удобного места для отпуска. Но больше мы им не завидуем! Google cовершил благородный поступок и выпустил родной
порт для старого доброго Linux. Родной – это вам не полуподпольные библиотеки Wine для обработки системных вызовов Windows, как в
Picasa (см. обзор [[LXF83|LXF83]]). Всё сделано основательно, с помощью Qt и под OpenGL.

Для тех, кому пока не посчастливилось наблюдать Google Earth в действии – это естественное расширение Google Maps. При первом запуске мы видим голубое пятнышко Земли с расстояния порядка 15 000 миль. Прокрутка мыши приближает нас к родной планете, пока мы не зависнем над США. Чем дольше вы держитесь на одном месте, тем детальнее становится вид – Google Earth безостановочно транслирует спутниковое изображение со своего сервера. Именно поэтому вам понадобится как минимум широкополосное подключение к Интернету: только тогда вы
насладитесь в полной мере.

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

=== Полёт навигатора ===
{{врезка|Ширина=200px|left|
Заголовок=Свойства навскидку|
Содержание=
*Высота гор
[[Image:Img_84_08_2.png|thumb|Использование высотных данных означает, что горы типа Эвереста поднимаются над
земной поверхностью.]]
*Отображение зданий
[[Image:Img_84_08_3.png|thumb|В нескольких городах США отображаются даже дома, а пользователи добавили
текстурные здания и в другие места.]]
}}
Секстант не понадобится: навигация сводится к набору на клавиатуре названия места, куда вы хотели бы попасть. Вид плавно удаляется в космос, затем перемещается к месту назначения. Приоритеты расставлены с американских позиций – например, если набрать
«Birmingham», то вы угодите в Алабаму, а не в более крупный город в Британии.

Прибыв на место назначения, можно щёлкать и перемещать карту мышью (совсем как в Google Maps). Но если нажать и удерживать
среднюю кнопку мыши, вы измените угол зрения со стандартного (сверху вниз, как со спутника) до совершенно горизонтального,
если захотите. Google Maps так не умеет – а что особенно поражает, Google Earth использует высотные данные для приближённого
отображения неровностей земной поверхности. Например, посетив Эверест или Большой Каньон, вы увидите их реалистичные модели.

Надоело выискивать собственное местонахождение? Интернет полон открытиями других людей. Они пользуются KML, Keyhole Markup Language, и отмечают интересные места, новые 3D-модели (с текстурами!), фото, клипы и информацию, напрямую связанные с Интернетом. Поиски могут вывести и на рекламодателей Google, аналогично страницам поиска в поисковой машине. Это может пригодиться, если вы, скажем, ищете ближайший ресторан в Непале, а программа в этом помочь не может. Закладки делаются на всех интересных местах, совершенно так же, как в обычном браузере.

Захлопает бабочка крылышками на другой стороне планеты – и Google Earth создаст у вас иллюзию, что двойным щелчком мыши можно
вмешаться в это событие и наблюдать наступивший хаос. Google Earth будит желание поохотиться за метеоритными кратерами или найти исток Амазонки. Бесплатный ресурс такой мощи просто не за что критиковать.
{{врезка|Ширина=300px|
Заголовок=LinuxFormat Вердикт|
Содержание=
'''Google Earth'''

Разработчик: Google

Сайт: http://earth.google.com

Цена: Бесплатно по закрытой лицензии

*Функциональность 10/10
*Производительность 9/10
*Простота использования 9/10
*Документация 9/10

Если весь мир – сцена, то Google Earth – театр. Простая в использовании, захватывающая и ободряюще практичная программа.

'''Рейтинг 9/10'''
}}

LXF84:Google Earth

2008-03-25T10:36:05Z

Skryabin yuri: Врезка

LXF86:Java

2008-03-20T05:35:06Z

Skryabin yuri: Изменена ссылка на следующую статью

{{Цикл/Java}}

=== Хранение данных ===
''ЧАСТЬ 3: Даже самой замечательной программе надо откуда-то черпать данные для своей работы. Данные, как известно, хранятся в файлах. Тему продолжает '''Антон Черноусов'''.''

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

В течение третьего урока мы поговорим о работе с файлами, о протоколировании работы программы и коснемся методов работы с
XML-данными.

=== Файлы — потоки ===
Сказочное королевство под руководством царевны Несмеяны (так как cупруг практически всегда отсутствовал), благодаря талантам и приобретенным навыкам, стало разрастаться, и результаты полюдья просто-напросто перестали помещаться в семейный чулан. Чтобы накапливать и хранить богатства, потребовались дополнительные помещения, роль которых для нас привычно играют файлы.

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

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

=== Чтение данных ===
Разнообразие классов для работы с файлами позволяет выбрать для себя ту связку, которая больше нравится. Лично я для чтения данных использую BufferedReader, InputStreamReader и FileInputStream. Собственно взаимодействие этих классов для программиста заканчивается в момент создания экземпляра BufferedReader, что делается следующим образом:

<source lang = "java">
BufferedReader br = null;
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile), encoding));
</source>

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

<source lang = "java">
protected static String DEFAULT_ENCODING = "UTF-8";
</source>

Любой текстовый файл можно представить себе в виде набора строк, поэтому давайте реализуем метод для считывания содержимого
файла в массив String[]. Далее представлен метод rippedCurrentFile(path ToFile, encoding) класса FileRipper, который извлекает данные из файла с помощью метода readLine() экземпляра класса BufferedReader:

<source lang = "java">
protected boolean rippedCurrentFile(String pathToFile, String encoding) {
// connecting to file
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile),encoding));
}
catch (UnsupportedEncodingException e) {
this.error = FILE_ERROR_UNSUPPORTED_ENCODING; return false;
}
catch (FileNotFoundException e) {
this.error = FILE_ERROR_NO_FILE; return false;
}
// ripping the file
String str = null;
ArrayList allStrings = new ArrayList();
try {
while (!(str = br.readLine()).equals(null)) { allStrings.add(str); }
}
catch (IOException e) {
this.error = FILE_ERROR_IO_READ; return false;
}
catch (NullPointerException e) {
this.error = FILE_ERROR_END_OF_FILE;
}
// free the resources
try {
br.close();
}
catch (IOException e) {
this.error = FILE_ERROR_IO_CLOSE; return false;
}
this.allStrings = (String[]) allStrings.toArray(new String[0]);
return true;
}

</source>
Полный код примера, в том числе код класса ConsoleToFileRipper, применяющий экземпляр класса FileRipper для извлечения данных из файла, можно найти на диске в каталоге '''examples 1'''.

=== Запись данных ===
Процесс записи данных в файл хоть и отличается от чтения, но тоже достаточно похож на организацию конвейера. Для записи
я обычно использую связку BufferedWriter, OutputStreamWriter, FileOutputStream.
<source lang = "java">
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
</source>
Для освобождения ресурсов, которые используют экземпляры классов BufferedReader и BufferedWriter, необходимо вызвать метод
close().

Далее приведу простой пример метода, который записывает строковый массив в файл (полный код метода расположен на диске в
директории '''examples 2'''):
<source lang = "java">
public boolean createCurrentFile(String pathToFile, String[] allStrings, String encoding){
try {
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
for (int i = 0; i < allStrings.length; i++) {
out.write(allStrings[i]); out.write(‘\n’);
}
out.close();
}
catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
</source>

=== Свободный доступ ===
В представленных ранее примерах доступ к данным осуществляется последовательно, что не всегда удобно (хотя в большинстве случаев именно такой доступ и используется). Для осуществления чтения и записи данных из файла в произвольном порядке существует специальный класс RandomAccessFile, экземпляр которого создается следующим образом:
<source lang = "java">
RandomAccessFile raf = new RandomAccessFile(pathToFile, mode);
</source>
При этом pathToFile — путь до файла, а mode — режим работы. mode может принимать значения: r (только чтение), rw (чтение-запись), rws (чтение-запись с синхронным сохранением содержимого и метаданных), rwd (чтение-запись с синхронным сохранением содержимого файла). К сожалению, кодировку указать нельзя. Огромным преимуществом подхода является то, что с помощью метода getFilePointer() можно узнать текущее месторасположение указателя, а с помощью метода seek() можно передвинуть указатель в необходимое место в файле. Я предпочитаю не использовать данный класс — считайте это личным предубеждением.

=== Протоколирование работы программы ===
Для контроля и анализа работы приложения существуют методы протоколирования. Популярным инструментом для этих целей в мире
Java является библиотека Log4j, которая разрабатывается в Apache Software Foundation. Текущую версию можно загрузить с [http://logging.apache.org/[http://logging.apache.org/]].

Для использования библиотеки необходимо создать конфигурационный файл, который описывает, что, куда и как нужно протоколировать. Log4j имеет три базовые составляющие: logger, appender и layout.

layout — это элементы, определяющие вид и содержание записей. Изначально имеется несколько заранее созданных layout-ов, а в случае необходимости можно создать свой собственный.

Appender — это элемент, определяющий местоположение протокола, с его помощью задается тип протоколирования:
* файловое протоколирование (FileAppender);
* консольное протоколирование (ConsoleAppender);
* протоколирование в базы данных (JDBCAppender);
* протоколирование на SMTP-сервера (SMTPAppender) и др.

Logger — это элемент, который обеспечивает протоколирование какого-либо события. Если обратиться к ранее приведенной аналогии
ленточного конвейера, logger — это и есть тот самый конвейер, вызывая методы которого, мы формируем протокол работы программы.
Элемент logger предусматривает следующие уровни протоколирования: DEBUG, INFO, WARN, ERROR, FATAL; уровням соответствуют методы класса org.apache.log4j.Logger: debug; info; warn; error; fatal.

Ниже представлен пример записей для конфигурационного файла нашего приложения, которые нужно сохранить в файл с названием '''log.properties''' (название файла может быть любым).

<code>
log4j.logger.simple=DEBUG, nameLogAppender
log4j.appender.nameLogAppender=org.apache.log4j.FileAppender
log4j.appender.nameLogAppender.File=nameLogFile.log
log4j.appender.nameLogAppender.layout=org.apache.log4j.SimpleLayout
</code>

Первая строка указывает используемый уровень logger (DEBUG) и appender (nameLogAppender). Далее идут настройки appender: указание типа — FileAppender. В третьей строке указываем путь до файла журнала, а в последней — формат записи. Использовать экземпляр класса Logger можно примерно так (пример протоколирования приведен на диске в каталоге '''examples 3'''):
<source lang = "java">
File propertiesFile = new File("log.properties");
PropertyConfigurator.configure(propertiesFile.toString());
Logger logger = Logger.getLogger("simple");
logger.info("the program has started");
</source>

=== Документы XML ===
Проектируя и создавая ПО, невозможно не столкнутся с миром XML (Extensible Markup Language). XML был создан в недрах World Wide
Web Consortium (W3C) для преодоления ограничений языка HTML. Можно сказать, что HTML — один из самых успешных языков, область
его использования с каждым годом растет (в основном в объемах). Несмотря на это, почему же W3C создал XML, и зачем вам использовать этот язык? В чем ограниченность HTML? Ответ на эти вопросы один:XML был создан для обеспечения взаимодействия разнородных систем.

HTML, как и любой другой текстовый язык, не позволяет перенести смысл тех данных, которые он хранит. XML был разработан для решения этой задачи с прицелом на Web, но получился таким удачным, что его стали использовать практически везде. Суть XML в том, что он хранит семантический смысл данных, поэтому выполнив анализ такого XML-документа, система может «понять» полученные данные. В Интернете существует большое количество информации, посвященной XML (например, [http://www.ibm.com/developerworks/xml/[www.ibm.com/developerworks/xml/]]), поэтому не будем подробно останавливаться на его преимуществах, а сразу приступим к использованию.

<source lang = "xml">
<?xml version="1.0" ?>
<line name="firstLine">
<point id="1" theX="1" theY="1"/>
<point id="2" theX="2" theY="2"/>
</line>
</source>

Выше приведен простой пример XML-документа, содержащего корневой элемент line, который, в свою очередь, содержит два узла с
тремя атрибутами (id, theX, theY) каждый.

=== Создание XML-документа ===
Говоря про создание XML-документа, я подразумеваю создание дерева XML-документа в памяти системы, то есть объекта DOM (Document Object Model). DOM была создана W3C, и это — официальная Рекомендация консорциума. В противовес DOM существует SAX (Simple API for XML). С моделью SAX можно ознакомиться более подробно в
[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp]]. Основная разница между методами заключается в том, что DOM обеспечивает виртуальное представление XML-файла в памяти системы, в то время как SAX — это событийная модель обработки, в которой в момент встречи определенного элемента вызывается соответствующее событие.

Для создания «отображения» XML-файла в памяти системы необходимо воспользоваться классом Document, экземпляр которого можно получить следующим образом:
<source lang = "java">
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
</source>
Создание корневого узла XML документа можно выполняется так:
<source lang = "java">
Element root = doc.createElement("line");
root.setAttribute("name", "firstLine");
</source>
С помощью метода createElement(name) производится создание элементов, в то время как создание и установка значений атрибутов
элементов производится с помощью метода setAttribute(name, value), где name — имя атрибута, а value — его значение. С помощью метода appendChild можно добавить узел в элемент или произвести запись элемента в документ XML, например, так:
<source lang = "java">
root.appendChild(item);
doc.appendChild(root);
</source>
Более детально процесс создания XML документа на примере класса Line изложен в директории '''examples 4'''. При вызове метода
createDoc() этого класса создается экземпляр класса Document, идентичный приведенному ранее коду XML.

=== Сохранение XML-документа ===
Для сохранения созданного в памяти документа предлагаю воспользоваться методом saveXML(docToSave, pathToFile, charSet). В процессе сохранения участвует уже знакомый нам OutputStreamWriter, а также экземпляр класса Transformer, который обеспечивает преобразование объекта DOMSource в выходной поток.
<source lang = "java">
public void saveXML(Document docToSave, String pathToFile, String charSet) {
try {
Writer target = new OutputStreamWriter(new FileOutputStream(pathToFile), charSet);
Source source = new DOMSource(docToSave);
StreamResult dest = new StreamResult(target);
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.ENCODING, charSet);
t.setOutputProperty(OutputKeys.INDENT, "yes");
t.transform(source, dest);
target.flush();
target.close();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
</source>
Реализация этого метода представлена на диске в директории '''examples 5'''.

=== Загрузка XML-документа ===
Подобно сохранению XLM-документа, загрузка также достаточно просто выполняется с помощью экземпляра класса FileInputStream. Используя DocumentBuilderFactory, сгенерируем объект класса Document следующим образом:
<source lang = "java">
FileInputStream fis = new FileInputStream(pathToFile);
Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(fis);
</source>
Фактически, создание документа происходит вследствие выполнения метода parse. Для детально рассмотрения процесса загрузки
XML документа обратитесь к директории '''examples 6''', расположенной на диске.

=== Извлечение данных из XML-документа ===
Итак, что же делать с Document? Работать, естественно! Прежде чем приступить к обработке XML-документа, хочу обратить внимание на одну неприятную особенность: почти всегда XML документ содержит пустые узлы или символы перевода каретки (неизбежное зло форматирования). К сожалению, такая особенность существенно затрудняет процесс обработки XML-документа. Поэтому следует всегда проводить нормализацию с помощью определенного в интерфейсе метода normalize(), или, если реализация Document не имеет такой возможности или нормализация выполняется некорректно — воспользуйтесь методом normalizeDocument класса FileXMLReader (вы найдете его все в той же директории '''examples 6'''). Вызвать данный метод можно следующим образом:
<source lang = "java">
normalizeDocument(doc.getDocumentElement());
</source>
Изложенный выше материал получился несколько другого формата, нежели предыдущие статьи. Статья содержит небольшие примеры
и отсылает на набор сознательно упрощенных готовых решений, благодаря которым вы сможете работать с файлами, производить прото-
колирование деятельности вашего приложения, начать работать с данными в формате XML. Цель приведенных примеров — обеспечить вас
необходимым минимумом информации и дать направление для поиска ответов на Ваши вопросы. В [[LXF87/88:Java|следующей статье]] мы расмотрим потоки.

LXF84:Google Earth

2008-03-18T07:12:06Z

Skryabin yuri:

== Google Earth ==
''Предвидя захват Земли хакерами, '''Грэм Моррисон''' рассматривает проект Google – никогда ещё виртуальная жизнь не была так хороша.''

{{врезка|Ширина=200px|left|
Заголовок=Вкратце...|
Содержание=Исследуйте Землю за своим рабочим столом с помощью спутниковых изображений и 3D-данных. См. также: Celestia или ожидаемый NASA World Wind 1.5.}}
[[Image:Img_84_08_1.png|thumb|300px|Пусть Большой Каньон находится на другой стороне планеты – исследовать фотогеничную американскую бездну можно, не выходя из-за компьютера.]]
Надо признать, что год назад, когда был выпущен Google Earth для Windows, впечатление было сильным. Мы завистливо наблюдали, как знакомые почитатели Windows и Mac запускают виртуальную планету Google и бороздят Тихий океан в поисках неисследованных территорий
или просто удобного места для отпуска. Но больше мы им не завидуем! Google cовершил благородный поступок и выпустил родной
порт для старого доброго Linux. Родной – это вам не полуподпольные библиотеки Wine для обработки системных вызовов Windows, как в
Picasa (см. обзор LXF83). Всё сделано основательно, с помощью Qt и под OpenGL.

Для тех, кому пока не посчастливилось наблюдать Google Earth в действии – это естественное расширение Google Maps. При первом запуске мы видим голубое пятнышко Земли с расстояния порядка 15 000 миль. Прокрутка мыши приближает нас к родной планете, пока мы не зависнем над США. Чем дольше вы держитесь на одном месте, тем детальнее становится вид – Google Earth безостановочно транслирует спутниковое изображение со своего сервера. Именно поэтому вам понадобится как минимум широкополосное подключение к Интернету: только тогда вы
насладитесь в полной мере.

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

=== Полёт навигатора ===
Секстант не понадобится: навигация сводится к набору на клавиатуре названия места, куда вы хотели бы попасть. Вид плавно удаляется в космос, затем перемещается к месту назначения. Приоритеты расставлены с американских позиций – например, если набрать
«Birmingham», то вы угодите в Алабаму, а не в более крупный город в Британии.

Прибыв на место назначения, можно щёлкать и перемещать карту мышью (совсем как в Google Maps). Но если нажать и удерживать
среднюю кнопку мыши, вы измените угол зрения со стандартного (сверху вниз, как со спутника) до совершенно горизонтального,
если захотите. Google Maps так не умеет – а что особенно поражает, Google Earth использует высотные данные для приближённого
отображения неровностей земной поверхности. Например, посетив Эверест или Большой Каньон, вы увидите их реалистичные модели.

Надоело выискивать собственное местонахождение? Интернет полон открытиями других людей. Они пользуются KML, Keyhole Markup Language, и отмечают интересные места, новые 3D-модели (с текстурами!), фото, клипы и информацию, напрямую связанные с Интернетом. Поиски могут вывести и на рекламодателей Google, аналогично страницам поиска в поисковой машине. Это может пригодиться, если вы, скажем, ищете ближайший ресторан в Непале, а программа в этом помочь не может. Закладки делаются на всех интересных местах, совершенно так же, как в обычном браузере.

Захлопает бабочка крылышками на другой стороне планеты – и Google Earth создаст у вас иллюзию, что двойным щелчком мыши можно
вмешаться в это событие и наблюдать наступивший хаос. Google Earth будит желание поохотиться за метеоритными кратерами или найти исток Амазонки. Бесплатный ресурс такой мощи просто не за что критиковать.

Файл:Img 84 08 3.png

2008-03-18T06:02:55Z

Skryabin yuri: Google Earth рис 3

Google Earth рис 3

Файл:Img 84 08 2.png

2008-03-18T06:01:45Z

Skryabin yuri: Google Earth рис 2

Google Earth рис 2

Файл:Img 84 08 1.png

2008-03-18T06:00:49Z

Skryabin yuri: Google Earth рис 1

Google Earth рис 1

LXF84:Google Earth

2008-03-18T05:40:27Z

Skryabin yuri: Предварительный вариант

== Google Earth ==
''Предвидя захват Земли хакерами, '''Грэм Моррисон''' рассматривает проект Google – никогда ещё виртуальная жизнь не была так хороша.''

Надо признать, что год назад, когда был выпущен Google Earth для Windows, впечатление было сильным. Мы завистливо наблюдали, как знакомые почитатели Windows и Mac запускают виртуальную планету Google и бороздят Тихий океан в поисках неисследованных территорий
или просто удобного места для отпуска. Но больше мы им не завидуем! Google cовершил благородный поступок и выпустил родной
порт для старого доброго Linux. Родной – это вам не полуподпольные библиотеки Wine для обработки системных вызовов Windows, как в
Picasa (см. обзор LXF83). Всё сделано основательно, с помощью Qt и под OpenGL.

Для тех, кому пока не посчастливилось наблюдать Google Earth в действии – это естественное расширение Google Maps. При первом запуске мы видим голубое пятнышко Земли с расстояния порядка 15 000 миль. Прокрутка мыши приближает нас к родной планете, пока мы не зависнем над США. Чем дольше вы держитесь на одном месте, тем детальнее становится вид – Google Earth безостановочно транслирует спутниковое изображение со своего сервера. Именно поэтому вам понадобится как минимум широкополосное подключение к Интернету: только тогда вы
насладитесь в полной мере.

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

=== Полёт навигатора ===

Секстант не понадобится: навигация сводится к набору на клавиатуре названия места, куда вы хотели бы попасть. Вид плавно удаляется в космос, затем перемещается к месту назначения. Приоритеты расставлены с американских позиций – например, если набрать
«Birmingham», то вы угодите в Алабаму, а не в более крупный город в Британии.

Прибыв на место назначения, можно щёлкать и перемещать карту мышью (совсем как в Google Maps). Но если нажать и удерживать
среднюю кнопку мыши, вы измените угол зрения со стандартного (сверху вниз, как со спутника) до совершенно горизонтального,
если захотите. Google Maps так не умеет – а что особенно поражает, Google Earth использует высотные данные для приближённого
отображения неровностей земной поверхности. Например, посетив Эверест или Большой Каньон, вы увидите их реалистичные модели.

Надоело выискивать собственное местонахождение? Интернет полон открытиями других людей. Они пользуются KML, Keyhole Markup Language, и отмечают интересные места, новые 3D-модели (с текстурами!), фото, клипы и информацию, напрямую связанные с Интернетом. Поиски могут вывести и на рекламодателей Google, аналогично страницам поиска в поисковой машине. Это может пригодиться, если вы, скажем, ищете ближайший ресторан в Непале, а программа в этом помочь не может. Закладки делаются на всех интересных местах, совершенно так же, как в обычном браузере.

Захлопает бабочка крылышками на другой стороне планеты – и Google Earth создаст у вас иллюзию, что двойным щелчком мыши можно
вмешаться в это событие и наблюдать наступивший хаос. Google Earth будит желание поохотиться за метеоритными кратерами или найти исток Амазонки. Бесплатный ресурс такой мощи просто не за что критиковать.

Участник:Skryabin yuri

2008-03-18T05:29:23Z

Skryabin yuri:

== Скрябин Юрий ==
[[LXF84|LXF84]]

[[LXF85|LXF85]]

[[LXF86|LXF86]]

[[LXF87-88|LXF87/88]]

Участник:Skryabin yuri

2008-03-18T05:28:03Z

Skryabin yuri: Новая: == Скрябин Юрий == LXF84 LXF85 LXF86 LXF87/88

== Скрябин Юрий ==
[[LXF84|LXF84]]

[[LXF85|LXF85]]

[[LXF86|LXF86]]

[[LXF87/88|LXF87/88]]

LXF84:Что за штука...

2008-03-17T13:55:05Z

Skryabin yuri: Новая: == Что за штука... Java Server Faces? == '''''Ричард Драммонд''' прослышал о более простом и быстром способе строител...

== Что за штука... Java Server Faces? ==
'''''Ричард Драммонд''' прослышал о более простом и быстром способе строительства web-приложений. Определенно стоит разобраться…''

'''Сейчас много шумят об этой новой web-технологии, JavaServer Faces. Для чего она?'''

JavaServer Faces (сокращенно JSF) – компонентная платформа, призванная упростить разработку пользовательских интерфейсов для web-приложений Java. Это…

'''Секундочку. У нас уже есть Struts, Tapestry, WebWork и nauseam. Зачем создавать еще одну платформу для Java-приложений?'''

В том-то и часть проблемы: много несовместимых платформ. Однако JSF – открытый стандарт, разрабатываемый в рамках Java Community Process, и представители многих популярных, но нестандартных платформ внесли свою лепту в разработку спецификации JSF (текущая версия JSF 1.2). Спецификация открытая, и применять ее может каждый. Sun, кстати, выпустила стандартную реализацию.

'''Ясно. Но чем JSF отличается от, скажем, Jakarta Struts?'''

Тем, что у этих проектов разные цели. Struts – завершенная платформа, позволяющая упростить построение Java-приложений с использованием парадигмы модель-вид-контроллер (MVC). JSF сосредоточена на одной части парадигмы, виде.

'''Вид — то есть вид web-приложений, отсюда и «Faces»?'''

Точно. MVC – программная архитектура, четко разделяющая пользовательское приложение на три части: Модель (часть программы, содержащая данные), Вид (представление данных, позволяющее пользователю взаимодействовать с программой) и Управление (обработка событий, например, пользовательского ввода, и обновление в соответствии с этими событиями Модели и/или Вида). Архитектура MVC успешно используется некоторыми современными средами разработки, включая Cocoa для Mac OS X, Microsoft Foundation Classes и Swing для Java.
Теперь наблюдается, что подобный подход начал применяться и к web-приложениям, отсюда и популярность Struts.

'''Спасибо за объяснение технологии, но что MVC даст лично мне?'''

Если рассматривать приложение таким образом, можно отделить модель от вида. Это особенно актуально для web-приложений. Вспомните только, как часто популярные сайты подвергаются визуальному обновлению (меняется вид), а обрабатываемые ими данные (модель) остаются неизменными. Кроме того, в web-разработках и у программиста, и у дизайнера (который не обязательно разбирается в программировании) должна быть возможность трудиться над приложением вместе. Наконец, вам могут понадобиться различные методы доставки web-приложения пользователям: скажем, вы работаете с HTML-интерфейсом для настольных компьютеров, а с WML – для мобильных устройств. Благодаря MVC решение этих задач существенно упрощается.

'''Если JSF занимается только видом, чем она лучше Struts, которая умеет все?'''

Не обязательно быть во всем лучше всех. JSF лучше только для построения пользовательских интерфейсов. Вполне возможно совместное использование Struts и JSF в одном приложении – есть даже дочерний проект Struts под названием Shale, для более плотной интеграции с JSF (см. http://shale.apache.org).

'''Об этом хватит! Расскажите подробнее о JSF.'''

Вижу, вас надо хорошенько убедить. Ладно. Иногда JSF называют «Swing для web-приложений», и это правильно (как известно, Swing – стандартная среда разработки графических пользовательских интерфейсов, GUI, на чистом Java). Со Swing легко изменять способы отображения компонентов интерфейса или создавать особые компоненты, а также использовать визуальные редакторы интерфейсов. Все эти преимущества применимы к JSF, но не к Struts.

'''Вы приводите сравнение со Swing. Это, повашему, убедительно?'''

Да забудьте вы эту Swing-фобию! Ведь вы же сможете строить интерфейс web-приложения так же легко, как строится простой GUI – перетаскиванием компонентов в UI-конструктор; это ли не здорово?

'''Допустим. Но интерфейс для web и для обычных платформ – не одно и то же. Осуществима ли эта идея?'''

Да, поскольку JSF моделирует интерфейсы точно так же, как традиционные среды разработки, в частности, Swing. В основе JSF лежит API, позволяющий создавать компоненты интерфейса, не зависящие от устройства вывода. Этот API управляет всеми вопросами, связанными с пользовательским интерфейсом: жизненным циклом, обработкой событий, персистентностью (способность сохранять и поддерживать объекты) и навигацией. JSF предоставляет также базовый набор компонентов GUI, знакомых дизайнеру любых интерфейсов.

'''Как это отразится на HTML-интерфейсе, который я вижу в браузере?'''

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

'''Погодите продолжать, поясните, пожалуйста, что такое JavaServer Pages?'''

С удовольствием. Основа технологии генерации динамического web-контента с сервера Java-приложений – это сервлет. Но строительство пользовательского интерфейса только через сервлеты весьма проблематично: встраивать весь генерируемый контент (в основном HTML) внутрь Java-кода – задача непосильная. Поэтому и появилась JavaServer Pages. Теперь все наоборот: можно добавить в HTML особые тэги, исполняющие необходимый для генерации динамического контента Java-код, а то и встроить этот код непосредственно в HTML-страницу.

'''А применение JSF обязательно требует поддержки JSP?'''

Да, поставляется библиотека тэгов JSP с особыми тэгами, позволяющими оперировать с компонентами пользовательского интерфейса JSF. Например, если вы хотите представить пользователю данные в виде таблицы, нужно воспользоваться соответствующим JSF-тэгом. JSF возьмет на себя генерацию таблицы в виде HTML-кода в ответ на пользовательский запрос, а web-контейнер доставит ее в браузер пользователя.

'''Полагаю, ввод данных в страницы JSF не составит труда…'''

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

'''ОК, вы заинтриговали меня. С чего же начать разработку в JSF?'''

Можно начать разработку с помощью web-контейнера типа Tomcat, вручную инсталлировать экземпляр JSF, затем в простом текстовом редакторе создать шаблоны и необходимый Java-код. Однако простейший путь – зарегистрироваться в Sun Developer Network и
установить новейшую версию Sun Studio Creator (см. http://developers.sun.com/prodtech/javatools/jscreator). Это полный пакет для JSF-разработки, включающий Java IDE, визуальный конструктор и сервер приложений. Регистрация свободная, а загрузка Creator для
зарегистрированных членов бесплатна.

'''Хм. А нет ли других решений среди свободного ПО?'''

Creator от Sun основывается на открытом NetBeans IDE, но в текущей стабильной версии NetBeans еще нет визуальных инструментов для работы с JSF.

'''Вы сказали, что JSF – открытый стандарт. Нет ли других вариантов, кроме как от Sun?'''

Конечно, есть: например, Apache MyFaces (см. http://myfaces. apache.org).

'''Хотелось бы познакомиться с библиотеками компонентов JSF.'''

Отлично! Попробуйте ADF Faces от Oracle (http://www.oracle.com/technology/products/jdev/htdocs/partners/addins/exchange/jsf).

'''А где можно подробнее узнать о JavaServer Pages?'''

Рекомендую http://java.sun.com/javaee/javaserverfaces. Там можно найти информацию и ссылки на многочисленные статьи и руководства по JSF.

Linuxformat:Портал сообщества

2008-03-17T11:41:03Z

Skryabin yuri: Учебник Java выполнено

Обязательно к прочтению: [[Информация для авторов]]
{| class="standart"
|+Координационная таблица (красных ссылок)
|-
! ||Январь||Февраль||Март||Апрель||Май||Июнь||Июль||Август||Сентябрь||Октябрь||Ноябрь||Декабрь
|-
! 2005
| || || || || || || ||
| [[LXF70]]
| [[LXF71]]
| [[LXF72]]
| [[LXF73]]
|-
! 2006
| [[LXF74-75]]
| [[LXF76]]
| [[LXF77]]
| [[LXF78]]
| [[LXF79]]
| [[LXF80]]
| [[LXF81]]
| [[LXF82]]
| [[LXF83]]
| [[LXF84]]
| [[LXF85]]
| [[LXF86]]
|-
! 2007
| [[LXF87-88]]
| [[LXF89]]
| [[LXF90]]
| [[LXF91]]
| [[LXF92]]
| [[LXF93]]
| [[LXF94]]
| [[LXF95]]
| [[LXF96]]
| [[LXF97]]
| [[LXF98]]
| [[LXF99]]
|}

----

Следующие номера Linux Format являются "занятыми" – т.е. для них уже нашелся человек, желающий конвертировать их в формат Wiki:

# [[LXF70|Linux Format 70, Сентябрь 2005]] [[Изображение:75%.png]]
# [[LXF71|Linux Format 71, Октябрь 2005]] [[Изображение:00%.png]]
# [[LXF72|Linux Format 72, Ноябрь 2005]] [[Изображение:25%.png]]
# [[LXF73|Linux Format 73, Декабрь 2005]] [[Изображение:25%.png]]
# [[LXF74-75|Linux Format 74-75, Январь 2006]] [[Изображение:00%.png]]
# [[LXF76|Linux Format 76, Февраль 2006]] [[Изображение:00%.png]]
# [[LXF77|Linux Format 77, Март 2006]] [[Изображение:25%.png]]
# [[LXF78|Linux Format 78, Апрель 2006]] [[Изображение:25%.png]]
# [[LXF79|Linux Format 79, Май 2006]] [[Изображение:25%.png]]
# [[LXF80|Linux Format 80, Июнь 2006]] [[Изображение:00%.png]]
# [[LXF81|Linux Format 81, Июль 2006]] [[Изображение:75%.png]]
# [[LXF82|Linux Format 82, Август 2006]] [[Изображение:25%.png]]
# [[LXF83|Linux Format 83, Сентябрь 2006]] [[Изображение:50%.png]]
# [[LXF84|Linux Format 84, Октябрь 2006]] [[Изображение:25%.png]]
# [[LXF85|Linux Format 85, Ноябрь 2006]] [[Изображение:25%.png]]
# [[LXF86|Linux Format 86, Декабрь 2006]] [[Изображение:25%.png]]
# [[LXF87-88|Linux Format 87-88, Январь 2007]] [[Изображение:00%.png]]
# [[LXF89|Linux Format 89, Февраль 2007]] [[Изображение:75%.png]]
# [[LXF90|Linux Format 90, Март 2007]] [[Изображение:25%.png]]
# [[LXF91|Linux Format 91, Апрель 2007]] [[Изображение:25%.png]]
# [[LXF92|Linux Format 92, Май 2007]] [[Изображение:00%.png]]
# [[LXF93|Linux Format 93, Июнь 2007]] [[Изображение:25%.png]]
# [[LXF94|Linux Format 94, Июль 2007]] [[Изображение:25%.png]]
# [[LXF95|Linux Format 95, Август 2007]] [[Изображение:25%.png]]
# [[LXF96|Linux Fromat 96, Сентябрь 2007]] [[Изображение:25%.png]]
# [[LXF97|Linux Format 97, Октябрь 2007]] [[Изображение:25%.png]]
# [[LXF98|Linux Format 98, Ноябрь 2007]] [[Изображение:25%.png]]
# [[LXF99|Linux Format 99, Декабрь 2007]] [[Изображение:25%.png]]

Следующие материалы или серии материалов также являются "занятыми":
* Учебник Java, LXF84-LXF87/88 – выполнено
* Учебник Subversion ([[LXF70:Subversion1|части 1]],[[LXF70:Subversion2|2]]), LXF70 – выполнено

Для пробы wiki-разметки: [[Песочница]]

LXF87-88:Java

2008-03-17T11:29:51Z

Skryabin yuri: Взаимные блокировки

=== Потоки в Java ===
''ЧАСТЬ 4: Завершая курс молодого Java-бойца, '''Антон Черноусов''' научит вас управлять потоками... Жаль, что не денежными.''

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

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

Во избежание описанных проблем программа должна использовать потоки или процессы. Под процессом понимается заявка на потребле-
ние всех видов ресурсов системы, кроме одного – процессорного времени, или иначе говоря, процесс – это запущенная на выполнение программа (такое определение дается в [[LXF87/88:Java#Литература|[1]]]). Поток рассматривается как самостоятельная активность внутри процесса, хотя существуют другие трактовки этого понятия, которые зависят от используемой операционной системы (см., например, [[LXF87/88:Java#Литература|[2]]]). Поток получил свое название по аналогии с потоком команд, поступающих в процессор; при выполнении потоки делят адресное пространство и выделенную память внутри одного процесса. Процессорное время распределяется между различными потоками операционной системой, точнее, одним из компонентов ее ядра – планировщиком. Более полно с понятием процессов и потоков и механизмов работы с ними с точки зрения операционной системы вы можете ознакомиться в книге [[LXF87/88:Java#Литература|[3]]].

Давайте завершим наш экскурс в теорию и окунемся в реальность Java. Под процессом здесь принято понимать всеобъемлющий контекст выполнения, обеспечивающий высокий уровень изоляции охватываемых им данных от внешнего мира, а под потоком – более «легковесный» активный агент; в контексте одного процесса может функционировать целое множество потоков [[LXF87/88:Java#Литература|[4]]]. Планирование потоков в Java обеспечивается внутренними механизмами JVM.

=== Поток, он же thread ===
В Java существует два способа работы с потоками: первый заключается в реализации интерфейса Runnable, второй связан с наследованием
класса Thread, который уже реализует данный интерфейс. В обоих случаях класс должен предоставлять реализацию метода run(). Ниже
приведен пример класса, реализующего поток через наследование класса Thread:
<source lang = "java">
public class FirstThread extends Thread {
public void run(){
for (int i = 1 ; i < 30; i++)
System.out.println("It is in thread "+ i);
}
}
</source>
Собственно, метод run() и должен содержать некоторый набор инструкций (разумеется, на языке Java), которые вы хотите выполнить
в отдельном потоке. Например, если вы реализуете функцию копирования файла (а пользователь, скажем, копирует ISO-образ объемом
600 Мб), желательно, чтобы эта операция выполнялась в отдельном потоке, запуск которого можно производить следующим образом:
<source lang = "java">
public class ConsoleToThread {
public static void main(String[] args) {
FirstThread thread = new FirstThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
При выполнении метода main() класса ConsoleToThread создается объект-поток FirstThread, который запускается на выполнение методом start() [заметьте – метод run() никогда не вызывается явно, – прим.ред.]. Метод join() используется в случае, когда необходимо «дождаться» завершения потока. Завершение работы потока происходит при выходе из метода run(), как явном (например, посредством return), так и неявном (если внутри метода возникло и не было обработано какое-то исключение).

Имейте в виду (это важно!): повторный запуск уже отработавшего потока приведет к исключению IllegalThreadStateException.

=== Реализация потока через Runnable ===
Давайте теперь рассмотрим пример работы с потоками через интерфейс Runnable. Если, допустим, класс SameRunnable реализует интерфейс Runnable, то запустить поток на основе этого класса на выполнение можно следующим образом:
<source lang = "java">
Runnable run = new SameRunnable();
Thread thread = new Thread(run);
thread.start();
</source>
В следующем примере в методе main() класса ConsoleToThreadTwo создается массив threadArray, состоящий из объектов-потоков. При
этом используется конструктор класса Thread, принимающий два параметра: ссылку на объект, реализующий интерфейс Runnable и
имя потока:
<source lang = "java">
Thread thread = new Thread(Runnable, ThreadName);
</source>
Метод getName() объекта, реализующего поток, возвращает указанное при создании имя. Обратите внимание, что в нем используется
статический метод Thread.currentThread(), возвращающий ссылку на объект Thread, соответствующий выполняющемуся в текущий момент
потоку:
<source lang = "java">
public class SecondThread implements Runnable {
public String getName() {
return Thread.currentThread().getName();
}
public void run() {
for (int i = 1; i < 100000; i++) {
if ((i % 10000) == 0) {
System.out.println(getName() + " counts " + i / 10000);
}
}
}
}

public class ConsoleToThreadTwo {
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
}
</source>
Проследив за выводом этой программы, можно заметить, что процессорное время распределяется между потоками практически равномерно, однако порядок их выполнения во многом случаен.

=== Приоритеты потоков ===
Для управления величиной процессорного времени, выделяемого потоку, можно воспользоваться приоритетами. Установка приоритетов происходит с помощью метода Thread.setPriority(), узнать текущий приоритет позволяет метод getPriority(). В классе Thread определены
три константы:
<source lang = "java">
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
</source>
Важно понимать, что значение приоритета потока предназначено для Java-машины и не соответствует реальным приоритетам потоков
в операционной системе.

Давайте немного изменим код метода main() класса ConsoleToThreadTwo:
<source lang = "java">
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
int pr = 0;
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
if (pr == 10)
pr = 0;
threadArray[i].setPriority(Thread.MIN_PRIORITY + pr);
pr++;
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
</source>
Анализ результатов работы класса показывает, что потоки, получившие более высокий приоритет, выполняются чаще. Также, благодаря
условию на значение переменной pr, setPriority() никогда не будет передан приоритет, превышающий 10 (MAX_PRIORITY). Если бы это про-
изошло, система выбросила бы исключение IllegalArgumentException.

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

Что же это такое? Демон отличается от «простого смертного» потока вызовом метода setDeamon(true), который необходимо сделать до
начала работы. Например, так:
<source lang = "java">
FirstThread thread = new FirstThread();
thread.setDeamon(true);
thread.start();
</source>
Узнать, является ли поток демоном, можно с помощью метода isDeamon(). Обычно потоки-демоны создаются для обслуживания
некритичных задач, так как при завершении работы программа не дожидается их остановки, а прерывает их самостоятельно.

=== Где искать потоки? ===
В большинстве случаев бывает необходимо отслеживать ранее запущенные на выполнение потоки. Использование массива потоков,
как в предыдущем примере, не всегда оправданно. Для хранения и обработки потоков в Java существует класс ThreadGroup. Группа,
к которой принадлежит создаваемый поток, опять-таки передается конструктору Thread():
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
</source>
Если группа не указана явно, поток будет помещен в тот же ThreadGroup, что и его родитель.
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
Thread thread1 = new Thread(tg, new SecondThread(), "ThreadName2");
Thread thread2 = new Thread(tg, new SecondThread(), "ThreadName3");
System.out.println("active thread in group " + tg.activeCount());
thread.start();
thread1.start();
System.out.println("active thread in group " + tg.activeCount());
Thread[] threads = new Thread[tg.activeCount()];
int m = tg.enumerate(threads);
System.out.println("taked threads from group : " + m);
for (int i = 0; i < threads.length; i++) {
System.out.println(threads[i].getName());
}
</source>
В представленном выше примере в экземпляр класса ThreadGroup помещаются три потока, два из которых запускаются на выполнение.
Количество активных потоков в группе определяется с помощью метода activeCount(), а в результате выполнения метода enumerate() формируется перечень всех активных потоков.

=== Управление потоками ===
При запуске потоков следует учитывать и то, что их иногда приходится останавливать, причем как штатно, так и экстренно. Для того, чтобы
приостановить работу потока изнутри, допустим, в тот момент, когда закончилась доступные для обработки данные, можно использовать
два метода: sleep() и wait().
<source lang = "java">
public class ThirdThread extends Thread {
public void run() {
for (int i = 1; i < 110; i++) {
if (i == 10) {
try {
sleep(10000);
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)");
}
}
if (i == 100) {
try {
synchronized (this) { wait();}
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)again");
}
}
}
}
}
</source>
Методу sleep() передается переменная типа long, соответствующая количеству миллисекунд, в течении которых поток будет «спать». В
случае wait() поток ждет пробуждения снаружи. Применение методов sleep() и wait() требует обработки исключительной ситуации, которая возникают при пробуждении потока. В представленном ниже классе ConsoleToThreadThree потоки пробуждаются с помощью метода interrupt():
<source lang = "java">
public class ConsoleToThreadThree {
public static void main(String[] args) {
ThirdThread thread = new ThirdThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
Отметим, что вызов метода wait() без блока синхронизации (synchronized), о котором мы поговорим чуть ниже, приводит к исключению IllegalMonitorStateException. Возникшая ошибка свидетельствует об отсутствии монитора у объекта (понятие монитора и синхронизация
тесно связаны, о чем мы тоже поговорим ниже). Если для приостановления потока был применен метод wait(), то для «пробуждения» потока
можно воспользоваться методом notify() или notifyAll(). Первый пробуждает один случайно выбранный спящий поток, а второй пытается
пробудить их всех.

Кроме рассмотренных выше методов, иногда бывает целесообразно использовать метод yield(), который приостанавливает работу текущего потока. Метод yield() не переводит поток в режим ожидания, как wait(), но предоставляет другим потокам возможность начать работать
раньше, чем допустила бы Java-машина [фактически, поток, вызвавший yield() добровольно отдает свой квант процессорного времени, –
прим. ред.]. Метод yield() статичный, так что прекратить с его помощью работу другого потока не получится.

Методов остановки потоков тоже нет (ранее присутствовали методы stop(), resume(), suspend(), но сейчас они объявлены как «deprecated» –
то есть нерекомендованными к использованию). На сегодня в Java принят уведомительный стиль остановки потока с помощью пары методов:
уже известного нам interrupt(), применяемого снаружи, чтобы выставить флаг завершения и метода isInterrupted(), вызываемого изнутри
потока, чтобы узнать состояние флага, свидетельствующего о том, что «пора закругляться».

=== Мониторы и синхронизация ===
Что такое «монитор», о котором говорилось выше? Нет, это не дисплей, это – объект, используемый как защелка, то есть в данный момент
времени владеть монитором может только один поток. В случае, если поток завладел монитором, говорят, что он «вошел» в монитор, а все
остальные потоки, пытающиеся это сделать, будут заморожены (часто говорят, что они «ждут» монитора) до тех пор, пока владелец монитора
его не освободит, то есть не покинет.

Если перейти к реалиям Java, то объектов типа монитор в явном виде просто нет! С каждым объектом связан неявный монитор, и чтобы
завладеть им, необходимо вызвать метод или блок, помеченный ключевым словом synchronized. Как только поток входит в такой блок, он
завладевает монитором объекта, переданного synchronized в качестве параметра. Так происходит и в классе ThirdThread, однако, в момент
вызова метода wait(), монитор отпускается. Пример synchronized-метода представлен ниже:
<source lang = "java">
public synchronized boolean sameCheck() {
if (a) {
a = false; return true;
}
else {
a = true;
return false;
}
}
</source>
В целом, синхронизация – это механизм, обеспечивающий монопольный доступ участка кода к некоторому объекту. Одним из первых
способов, предложенных для синхронизации работы потоков, были семафоры, концепцию которых описал Дейкстра [Dijkstra] в 1965 году
(часто говорят, что семафор – это классический синхронизированный примитив). Семафор используется для предоставления доступа к огра-
ниченному количеству ресурсов. Как правило, у семафора есть две операции: P – занять ресурс и V – освободить ресурс. Он может быть
реализован следующим образом:
<source lang = "java">
public class SimpleSemaphore {
int counter;
public SimpleSemaphore() {
this.counter = 1;
}

public synchronized void p() throws InterruptedException {
while (counter == 0) {
wait();
}
counter = counter + 1;
}

public synchronized void v() throws InterruptedException {
counter = counter - 1;
notify();
}
}
</source>
Можно, конечно, реализовывать семафоры самостоятельно, но проще воспользоваться специальной библиотекой java.util.concurrent.
Кроме семафоров, она включает в себя еще много чего интересного.

Отметим, что программа, в принципе, может не использовать ни один из методов синхронизации, обходясь методами wait() и notify().

=== Взаимные блокировки ===
На этом наш рассказ можно было бы и завершить, но чтобы у вас не сложилось впечатление, что в мире многопоточных приложений все
так радужно, мы поговорим о неприятных последствиях синхронизации. Как только количество потоков начинает стремительно расти и
возникает необходимость синхронизированного доступа к ограниченному кругу объектов в различной последовательности, будьте готовы к
ошибкам типа deadlock – взаимным блокировкам.

Взаимная блокировка – это ошибка, которая лучше всего описывается простой формулой: «Поток A держит монитор a и хочет захватить
монитор b, а поток B держит монитор b и хочет захватить монитор a». В результате оба засыпают «мертвым сном».

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

Сегодня мы поговорили о двух способах создания потоков Java, разобрались с приоритетами, познакомились со средствами управления работой потоков и демонами, а также сделали небольшой обзор методов синхронизации. Для того, чтобы начать практическую работу с потоками, этого вполне достаточно. Желающим разобраться во всем этом глубже я рекомендую ознакомится с книгой «Concurrent Programming in Java: Design Principles and Patterns», автором которой является Дуг Ли [Doug Lea] – она считается одной из лучших по данной тематике.

На этом мы заканчиваем обзор основ программирования на Java и в следующий раз поговорим о серверных приложениях – приготовьтесь
к Java Enterprise Edition!

=== Литература ===
*1. П. Кью «Использование UNIX», ISBN 5-8275-0019-4
*2. В.Г. Олифер, Н.А. Олифер «Сетевые операционные системы», ISBN 5-272-00120-6
*3. Д. Бэкон, Т. Харрис «Операционные системы», ISBN 5-94723-969-8
*4. М. Фаулер «Архитектура корпоративных программных приложений», ISBN 5-8459-0579-6

LXF87-88:Java

2008-03-17T11:25:02Z

Skryabin yuri: /* Мониторы и синхронизация */

=== Потоки в Java ===
''ЧАСТЬ 4: Завершая курс молодого Java-бойца, '''Антон Черноусов''' научит вас управлять потоками... Жаль, что не денежными.''

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

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

Во избежание описанных проблем программа должна использовать потоки или процессы. Под процессом понимается заявка на потребле-
ние всех видов ресурсов системы, кроме одного – процессорного времени, или иначе говоря, процесс – это запущенная на выполнение программа (такое определение дается в [[LXF87/88:Java#Литература|[1]]]). Поток рассматривается как самостоятельная активность внутри процесса, хотя существуют другие трактовки этого понятия, которые зависят от используемой операционной системы (см., например, [[LXF87/88:Java#Литература|[2]]]). Поток получил свое название по аналогии с потоком команд, поступающих в процессор; при выполнении потоки делят адресное пространство и выделенную память внутри одного процесса. Процессорное время распределяется между различными потоками операционной системой, точнее, одним из компонентов ее ядра – планировщиком. Более полно с понятием процессов и потоков и механизмов работы с ними с точки зрения операционной системы вы можете ознакомиться в книге [[LXF87/88:Java#Литература|[3]]].

Давайте завершим наш экскурс в теорию и окунемся в реальность Java. Под процессом здесь принято понимать всеобъемлющий контекст выполнения, обеспечивающий высокий уровень изоляции охватываемых им данных от внешнего мира, а под потоком – более «легковесный» активный агент; в контексте одного процесса может функционировать целое множество потоков [[LXF87/88:Java#Литература|[4]]]. Планирование потоков в Java обеспечивается внутренними механизмами JVM.

=== Поток, он же thread ===
В Java существует два способа работы с потоками: первый заключается в реализации интерфейса Runnable, второй связан с наследованием
класса Thread, который уже реализует данный интерфейс. В обоих случаях класс должен предоставлять реализацию метода run(). Ниже
приведен пример класса, реализующего поток через наследование класса Thread:
<source lang = "java">
public class FirstThread extends Thread {
public void run(){
for (int i = 1 ; i < 30; i++)
System.out.println("It is in thread "+ i);
}
}
</source>
Собственно, метод run() и должен содержать некоторый набор инструкций (разумеется, на языке Java), которые вы хотите выполнить
в отдельном потоке. Например, если вы реализуете функцию копирования файла (а пользователь, скажем, копирует ISO-образ объемом
600 Мб), желательно, чтобы эта операция выполнялась в отдельном потоке, запуск которого можно производить следующим образом:
<source lang = "java">
public class ConsoleToThread {
public static void main(String[] args) {
FirstThread thread = new FirstThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
При выполнении метода main() класса ConsoleToThread создается объект-поток FirstThread, который запускается на выполнение методом start() [заметьте – метод run() никогда не вызывается явно, – прим.ред.]. Метод join() используется в случае, когда необходимо «дождаться» завершения потока. Завершение работы потока происходит при выходе из метода run(), как явном (например, посредством return), так и неявном (если внутри метода возникло и не было обработано какое-то исключение).

Имейте в виду (это важно!): повторный запуск уже отработавшего потока приведет к исключению IllegalThreadStateException.

=== Реализация потока через Runnable ===
Давайте теперь рассмотрим пример работы с потоками через интерфейс Runnable. Если, допустим, класс SameRunnable реализует интерфейс Runnable, то запустить поток на основе этого класса на выполнение можно следующим образом:
<source lang = "java">
Runnable run = new SameRunnable();
Thread thread = new Thread(run);
thread.start();
</source>
В следующем примере в методе main() класса ConsoleToThreadTwo создается массив threadArray, состоящий из объектов-потоков. При
этом используется конструктор класса Thread, принимающий два параметра: ссылку на объект, реализующий интерфейс Runnable и
имя потока:
<source lang = "java">
Thread thread = new Thread(Runnable, ThreadName);
</source>
Метод getName() объекта, реализующего поток, возвращает указанное при создании имя. Обратите внимание, что в нем используется
статический метод Thread.currentThread(), возвращающий ссылку на объект Thread, соответствующий выполняющемуся в текущий момент
потоку:
<source lang = "java">
public class SecondThread implements Runnable {
public String getName() {
return Thread.currentThread().getName();
}
public void run() {
for (int i = 1; i < 100000; i++) {
if ((i % 10000) == 0) {
System.out.println(getName() + " counts " + i / 10000);
}
}
}
}

public class ConsoleToThreadTwo {
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
}
</source>
Проследив за выводом этой программы, можно заметить, что процессорное время распределяется между потоками практически равномерно, однако порядок их выполнения во многом случаен.

=== Приоритеты потоков ===
Для управления величиной процессорного времени, выделяемого потоку, можно воспользоваться приоритетами. Установка приоритетов происходит с помощью метода Thread.setPriority(), узнать текущий приоритет позволяет метод getPriority(). В классе Thread определены
три константы:
<source lang = "java">
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
</source>
Важно понимать, что значение приоритета потока предназначено для Java-машины и не соответствует реальным приоритетам потоков
в операционной системе.

Давайте немного изменим код метода main() класса ConsoleToThreadTwo:
<source lang = "java">
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
int pr = 0;
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
if (pr == 10)
pr = 0;
threadArray[i].setPriority(Thread.MIN_PRIORITY + pr);
pr++;
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
</source>
Анализ результатов работы класса показывает, что потоки, получившие более высокий приоритет, выполняются чаще. Также, благодаря
условию на значение переменной pr, setPriority() никогда не будет передан приоритет, превышающий 10 (MAX_PRIORITY). Если бы это про-
изошло, система выбросила бы исключение IllegalArgumentException.

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

Что же это такое? Демон отличается от «простого смертного» потока вызовом метода setDeamon(true), который необходимо сделать до
начала работы. Например, так:
<source lang = "java">
FirstThread thread = new FirstThread();
thread.setDeamon(true);
thread.start();
</source>
Узнать, является ли поток демоном, можно с помощью метода isDeamon(). Обычно потоки-демоны создаются для обслуживания
некритичных задач, так как при завершении работы программа не дожидается их остановки, а прерывает их самостоятельно.

=== Где искать потоки? ===
В большинстве случаев бывает необходимо отслеживать ранее запущенные на выполнение потоки. Использование массива потоков,
как в предыдущем примере, не всегда оправданно. Для хранения и обработки потоков в Java существует класс ThreadGroup. Группа,
к которой принадлежит создаваемый поток, опять-таки передается конструктору Thread():
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
</source>
Если группа не указана явно, поток будет помещен в тот же ThreadGroup, что и его родитель.
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
Thread thread1 = new Thread(tg, new SecondThread(), "ThreadName2");
Thread thread2 = new Thread(tg, new SecondThread(), "ThreadName3");
System.out.println("active thread in group " + tg.activeCount());
thread.start();
thread1.start();
System.out.println("active thread in group " + tg.activeCount());
Thread[] threads = new Thread[tg.activeCount()];
int m = tg.enumerate(threads);
System.out.println("taked threads from group : " + m);
for (int i = 0; i < threads.length; i++) {
System.out.println(threads[i].getName());
}
</source>
В представленном выше примере в экземпляр класса ThreadGroup помещаются три потока, два из которых запускаются на выполнение.
Количество активных потоков в группе определяется с помощью метода activeCount(), а в результате выполнения метода enumerate() формируется перечень всех активных потоков.

=== Управление потоками ===
При запуске потоков следует учитывать и то, что их иногда приходится останавливать, причем как штатно, так и экстренно. Для того, чтобы
приостановить работу потока изнутри, допустим, в тот момент, когда закончилась доступные для обработки данные, можно использовать
два метода: sleep() и wait().
<source lang = "java">
public class ThirdThread extends Thread {
public void run() {
for (int i = 1; i < 110; i++) {
if (i == 10) {
try {
sleep(10000);
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)");
}
}
if (i == 100) {
try {
synchronized (this) { wait();}
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)again");
}
}
}
}
}
</source>
Методу sleep() передается переменная типа long, соответствующая количеству миллисекунд, в течении которых поток будет «спать». В
случае wait() поток ждет пробуждения снаружи. Применение методов sleep() и wait() требует обработки исключительной ситуации, которая возникают при пробуждении потока. В представленном ниже классе ConsoleToThreadThree потоки пробуждаются с помощью метода interrupt():
<source lang = "java">
public class ConsoleToThreadThree {
public static void main(String[] args) {
ThirdThread thread = new ThirdThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
Отметим, что вызов метода wait() без блока синхронизации (synchronized), о котором мы поговорим чуть ниже, приводит к исключению IllegalMonitorStateException. Возникшая ошибка свидетельствует об отсутствии монитора у объекта (понятие монитора и синхронизация
тесно связаны, о чем мы тоже поговорим ниже). Если для приостановления потока был применен метод wait(), то для «пробуждения» потока
можно воспользоваться методом notify() или notifyAll(). Первый пробуждает один случайно выбранный спящий поток, а второй пытается
пробудить их всех.

Кроме рассмотренных выше методов, иногда бывает целесообразно использовать метод yield(), который приостанавливает работу текущего потока. Метод yield() не переводит поток в режим ожидания, как wait(), но предоставляет другим потокам возможность начать работать
раньше, чем допустила бы Java-машина [фактически, поток, вызвавший yield() добровольно отдает свой квант процессорного времени, –
прим. ред.]. Метод yield() статичный, так что прекратить с его помощью работу другого потока не получится.

Методов остановки потоков тоже нет (ранее присутствовали методы stop(), resume(), suspend(), но сейчас они объявлены как «deprecated» –
то есть нерекомендованными к использованию). На сегодня в Java принят уведомительный стиль остановки потока с помощью пары методов:
уже известного нам interrupt(), применяемого снаружи, чтобы выставить флаг завершения и метода isInterrupted(), вызываемого изнутри
потока, чтобы узнать состояние флага, свидетельствующего о том, что «пора закругляться».

=== Мониторы и синхронизация ===
Что такое «монитор», о котором говорилось выше? Нет, это не дисплей, это – объект, используемый как защелка, то есть в данный момент
времени владеть монитором может только один поток. В случае, если поток завладел монитором, говорят, что он «вошел» в монитор, а все
остальные потоки, пытающиеся это сделать, будут заморожены (часто говорят, что они «ждут» монитора) до тех пор, пока владелец монитора
его не освободит, то есть не покинет.

Если перейти к реалиям Java, то объектов типа монитор в явном виде просто нет! С каждым объектом связан неявный монитор, и чтобы
завладеть им, необходимо вызвать метод или блок, помеченный ключевым словом synchronized. Как только поток входит в такой блок, он
завладевает монитором объекта, переданного synchronized в качестве параметра. Так происходит и в классе ThirdThread, однако, в момент
вызова метода wait(), монитор отпускается. Пример synchronized-метода представлен ниже:
<source lang = "java">
public synchronized boolean sameCheck() {
if (a) {
a = false; return true;
}
else {
a = true;
return false;
}
}
</source>
В целом, синхронизация – это механизм, обеспечивающий монопольный доступ участка кода к некоторому объекту. Одним из первых
способов, предложенных для синхронизации работы потоков, были семафоры, концепцию которых описал Дейкстра [Dijkstra] в 1965 году
(часто говорят, что семафор – это классический синхронизированный примитив). Семафор используется для предоставления доступа к огра-
ниченному количеству ресурсов. Как правило, у семафора есть две операции: P – занять ресурс и V – освободить ресурс. Он может быть
реализован следующим образом:
<source lang = "java">
public class SimpleSemaphore {
int counter;
public SimpleSemaphore() {
this.counter = 1;
}

public synchronized void p() throws InterruptedException {
while (counter == 0) {
wait();
}
counter = counter + 1;
}

public synchronized void v() throws InterruptedException {
counter = counter - 1;
notify();
}
}
Можно, конечно, реализовывать семафоры самостоятельно, но проще воспользоваться специальной библиотекой java.util.concurrent.
Кроме семафоров, она включает в себя еще много чего интересного.

Отметим, что программа, в принципе, может не использовать ни один из методов синхронизации, обходясь методами wait() и notify().

=== Взаимные блокировки ===
=== Литература ===
*1. П. Кью «Использование UNIX», ISBN 5-8275-0019-4
*2. В.Г. Олифер, Н.А. Олифер «Сетевые операционные системы», ISBN 5-272-00120-6
*3. Д. Бэкон, Т. Харрис «Операционные системы», ISBN 5-94723-969-8
*4. М. Фаулер «Архитектура корпоративных программных приложений», ISBN 5-8459-0579-6

LXF87-88:Java

2008-03-17T11:19:49Z

Skryabin yuri: /* Управление потоками */

=== Потоки в Java ===
''ЧАСТЬ 4: Завершая курс молодого Java-бойца, '''Антон Черноусов''' научит вас управлять потоками... Жаль, что не денежными.''

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

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

Во избежание описанных проблем программа должна использовать потоки или процессы. Под процессом понимается заявка на потребле-
ние всех видов ресурсов системы, кроме одного – процессорного времени, или иначе говоря, процесс – это запущенная на выполнение программа (такое определение дается в [[LXF87/88:Java#Литература|[1]]]). Поток рассматривается как самостоятельная активность внутри процесса, хотя существуют другие трактовки этого понятия, которые зависят от используемой операционной системы (см., например, [[LXF87/88:Java#Литература|[2]]]). Поток получил свое название по аналогии с потоком команд, поступающих в процессор; при выполнении потоки делят адресное пространство и выделенную память внутри одного процесса. Процессорное время распределяется между различными потоками операционной системой, точнее, одним из компонентов ее ядра – планировщиком. Более полно с понятием процессов и потоков и механизмов работы с ними с точки зрения операционной системы вы можете ознакомиться в книге [[LXF87/88:Java#Литература|[3]]].

Давайте завершим наш экскурс в теорию и окунемся в реальность Java. Под процессом здесь принято понимать всеобъемлющий контекст выполнения, обеспечивающий высокий уровень изоляции охватываемых им данных от внешнего мира, а под потоком – более «легковесный» активный агент; в контексте одного процесса может функционировать целое множество потоков [[LXF87/88:Java#Литература|[4]]]. Планирование потоков в Java обеспечивается внутренними механизмами JVM.

=== Поток, он же thread ===
В Java существует два способа работы с потоками: первый заключается в реализации интерфейса Runnable, второй связан с наследованием
класса Thread, который уже реализует данный интерфейс. В обоих случаях класс должен предоставлять реализацию метода run(). Ниже
приведен пример класса, реализующего поток через наследование класса Thread:
<source lang = "java">
public class FirstThread extends Thread {
public void run(){
for (int i = 1 ; i < 30; i++)
System.out.println("It is in thread "+ i);
}
}
</source>
Собственно, метод run() и должен содержать некоторый набор инструкций (разумеется, на языке Java), которые вы хотите выполнить
в отдельном потоке. Например, если вы реализуете функцию копирования файла (а пользователь, скажем, копирует ISO-образ объемом
600 Мб), желательно, чтобы эта операция выполнялась в отдельном потоке, запуск которого можно производить следующим образом:
<source lang = "java">
public class ConsoleToThread {
public static void main(String[] args) {
FirstThread thread = new FirstThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
При выполнении метода main() класса ConsoleToThread создается объект-поток FirstThread, который запускается на выполнение методом start() [заметьте – метод run() никогда не вызывается явно, – прим.ред.]. Метод join() используется в случае, когда необходимо «дождаться» завершения потока. Завершение работы потока происходит при выходе из метода run(), как явном (например, посредством return), так и неявном (если внутри метода возникло и не было обработано какое-то исключение).

Имейте в виду (это важно!): повторный запуск уже отработавшего потока приведет к исключению IllegalThreadStateException.

=== Реализация потока через Runnable ===
Давайте теперь рассмотрим пример работы с потоками через интерфейс Runnable. Если, допустим, класс SameRunnable реализует интерфейс Runnable, то запустить поток на основе этого класса на выполнение можно следующим образом:
<source lang = "java">
Runnable run = new SameRunnable();
Thread thread = new Thread(run);
thread.start();
</source>
В следующем примере в методе main() класса ConsoleToThreadTwo создается массив threadArray, состоящий из объектов-потоков. При
этом используется конструктор класса Thread, принимающий два параметра: ссылку на объект, реализующий интерфейс Runnable и
имя потока:
<source lang = "java">
Thread thread = new Thread(Runnable, ThreadName);
</source>
Метод getName() объекта, реализующего поток, возвращает указанное при создании имя. Обратите внимание, что в нем используется
статический метод Thread.currentThread(), возвращающий ссылку на объект Thread, соответствующий выполняющемуся в текущий момент
потоку:
<source lang = "java">
public class SecondThread implements Runnable {
public String getName() {
return Thread.currentThread().getName();
}
public void run() {
for (int i = 1; i < 100000; i++) {
if ((i % 10000) == 0) {
System.out.println(getName() + " counts " + i / 10000);
}
}
}
}

public class ConsoleToThreadTwo {
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
}
</source>
Проследив за выводом этой программы, можно заметить, что процессорное время распределяется между потоками практически равномерно, однако порядок их выполнения во многом случаен.

=== Приоритеты потоков ===
Для управления величиной процессорного времени, выделяемого потоку, можно воспользоваться приоритетами. Установка приоритетов происходит с помощью метода Thread.setPriority(), узнать текущий приоритет позволяет метод getPriority(). В классе Thread определены
три константы:
<source lang = "java">
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
</source>
Важно понимать, что значение приоритета потока предназначено для Java-машины и не соответствует реальным приоритетам потоков
в операционной системе.

Давайте немного изменим код метода main() класса ConsoleToThreadTwo:
<source lang = "java">
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
int pr = 0;
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
if (pr == 10)
pr = 0;
threadArray[i].setPriority(Thread.MIN_PRIORITY + pr);
pr++;
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
</source>
Анализ результатов работы класса показывает, что потоки, получившие более высокий приоритет, выполняются чаще. Также, благодаря
условию на значение переменной pr, setPriority() никогда не будет передан приоритет, превышающий 10 (MAX_PRIORITY). Если бы это про-
изошло, система выбросила бы исключение IllegalArgumentException.

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

Что же это такое? Демон отличается от «простого смертного» потока вызовом метода setDeamon(true), который необходимо сделать до
начала работы. Например, так:
<source lang = "java">
FirstThread thread = new FirstThread();
thread.setDeamon(true);
thread.start();
</source>
Узнать, является ли поток демоном, можно с помощью метода isDeamon(). Обычно потоки-демоны создаются для обслуживания
некритичных задач, так как при завершении работы программа не дожидается их остановки, а прерывает их самостоятельно.

=== Где искать потоки? ===
В большинстве случаев бывает необходимо отслеживать ранее запущенные на выполнение потоки. Использование массива потоков,
как в предыдущем примере, не всегда оправданно. Для хранения и обработки потоков в Java существует класс ThreadGroup. Группа,
к которой принадлежит создаваемый поток, опять-таки передается конструктору Thread():
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
</source>
Если группа не указана явно, поток будет помещен в тот же ThreadGroup, что и его родитель.
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
Thread thread1 = new Thread(tg, new SecondThread(), "ThreadName2");
Thread thread2 = new Thread(tg, new SecondThread(), "ThreadName3");
System.out.println("active thread in group " + tg.activeCount());
thread.start();
thread1.start();
System.out.println("active thread in group " + tg.activeCount());
Thread[] threads = new Thread[tg.activeCount()];
int m = tg.enumerate(threads);
System.out.println("taked threads from group : " + m);
for (int i = 0; i < threads.length; i++) {
System.out.println(threads[i].getName());
}
</source>
В представленном выше примере в экземпляр класса ThreadGroup помещаются три потока, два из которых запускаются на выполнение.
Количество активных потоков в группе определяется с помощью метода activeCount(), а в результате выполнения метода enumerate() формируется перечень всех активных потоков.

=== Управление потоками ===
При запуске потоков следует учитывать и то, что их иногда приходится останавливать, причем как штатно, так и экстренно. Для того, чтобы
приостановить работу потока изнутри, допустим, в тот момент, когда закончилась доступные для обработки данные, можно использовать
два метода: sleep() и wait().
<source lang = "java">
public class ThirdThread extends Thread {
public void run() {
for (int i = 1; i < 110; i++) {
if (i == 10) {
try {
sleep(10000);
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)");
}
}
if (i == 100) {
try {
synchronized (this) { wait();}
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)again");
}
}
}
}
}
</source>
Методу sleep() передается переменная типа long, соответствующая количеству миллисекунд, в течении которых поток будет «спать». В
случае wait() поток ждет пробуждения снаружи. Применение методов sleep() и wait() требует обработки исключительной ситуации, которая возникают при пробуждении потока. В представленном ниже классе ConsoleToThreadThree потоки пробуждаются с помощью метода interrupt():
<source lang = "java">
public class ConsoleToThreadThree {
public static void main(String[] args) {
ThirdThread thread = new ThirdThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
Отметим, что вызов метода wait() без блока синхронизации (synchronized), о котором мы поговорим чуть ниже, приводит к исключению IllegalMonitorStateException. Возникшая ошибка свидетельствует об отсутствии монитора у объекта (понятие монитора и синхронизация
тесно связаны, о чем мы тоже поговорим ниже). Если для приостановления потока был применен метод wait(), то для «пробуждения» потока
можно воспользоваться методом notify() или notifyAll(). Первый пробуждает один случайно выбранный спящий поток, а второй пытается
пробудить их всех.

Кроме рассмотренных выше методов, иногда бывает целесообразно использовать метод yield(), который приостанавливает работу текущего потока. Метод yield() не переводит поток в режим ожидания, как wait(), но предоставляет другим потокам возможность начать работать
раньше, чем допустила бы Java-машина [фактически, поток, вызвавший yield() добровольно отдает свой квант процессорного времени, –
прим. ред.]. Метод yield() статичный, так что прекратить с его помощью работу другого потока не получится.

Методов остановки потоков тоже нет (ранее присутствовали методы stop(), resume(), suspend(), но сейчас они объявлены как «deprecated» –
то есть нерекомендованными к использованию). На сегодня в Java принят уведомительный стиль остановки потока с помощью пары методов:
уже известного нам interrupt(), применяемого снаружи, чтобы выставить флаг завершения и метода isInterrupted(), вызываемого изнутри
потока, чтобы узнать состояние флага, свидетельствующего о том, что «пора закругляться».

=== Мониторы и синхронизация ===
=== Взаимные блокировки ===
=== Литература ===
*1. П. Кью «Использование UNIX», ISBN 5-8275-0019-4
*2. В.Г. Олифер, Н.А. Олифер «Сетевые операционные системы», ISBN 5-272-00120-6
*3. Д. Бэкон, Т. Харрис «Операционные системы», ISBN 5-94723-969-8
*4. М. Фаулер «Архитектура корпоративных программных приложений», ISBN 5-8459-0579-6

LXF87-88:Java

2008-03-17T11:10:22Z

Skryabin yuri: /* Где искать потоки? */

LXF87-88:Java

2008-03-17T10:24:44Z

Skryabin yuri: /* Потоки-демоны */

LXF87-88:Java

2008-03-17T10:23:01Z

Skryabin yuri: /* Приоритеты потоков */

LXF87-88:Java

2008-03-17T10:15:50Z

Skryabin yuri: /* Реализация потока через Runnable */

LXF87-88:Java

2008-03-17T07:35:05Z

Skryabin yuri:

LXF87-88:Java

2008-03-17T07:32:40Z

Skryabin yuri: /* Поток, он же thread */

LXF87-88:Java

2008-03-17T07:12:20Z

Skryabin yuri:

LXF87-88:Java

2008-03-17T07:08:17Z

Skryabin yuri: Литература

Обсуждение участника:Lockal

2008-03-17T05:59:49Z

Skryabin yuri:

Сэр, я хоть и с опозданием (не было нета), но приступил к работе.
Спасибо, конечно, за помощь, но этот номер зарегистрирован за мной.
: Без проблем, хотя я начал[http://wiki.linuxformat.ru/index.php?title=LXF85&action=history] работать над номером, когда он был ещё свободен[http://wiki.linuxformat.ru/?oldid=623]. А пока я займусь другими номерами. --[[Участник:Lockal|Lockal]] 19:16, 16 марта 2008 (MSK)

Не хочу показаться интервентом - могу переслать письмо от Валентина Синицына от 6 марта, где за мной утвердили 85-ый номер. --[[Участник:flagist0|flagist0]]

'''LXF84''' Спасибо за статью по LaTeX, но этот номер (LXF 84) занят, и я хотел бы завершить работу над ним самостоятельно
[[Участник:Skryabin yuri|Skryabin yuri]]

Обсуждение участника:Lockal

2008-03-17T05:51:25Z

Skryabin yuri: New section: LXF84

Сэр, я хоть и с опозданием (не было нета), но приступил к работе.
Спасибо, конечно, за помощь, но этот номер зарегистрирован за мной.
: Без проблем, хотя я начал[http://wiki.linuxformat.ru/index.php?title=LXF85&action=history] работать над номером, когда он был ещё свободен[http://wiki.linuxformat.ru/?oldid=623]. А пока я займусь другими номерами. --[[Участник:Lockal|Lockal]] 19:16, 16 марта 2008 (MSK)

Не хочу показаться интервентом - могу переслать письмо от Валентина Синицына от 6 марта, где за мной утвердили 85-ый номер. --[[Участник:flagist0|flagist0]]

== LXF84 ==

Спасибо за статью по LaTeX, но этот номер (LXF 84) занят, и я хотел бы завершить работу над ним самостоятельно

LXF87-88

2008-03-14T13:28:47Z

Skryabin yuri: Изменена ссылка на учебник Java

==Linux Format 1 (87/88), Январь 2008==
===Обзоры===
* [[LXF87/88:Fedora_Core_6_vs_Ubuntu_6.10|Fedora Core 6 vs Ubuntu 6.10]]
* [[LXF87/88:FreeBSD_6.2|FreeBSD 6.2]]
* [[LXF87/88:Mandriva_Powerpack_2007|Mandriva Powerpack 2007]]
* [[LXF87/88:Oxygen|Oxygen]]
* [[LXF87/88:Valgrind|Valgrind]]
=== Учебники ===
* [[LXF87/88:Java|Потоки в Java]]
Не удивляйтесь – программисты Java тоже
хотят выполнять много задач одновременно.

LXF87-88

2008-03-14T13:27:27Z

Skryabin yuri: Изменена ссылка на учебник Java

==Linux Format 1 (87/88), Январь 2008==
===Обзоры===
* [[LXF87/88:Fedora_Core_6_vs_Ubuntu_6.10|Fedora Core 6 vs Ubuntu 6.10]]
* [[LXF87/88:FreeBSD_6.2|FreeBSD 6.2]]
* [[LXF87/88:Mandriva_Powerpack_2007|Mandriva Powerpack 2007]]
* [[LXF87/88:Oxygen|Oxygen]]
* [[LXF87/88:Valgrind|Valgrind]]
=== Учебники ===
* [[LXF87/88:Java|Потоки Java]]
Не удивляйтесь – программисты Java тоже
хотят выполнять много задач одновременно.

LXF87-88:Java

2008-03-14T13:24:38Z

Skryabin yuri: Начало, содержание

LXF87-88

2008-03-14T13:12:47Z

Skryabin yuri: Добавлена ссылка на учебник Java

==Linux Format 1 (87/88), Январь 2008==
===Обзоры===
* [[LXF87/88:Fedora_Core_6_vs_Ubuntu_6.10|Fedora Core 6 vs Ubuntu 6.10]]
* [[LXF87/88:FreeBSD_6.2|FreeBSD 6.2]]
* [[LXF87/88:Mandriva_Powerpack_2007|Mandriva Powerpack 2007]]
* [[LXF87/88:Oxygen|Oxygen]]
* [[LXF87/88:Valgrind|Valgrind]]
=== Учебники ===
* [[LXF87/88:Java|Снова о потоках]]
Не удивляйтесь – программисты Java тоже
хотят выполнять много задач одновременно.

LXF86:Java

2008-03-13T10:37:03Z

Skryabin yuri: /* Извлечение данных из XML-документа */

=== Хранение данных ===
''ЧАСТЬ 3: Даже самой замечательной программе надо откуда-то черпать данные для своей работы. Данные, как известно, хранятся в файлах. Тему продолжает '''Антон Черноусов'''.''

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

В течение третьего урока мы поговорим о работе с файлами, о протоколировании работы программы и коснемся методов работы с
XML-данными.

=== Файлы — потоки ===
Сказочное королевство под руководством царевны Несмеяны (так как cупруг практически всегда отсутствовал), благодаря талантам и приобретенным навыкам, стало разрастаться, и результаты полюдья просто-напросто перестали помещаться в семейный чулан. Чтобы накапливать и хранить богатства, потребовались дополнительные помещения, роль которых для нас привычно играют файлы.

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

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

=== Чтение данных ===
Разнообразие классов для работы с файлами позволяет выбрать для себя ту связку, которая больше нравится. Лично я для чтения данных использую BufferedReader, InputStreamReader и FileInputStream. Собственно взаимодействие этих классов для программиста заканчивается в момент создания экземпляра BufferedReader, что делается следующим образом:

<source lang = "java">
BufferedReader br = null;
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile), encoding));
</source>

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

<source lang = "java">
protected static String DEFAULT_ENCODING = "UTF-8";
</source>

Любой текстовый файл можно представить себе в виде набора строк, поэтому давайте реализуем метод для считывания содержимого
файла в массив String[]. Далее представлен метод rippedCurrentFile(path ToFile, encoding) класса FileRipper, который извлекает данные из файла с помощью метода readLine() экземпляра класса BufferedReader:

<source lang = "java">
protected boolean rippedCurrentFile(String pathToFile, String encoding) {
// connecting to file
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile),encoding));
}
catch (UnsupportedEncodingException e) {
this.error = FILE_ERROR_UNSUPPORTED_ENCODING; return false;
}
catch (FileNotFoundException e) {
this.error = FILE_ERROR_NO_FILE; return false;
}
// ripping the file
String str = null;
ArrayList allStrings = new ArrayList();
try {
while (!(str = br.readLine()).equals(null)) { allStrings.add(str); }
}
catch (IOException e) {
this.error = FILE_ERROR_IO_READ; return false;
}
catch (NullPointerException e) {
this.error = FILE_ERROR_END_OF_FILE;
}
// free the resources
try {
br.close();
}
catch (IOException e) {
this.error = FILE_ERROR_IO_CLOSE; return false;
}
this.allStrings = (String[]) allStrings.toArray(new String[0]);
return true;
}

</source>
Полный код примера, в том числе код класса ConsoleToFileRipper, применяющий экземпляр класса FileRipper для извлечения данных из файла, можно найти на диске в каталоге '''examples 1'''.

=== Запись данных ===
Процесс записи данных в файл хоть и отличается от чтения, но тоже достаточно похож на организацию конвейера. Для записи
я обычно использую связку BufferedWriter, OutputStreamWriter, FileOutputStream.
<source lang = "java">
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
</source>
Для освобождения ресурсов, которые используют экземпляры классов BufferedReader и BufferedWriter, необходимо вызвать метод
close().

Далее приведу простой пример метода, который записывает строковый массив в файл (полный код метода расположен на диске в
директории '''examples 2'''):
<source lang = "java">
public boolean createCurrentFile(String pathToFile, String[] allStrings, String encoding){
try {
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
for (int i = 0; i < allStrings.length; i++) {
out.write(allStrings[i]); out.write(‘\n’);
}
out.close();
}
catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
</source>

=== Свободный доступ ===
В представленных ранее примерах доступ к данным осуществляется последовательно, что не всегда удобно (хотя в большинстве случаев именно такой доступ и используется). Для осуществления чтения и записи данных из файла в произвольном порядке существует специальный класс RandomAccessFile, экземпляр которого создается следующим образом:
<source lang = "java">
RandomAccessFile raf = new RandomAccessFile(pathToFile, mode);
</source>
При этом pathToFile — путь до файла, а mode — режим работы. mode может принимать значения: r (только чтение), rw (чтение-запись), rws (чтение-запись с синхронным сохранением содержимого и метаданных), rwd (чтение-запись с синхронным сохранением содержимого файла). К сожалению, кодировку указать нельзя. Огромным преимуществом подхода является то, что с помощью метода getFilePointer() можно узнать текущее месторасположение указателя, а с помощью метода seek() можно передвинуть указатель в необходимое место в файле. Я предпочитаю не использовать данный класс — считайте это личным предубеждением.

=== Протоколирование работы программы ===
Для контроля и анализа работы приложения существуют методы протоколирования. Популярным инструментом для этих целей в мире
Java является библиотека Log4j, которая разрабатывается в Apache Software Foundation. Текущую версию можно загрузить с [http://logging.apache.org/[http://logging.apache.org/]].

Для использования библиотеки необходимо создать конфигурационный файл, который описывает, что, куда и как нужно протоколировать. Log4j имеет три базовые составляющие: logger, appender и layout.

layout — это элементы, определяющие вид и содержание записей. Изначально имеется несколько заранее созданных layout-ов, а в случае необходимости можно создать свой собственный.

Appender — это элемент, определяющий местоположение протокола, с его помощью задается тип протоколирования:
* файловое протоколирование (FileAppender);
* консольное протоколирование (ConsoleAppender);
* протоколирование в базы данных (JDBCAppender);
* протоколирование на SMTP-сервера (SMTPAppender) и др.

Logger — это элемент, который обеспечивает протоколирование какого-либо события. Если обратиться к ранее приведенной аналогии
ленточного конвейера, logger — это и есть тот самый конвейер, вызывая методы которого, мы формируем протокол работы программы.
Элемент logger предусматривает следующие уровни протоколирования: DEBUG, INFO, WARN, ERROR, FATAL; уровням соответствуют методы класса org.apache.log4j.Logger: debug; info; warn; error; fatal.

Ниже представлен пример записей для конфигурационного файла нашего приложения, которые нужно сохранить в файл с названием '''log.properties''' (название файла может быть любым).

<code>
log4j.logger.simple=DEBUG, nameLogAppender
log4j.appender.nameLogAppender=org.apache.log4j.FileAppender
log4j.appender.nameLogAppender.File=nameLogFile.log
log4j.appender.nameLogAppender.layout=org.apache.log4j.SimpleLayout
</code>

Первая строка указывает используемый уровень logger (DEBUG) и appender (nameLogAppender). Далее идут настройки appender: указание типа — FileAppender. В третьей строке указываем путь до файла журнала, а в последней — формат записи. Использовать экземпляр класса Logger можно примерно так (пример протоколирования приведен на диске в каталоге '''examples 3'''):
<source lang = "java">
File propertiesFile = new File("log.properties");
PropertyConfigurator.configure(propertiesFile.toString());
Logger logger = Logger.getLogger("simple");
logger.info("the program has started");
</source>

=== Документы XML ===
Проектируя и создавая ПО, невозможно не столкнутся с миром XML (Extensible Markup Language). XML был создан в недрах World Wide
Web Consortium (W3C) для преодоления ограничений языка HTML. Можно сказать, что HTML — один из самых успешных языков, область
его использования с каждым годом растет (в основном в объемах). Несмотря на это, почему же W3C создал XML, и зачем вам использовать этот язык? В чем ограниченность HTML? Ответ на эти вопросы один:XML был создан для обеспечения взаимодействия разнородных систем.

HTML, как и любой другой текстовый язык, не позволяет перенести смысл тех данных, которые он хранит. XML был разработан для решения этой задачи с прицелом на Web, но получился таким удачным, что его стали использовать практически везде. Суть XML в том, что он хранит семантический смысл данных, поэтому выполнив анализ такого XML-документа, система может «понять» полученные данные. В Интернете существует большое количество информации, посвященной XML (например, [http://www.ibm.com/developerworks/xml/[www.ibm.com/developerworks/xml/]]), поэтому не будем подробно останавливаться на его преимуществах, а сразу приступим к использованию.

<source lang = "xml">
<?xml version="1.0" ?>
<line name="firstLine">
<point id="1" theX="1" theY="1"/>
<point id="2" theX="2" theY="2"/>
</line>
</source>

Выше приведен простой пример XML-документа, содержащего корневой элемент line, который, в свою очередь, содержит два узла с
тремя атрибутами (id, theX, theY) каждый.

=== Создание XML-документа ===
Говоря про создание XML-документа, я подразумеваю создание дерева XML-документа в памяти системы, то есть объекта DOM (Document Object Model). DOM была создана W3C, и это – официальная Рекомендация консорциума. В противовес DOM существует SAX (Simple API for XML). С моделью SAX можно ознакомиться более подробно в
[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp]]. Основная разница между методами заключается в том, что DOM обеспечивает виртуальное представление XML-файла в памяти системы, в то время как SAX – это событийная модель обработки, в которой в момент встречи определенного элемента вызывается соответствующее событие.

Для создания «отображения» XML-файла в памяти системы необходимо воспользоваться классом Document, экземпляр которого можно получить следующим образом:
<source lang = "java">
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
</source>
Создание корневого узла XML документа можно выполняется так:
<source lang = "java">
Element root = doc.createElement("line");
root.setAttribute("name", "firstLine");
</source>
С помощью метода createElement(name) производится создание элементов, в то время как создание и установка значений атрибутов
элементов производится с помощью метода setAttribute(name, value), где name – имя атрибута, а value – его значение. С помощью метода appendChild можно добавить узел в элемент или произвести запись элемента в документ XML, например, так:
<source lang = "java">
root.appendChild(item);
doc.appendChild(root);
</source>
Более детально процесс создания XML документа на примере класса Line изложен в директории '''examples 4'''. При вызове метода
createDoc() этого класса создается экземпляр класса Document, идентичный приведенному ранее коду XML.

=== Сохранение XML-документа ===
Для сохранения созданного в памяти документа предлагаю воспользоваться методом saveXML(docToSave, pathToFile, charSet). В процессе сохранения участвует уже знакомый нам OutputStreamWriter, а также экземпляр класса Transformer, который обеспечивает преобразование объекта DOMSource в выходной поток.
<source lang = "java">
public void saveXML(Document docToSave, String pathToFile, String charSet) {
try {
Writer target = new OutputStreamWriter(new FileOutputStream(pathToFile), charSet);
Source source = new DOMSource(docToSave);
StreamResult dest = new StreamResult(target);
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.ENCODING, charSet);
t.setOutputProperty(OutputKeys.INDENT, "yes");
t.transform(source, dest);
target.flush();
target.close();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
</source>
Реализация этого метода представлена на диске в директории '''examples 5'''.

=== Загрузка XML-документа ===
Подобно сохранению XLM-документа, загрузка также достаточно просто выполняется с помощью экземпляра класса FileInputStream. Используя DocumentBuilderFactory, сгенерируем объект класса Document следующим образом:
<source lang = "java">
FileInputStream fis = new FileInputStream(pathToFile);
Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(fis);
</source>
Фактически, создание документа происходит вследствие выполнения метода parse. Для детально рассмотрения процесса загрузки
XML документа обратитесь к директории '''examples 6''', расположенной на диске.

=== Извлечение данных из XML-документа ===
Итак, что же делать с Document? Работать, естественно! Прежде чем приступить к обработке XML-документа, хочу обратить внимание на одну неприятную особенность: почти всегда XML документ содержит пустые узлы или символы перевода каретки (неизбежное зло форматирования). К сожалению, такая особенность существенно затрудняет процесс обработки XML-документа. Поэтому следует всегда проводить нормализацию с помощью определенного в интерфейсе метода normalize(), или, если реализация Document не имеет такой возможности или нормализация выполняется некорректно – воспользуйтесь методом normalizeDocument класса FileXMLReader (вы найдете его все в той же директории '''examples 6'''). Вызвать данный метод можно следующим образом:
<source lang = "java">
normalizeDocument(doc.getDocumentElement());
</source>
Изложенный выше материал получился несколько другого формата, нежели предыдущие статьи. Статья содержит небольшие примеры
и отсылает на набор сознательно упрощенных готовых решений, благодаря которым вы сможете работать с файлами, производить прото-
колирование деятельности вашего приложения, начать работать с данными в формате XML. Цель приведенных примеров – обеспечить вас
необходимым минимумом информации и дать направление для поиска ответов на Ваши вопросы.

LXF86:Java

2008-03-13T10:34:45Z

Skryabin yuri: /* Загрузка XML-документа */

LXF86:Java

2008-03-13T10:32:41Z

Skryabin yuri: /* Сохранение XML-документа */

=== Хранение данных ===
''ЧАСТЬ 3: Даже самой замечательной программе надо откуда-то черпать данные для своей работы. Данные, как известно, хранятся в файлах. Тему продолжает '''Антон Черноусов'''.''

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

В течение третьего урока мы поговорим о работе с файлами, о протоколировании работы программы и коснемся методов работы с
XML-данными.

=== Файлы — потоки ===
Сказочное королевство под руководством царевны Несмеяны (так как cупруг практически всегда отсутствовал), благодаря талантам и приобретенным навыкам, стало разрастаться, и результаты полюдья просто-напросто перестали помещаться в семейный чулан. Чтобы накапливать и хранить богатства, потребовались дополнительные помещения, роль которых для нас привычно играют файлы.

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

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

=== Чтение данных ===
Разнообразие классов для работы с файлами позволяет выбрать для себя ту связку, которая больше нравится. Лично я для чтения данных использую BufferedReader, InputStreamReader и FileInputStream. Собственно взаимодействие этих классов для программиста заканчивается в момент создания экземпляра BufferedReader, что делается следующим образом:

<source lang = "java">
BufferedReader br = null;
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile), encoding));
</source>

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

<source lang = "java">
protected static String DEFAULT_ENCODING = "UTF-8";
</source>

Любой текстовый файл можно представить себе в виде набора строк, поэтому давайте реализуем метод для считывания содержимого
файла в массив String[]. Далее представлен метод rippedCurrentFile(path ToFile, encoding) класса FileRipper, который извлекает данные из файла с помощью метода readLine() экземпляра класса BufferedReader:

<source lang = "java">
protected boolean rippedCurrentFile(String pathToFile, String encoding) {
// connecting to file
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile),encoding));
}
catch (UnsupportedEncodingException e) {
this.error = FILE_ERROR_UNSUPPORTED_ENCODING; return false;
}
catch (FileNotFoundException e) {
this.error = FILE_ERROR_NO_FILE; return false;
}
// ripping the file
String str = null;
ArrayList allStrings = new ArrayList();
try {
while (!(str = br.readLine()).equals(null)) { allStrings.add(str); }
}
catch (IOException e) {
this.error = FILE_ERROR_IO_READ; return false;
}
catch (NullPointerException e) {
this.error = FILE_ERROR_END_OF_FILE;
}
// free the resources
try {
br.close();
}
catch (IOException e) {
this.error = FILE_ERROR_IO_CLOSE; return false;
}
this.allStrings = (String[]) allStrings.toArray(new String[0]);
return true;
}

</source>
Полный код примера, в том числе код класса ConsoleToFileRipper, применяющий экземпляр класса FileRipper для извлечения данных из файла, можно найти на диске в каталоге '''examples 1'''.

=== Запись данных ===
Процесс записи данных в файл хоть и отличается от чтения, но тоже достаточно похож на организацию конвейера. Для записи
я обычно использую связку BufferedWriter, OutputStreamWriter, FileOutputStream.
<source lang = "java">
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
</source>
Для освобождения ресурсов, которые используют экземпляры классов BufferedReader и BufferedWriter, необходимо вызвать метод
close().

Далее приведу простой пример метода, который записывает строковый массив в файл (полный код метода расположен на диске в
директории '''examples 2'''):
<source lang = "java">
public boolean createCurrentFile(String pathToFile, String[] allStrings, String encoding){
try {
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
for (int i = 0; i < allStrings.length; i++) {
out.write(allStrings[i]); out.write(‘\n’);
}
out.close();
}
catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
</source>

=== Свободный доступ ===
В представленных ранее примерах доступ к данным осуществляется последовательно, что не всегда удобно (хотя в большинстве случаев именно такой доступ и используется). Для осуществления чтения и записи данных из файла в произвольном порядке существует специальный класс RandomAccessFile, экземпляр которого создается следующим образом:
<source lang = "java">
RandomAccessFile raf = new RandomAccessFile(pathToFile, mode);
</source>
При этом pathToFile — путь до файла, а mode — режим работы. mode может принимать значения: r (только чтение), rw (чтение-запись), rws (чтение-запись с синхронным сохранением содержимого и метаданных), rwd (чтение-запись с синхронным сохранением содержимого файла). К сожалению, кодировку указать нельзя. Огромным преимуществом подхода является то, что с помощью метода getFilePointer() можно узнать текущее месторасположение указателя, а с помощью метода seek() можно передвинуть указатель в необходимое место в файле. Я предпочитаю не использовать данный класс — считайте это личным предубеждением.

=== Протоколирование работы программы ===
Для контроля и анализа работы приложения существуют методы протоколирования. Популярным инструментом для этих целей в мире
Java является библиотека Log4j, которая разрабатывается в Apache Software Foundation. Текущую версию можно загрузить с [http://logging.apache.org/[http://logging.apache.org/]].

Для использования библиотеки необходимо создать конфигурационный файл, который описывает, что, куда и как нужно протоколировать. Log4j имеет три базовые составляющие: logger, appender и layout.

layout — это элементы, определяющие вид и содержание записей. Изначально имеется несколько заранее созданных layout-ов, а в случае необходимости можно создать свой собственный.

Appender — это элемент, определяющий местоположение протокола, с его помощью задается тип протоколирования:
* файловое протоколирование (FileAppender);
* консольное протоколирование (ConsoleAppender);
* протоколирование в базы данных (JDBCAppender);
* протоколирование на SMTP-сервера (SMTPAppender) и др.

Logger — это элемент, который обеспечивает протоколирование какого-либо события. Если обратиться к ранее приведенной аналогии
ленточного конвейера, logger — это и есть тот самый конвейер, вызывая методы которого, мы формируем протокол работы программы.
Элемент logger предусматривает следующие уровни протоколирования: DEBUG, INFO, WARN, ERROR, FATAL; уровням соответствуют методы класса org.apache.log4j.Logger: debug; info; warn; error; fatal.

Ниже представлен пример записей для конфигурационного файла нашего приложения, которые нужно сохранить в файл с названием '''log.properties''' (название файла может быть любым).

<code>
log4j.logger.simple=DEBUG, nameLogAppender
log4j.appender.nameLogAppender=org.apache.log4j.FileAppender
log4j.appender.nameLogAppender.File=nameLogFile.log
log4j.appender.nameLogAppender.layout=org.apache.log4j.SimpleLayout
</code>

Первая строка указывает используемый уровень logger (DEBUG) и appender (nameLogAppender). Далее идут настройки appender: указание типа — FileAppender. В третьей строке указываем путь до файла журнала, а в последней — формат записи. Использовать экземпляр класса Logger можно примерно так (пример протоколирования приведен на диске в каталоге '''examples 3'''):
<source lang = "java">
File propertiesFile = new File("log.properties");
PropertyConfigurator.configure(propertiesFile.toString());
Logger logger = Logger.getLogger("simple");
logger.info("the program has started");
</source>

=== Документы XML ===
Проектируя и создавая ПО, невозможно не столкнутся с миром XML (Extensible Markup Language). XML был создан в недрах World Wide
Web Consortium (W3C) для преодоления ограничений языка HTML. Можно сказать, что HTML — один из самых успешных языков, область
его использования с каждым годом растет (в основном в объемах). Несмотря на это, почему же W3C создал XML, и зачем вам использовать этот язык? В чем ограниченность HTML? Ответ на эти вопросы один:XML был создан для обеспечения взаимодействия разнородных систем.

HTML, как и любой другой текстовый язык, не позволяет перенести смысл тех данных, которые он хранит. XML был разработан для решения этой задачи с прицелом на Web, но получился таким удачным, что его стали использовать практически везде. Суть XML в том, что он хранит семантический смысл данных, поэтому выполнив анализ такого XML-документа, система может «понять» полученные данные. В Интернете существует большое количество информации, посвященной XML (например, [http://www.ibm.com/developerworks/xml/[www.ibm.com/developerworks/xml/]]), поэтому не будем подробно останавливаться на его преимуществах, а сразу приступим к использованию.

<source lang = "xml">
<?xml version="1.0" ?>
<line name="firstLine">
<point id="1" theX="1" theY="1"/>
<point id="2" theX="2" theY="2"/>
</line>
</source>

Выше приведен простой пример XML-документа, содержащего корневой элемент line, который, в свою очередь, содержит два узла с
тремя атрибутами (id, theX, theY) каждый.

=== Создание XML-документа ===
Говоря про создание XML-документа, я подразумеваю создание дерева XML-документа в памяти системы, то есть объекта DOM (Document Object Model). DOM была создана W3C, и это – официальная Рекомендация консорциума. В противовес DOM существует SAX (Simple API for XML). С моделью SAX можно ознакомиться более подробно в
[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp]]. Основная разница между методами заключается в том, что DOM обеспечивает виртуальное представление XML-файла в памяти системы, в то время как SAX – это событийная модель обработки, в которой в момент встречи определенного элемента вызывается соответствующее событие.

Для создания «отображения» XML-файла в памяти системы необходимо воспользоваться классом Document, экземпляр которого можно получить следующим образом:
<source lang = "java">
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
</source>
Создание корневого узла XML документа можно выполняется так:
<source lang = "java">
Element root = doc.createElement("line");
root.setAttribute("name", "firstLine");
</source>
С помощью метода createElement(name) производится создание элементов, в то время как создание и установка значений атрибутов
элементов производится с помощью метода setAttribute(name, value), где name – имя атрибута, а value – его значение. С помощью метода appendChild можно добавить узел в элемент или произвести запись элемента в документ XML, например, так:
<source lang = "java">
root.appendChild(item);
doc.appendChild(root);
</source>
Более детально процесс создания XML документа на примере класса Line изложен в директории '''examples 4'''. При вызове метода
createDoc() этого класса создается экземпляр класса Document, идентичный приведенному ранее коду XML.

=== Сохранение XML-документа ===
Для сохранения созданного в памяти документа предлагаю воспользоваться методом saveXML(docToSave, pathToFile, charSet). В процессе сохранения участвует уже знакомый нам OutputStreamWriter, а также экземпляр класса Transformer, который обеспечивает преобразование объекта DOMSource в выходной поток.
<source lang = "java">
public void saveXML(Document docToSave, String pathToFile, String charSet) {
try {
Writer target = new OutputStreamWriter(new FileOutputStream(pathToFile), charSet);
Source source = new DOMSource(docToSave);
StreamResult dest = new StreamResult(target);
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.ENCODING, charSet);
t.setOutputProperty(OutputKeys.INDENT, "yes");
t.transform(source, dest);
target.flush();
target.close();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
</source>
Реализация этого метода представлена на диске в директории '''examples 5'''.

=== Загрузка XML-документа ===

=== Извлечение данных из XML-документа ===

LXF86:Java

2008-03-13T10:32:17Z

Skryabin yuri: /* Сохранение XML-документа */

=== Хранение данных ===
''ЧАСТЬ 3: Даже самой замечательной программе надо откуда-то черпать данные для своей работы. Данные, как известно, хранятся в файлах. Тему продолжает '''Антон Черноусов'''.''

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

В течение третьего урока мы поговорим о работе с файлами, о протоколировании работы программы и коснемся методов работы с
XML-данными.

=== Файлы — потоки ===
Сказочное королевство под руководством царевны Несмеяны (так как cупруг практически всегда отсутствовал), благодаря талантам и приобретенным навыкам, стало разрастаться, и результаты полюдья просто-напросто перестали помещаться в семейный чулан. Чтобы накапливать и хранить богатства, потребовались дополнительные помещения, роль которых для нас привычно играют файлы.

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

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

=== Чтение данных ===
Разнообразие классов для работы с файлами позволяет выбрать для себя ту связку, которая больше нравится. Лично я для чтения данных использую BufferedReader, InputStreamReader и FileInputStream. Собственно взаимодействие этих классов для программиста заканчивается в момент создания экземпляра BufferedReader, что делается следующим образом:

<source lang = "java">
BufferedReader br = null;
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile), encoding));
</source>

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

<source lang = "java">
protected static String DEFAULT_ENCODING = "UTF-8";
</source>

Любой текстовый файл можно представить себе в виде набора строк, поэтому давайте реализуем метод для считывания содержимого
файла в массив String[]. Далее представлен метод rippedCurrentFile(path ToFile, encoding) класса FileRipper, который извлекает данные из файла с помощью метода readLine() экземпляра класса BufferedReader:

<source lang = "java">
protected boolean rippedCurrentFile(String pathToFile, String encoding) {
// connecting to file
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile),encoding));
}
catch (UnsupportedEncodingException e) {
this.error = FILE_ERROR_UNSUPPORTED_ENCODING; return false;
}
catch (FileNotFoundException e) {
this.error = FILE_ERROR_NO_FILE; return false;
}
// ripping the file
String str = null;
ArrayList allStrings = new ArrayList();
try {
while (!(str = br.readLine()).equals(null)) { allStrings.add(str); }
}
catch (IOException e) {
this.error = FILE_ERROR_IO_READ; return false;
}
catch (NullPointerException e) {
this.error = FILE_ERROR_END_OF_FILE;
}
// free the resources
try {
br.close();
}
catch (IOException e) {
this.error = FILE_ERROR_IO_CLOSE; return false;
}
this.allStrings = (String[]) allStrings.toArray(new String[0]);
return true;
}

</source>
Полный код примера, в том числе код класса ConsoleToFileRipper, применяющий экземпляр класса FileRipper для извлечения данных из файла, можно найти на диске в каталоге '''examples 1'''.

=== Запись данных ===
Процесс записи данных в файл хоть и отличается от чтения, но тоже достаточно похож на организацию конвейера. Для записи
я обычно использую связку BufferedWriter, OutputStreamWriter, FileOutputStream.
<source lang = "java">
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
</source>
Для освобождения ресурсов, которые используют экземпляры классов BufferedReader и BufferedWriter, необходимо вызвать метод
close().

Далее приведу простой пример метода, который записывает строковый массив в файл (полный код метода расположен на диске в
директории '''examples 2'''):
<source lang = "java">
public boolean createCurrentFile(String pathToFile, String[] allStrings, String encoding){
try {
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
for (int i = 0; i < allStrings.length; i++) {
out.write(allStrings[i]); out.write(‘\n’);
}
out.close();
}
catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
</source>

=== Свободный доступ ===
В представленных ранее примерах доступ к данным осуществляется последовательно, что не всегда удобно (хотя в большинстве случаев именно такой доступ и используется). Для осуществления чтения и записи данных из файла в произвольном порядке существует специальный класс RandomAccessFile, экземпляр которого создается следующим образом:
<source lang = "java">
RandomAccessFile raf = new RandomAccessFile(pathToFile, mode);
</source>
При этом pathToFile — путь до файла, а mode — режим работы. mode может принимать значения: r (только чтение), rw (чтение-запись), rws (чтение-запись с синхронным сохранением содержимого и метаданных), rwd (чтение-запись с синхронным сохранением содержимого файла). К сожалению, кодировку указать нельзя. Огромным преимуществом подхода является то, что с помощью метода getFilePointer() можно узнать текущее месторасположение указателя, а с помощью метода seek() можно передвинуть указатель в необходимое место в файле. Я предпочитаю не использовать данный класс — считайте это личным предубеждением.

=== Протоколирование работы программы ===
Для контроля и анализа работы приложения существуют методы протоколирования. Популярным инструментом для этих целей в мире
Java является библиотека Log4j, которая разрабатывается в Apache Software Foundation. Текущую версию можно загрузить с [http://logging.apache.org/[http://logging.apache.org/]].

Для использования библиотеки необходимо создать конфигурационный файл, который описывает, что, куда и как нужно протоколировать. Log4j имеет три базовые составляющие: logger, appender и layout.

layout — это элементы, определяющие вид и содержание записей. Изначально имеется несколько заранее созданных layout-ов, а в случае необходимости можно создать свой собственный.

Appender — это элемент, определяющий местоположение протокола, с его помощью задается тип протоколирования:
* файловое протоколирование (FileAppender);
* консольное протоколирование (ConsoleAppender);
* протоколирование в базы данных (JDBCAppender);
* протоколирование на SMTP-сервера (SMTPAppender) и др.

Logger — это элемент, который обеспечивает протоколирование какого-либо события. Если обратиться к ранее приведенной аналогии
ленточного конвейера, logger — это и есть тот самый конвейер, вызывая методы которого, мы формируем протокол работы программы.
Элемент logger предусматривает следующие уровни протоколирования: DEBUG, INFO, WARN, ERROR, FATAL; уровням соответствуют методы класса org.apache.log4j.Logger: debug; info; warn; error; fatal.

Ниже представлен пример записей для конфигурационного файла нашего приложения, которые нужно сохранить в файл с названием '''log.properties''' (название файла может быть любым).

<code>
log4j.logger.simple=DEBUG, nameLogAppender
log4j.appender.nameLogAppender=org.apache.log4j.FileAppender
log4j.appender.nameLogAppender.File=nameLogFile.log
log4j.appender.nameLogAppender.layout=org.apache.log4j.SimpleLayout
</code>

Первая строка указывает используемый уровень logger (DEBUG) и appender (nameLogAppender). Далее идут настройки appender: указание типа — FileAppender. В третьей строке указываем путь до файла журнала, а в последней — формат записи. Использовать экземпляр класса Logger можно примерно так (пример протоколирования приведен на диске в каталоге '''examples 3'''):
<source lang = "java">
File propertiesFile = new File("log.properties");
PropertyConfigurator.configure(propertiesFile.toString());
Logger logger = Logger.getLogger("simple");
logger.info("the program has started");
</source>

=== Документы XML ===
Проектируя и создавая ПО, невозможно не столкнутся с миром XML (Extensible Markup Language). XML был создан в недрах World Wide
Web Consortium (W3C) для преодоления ограничений языка HTML. Можно сказать, что HTML — один из самых успешных языков, область
его использования с каждым годом растет (в основном в объемах). Несмотря на это, почему же W3C создал XML, и зачем вам использовать этот язык? В чем ограниченность HTML? Ответ на эти вопросы один:XML был создан для обеспечения взаимодействия разнородных систем.

HTML, как и любой другой текстовый язык, не позволяет перенести смысл тех данных, которые он хранит. XML был разработан для решения этой задачи с прицелом на Web, но получился таким удачным, что его стали использовать практически везде. Суть XML в том, что он хранит семантический смысл данных, поэтому выполнив анализ такого XML-документа, система может «понять» полученные данные. В Интернете существует большое количество информации, посвященной XML (например, [http://www.ibm.com/developerworks/xml/[www.ibm.com/developerworks/xml/]]), поэтому не будем подробно останавливаться на его преимуществах, а сразу приступим к использованию.

<source lang = "xml">
<?xml version="1.0" ?>
<line name="firstLine">
<point id="1" theX="1" theY="1"/>
<point id="2" theX="2" theY="2"/>
</line>
</source>

Выше приведен простой пример XML-документа, содержащего корневой элемент line, который, в свою очередь, содержит два узла с
тремя атрибутами (id, theX, theY) каждый.

=== Создание XML-документа ===
Говоря про создание XML-документа, я подразумеваю создание дерева XML-документа в памяти системы, то есть объекта DOM (Document Object Model). DOM была создана W3C, и это – официальная Рекомендация консорциума. В противовес DOM существует SAX (Simple API for XML). С моделью SAX можно ознакомиться более подробно в
[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp]]. Основная разница между методами заключается в том, что DOM обеспечивает виртуальное представление XML-файла в памяти системы, в то время как SAX – это событийная модель обработки, в которой в момент встречи определенного элемента вызывается соответствующее событие.

Для создания «отображения» XML-файла в памяти системы необходимо воспользоваться классом Document, экземпляр которого можно получить следующим образом:
<source lang = "java">
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
</source>
Создание корневого узла XML документа можно выполняется так:
<source lang = "java">
Element root = doc.createElement("line");
root.setAttribute("name", "firstLine");
</source>
С помощью метода createElement(name) производится создание элементов, в то время как создание и установка значений атрибутов
элементов производится с помощью метода setAttribute(name, value), где name – имя атрибута, а value – его значение. С помощью метода appendChild можно добавить узел в элемент или произвести запись элемента в документ XML, например, так:
<source lang = "java">
root.appendChild(item);
doc.appendChild(root);
</source>
Более детально процесс создания XML документа на примере класса Line изложен в директории '''examples 4'''. При вызове метода
createDoc() этого класса создается экземпляр класса Document, идентичный приведенному ранее коду XML.

=== Сохранение XML-документа ===
Для сохранения созданного в памяти документа предлагаю воспользоваться методом saveXML(docToSave, pathToFile, charSet). В процессе сохранения участвует уже знакомый нам OutputStreamWriter, а также экземпляр класса Transformer, который обеспечивает преобразование объекта DOMSource в выходной поток.
<source lang = "java">
public void saveXML(Document docToSave, String pathToFile, String charSet) {
try {
Writer target = new OutputStreamWriter(new FileOutputStream(pathToFile), charSet);
Source source = new DOMSource(docToSave);
StreamResult dest = new StreamResult(target);
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.ENCODING, charSet);
t.setOutputProperty(OutputKeys.INDENT, “yes”);
t.transform(source, dest);
target.flush();
target.close();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
</source>
Реализация этого метода представлена на диске в директории '''examples 5'''.

=== Загрузка XML-документа ===

=== Извлечение данных из XML-документа ===

LXF86:Java

2008-03-13T10:28:34Z

Skryabin yuri: /* Создание XML-документа */

=== Хранение данных ===
''ЧАСТЬ 3: Даже самой замечательной программе надо откуда-то черпать данные для своей работы. Данные, как известно, хранятся в файлах. Тему продолжает '''Антон Черноусов'''.''

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

В течение третьего урока мы поговорим о работе с файлами, о протоколировании работы программы и коснемся методов работы с
XML-данными.

=== Файлы — потоки ===
Сказочное королевство под руководством царевны Несмеяны (так как cупруг практически всегда отсутствовал), благодаря талантам и приобретенным навыкам, стало разрастаться, и результаты полюдья просто-напросто перестали помещаться в семейный чулан. Чтобы накапливать и хранить богатства, потребовались дополнительные помещения, роль которых для нас привычно играют файлы.

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

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

=== Чтение данных ===
Разнообразие классов для работы с файлами позволяет выбрать для себя ту связку, которая больше нравится. Лично я для чтения данных использую BufferedReader, InputStreamReader и FileInputStream. Собственно взаимодействие этих классов для программиста заканчивается в момент создания экземпляра BufferedReader, что делается следующим образом:

<source lang = "java">
BufferedReader br = null;
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile), encoding));
</source>

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

<source lang = "java">
protected static String DEFAULT_ENCODING = "UTF-8";
</source>

Любой текстовый файл можно представить себе в виде набора строк, поэтому давайте реализуем метод для считывания содержимого
файла в массив String[]. Далее представлен метод rippedCurrentFile(path ToFile, encoding) класса FileRipper, который извлекает данные из файла с помощью метода readLine() экземпляра класса BufferedReader:

<source lang = "java">
protected boolean rippedCurrentFile(String pathToFile, String encoding) {
// connecting to file
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile),encoding));
}
catch (UnsupportedEncodingException e) {
this.error = FILE_ERROR_UNSUPPORTED_ENCODING; return false;
}
catch (FileNotFoundException e) {
this.error = FILE_ERROR_NO_FILE; return false;
}
// ripping the file
String str = null;
ArrayList allStrings = new ArrayList();
try {
while (!(str = br.readLine()).equals(null)) { allStrings.add(str); }
}
catch (IOException e) {
this.error = FILE_ERROR_IO_READ; return false;
}
catch (NullPointerException e) {
this.error = FILE_ERROR_END_OF_FILE;
}
// free the resources
try {
br.close();
}
catch (IOException e) {
this.error = FILE_ERROR_IO_CLOSE; return false;
}
this.allStrings = (String[]) allStrings.toArray(new String[0]);
return true;
}

</source>
Полный код примера, в том числе код класса ConsoleToFileRipper, применяющий экземпляр класса FileRipper для извлечения данных из файла, можно найти на диске в каталоге '''examples 1'''.

=== Запись данных ===
Процесс записи данных в файл хоть и отличается от чтения, но тоже достаточно похож на организацию конвейера. Для записи
я обычно использую связку BufferedWriter, OutputStreamWriter, FileOutputStream.
<source lang = "java">
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
</source>
Для освобождения ресурсов, которые используют экземпляры классов BufferedReader и BufferedWriter, необходимо вызвать метод
close().

Далее приведу простой пример метода, который записывает строковый массив в файл (полный код метода расположен на диске в
директории '''examples 2'''):
<source lang = "java">
public boolean createCurrentFile(String pathToFile, String[] allStrings, String encoding){
try {
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
for (int i = 0; i < allStrings.length; i++) {
out.write(allStrings[i]); out.write(‘\n’);
}
out.close();
}
catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
</source>

=== Свободный доступ ===
В представленных ранее примерах доступ к данным осуществляется последовательно, что не всегда удобно (хотя в большинстве случаев именно такой доступ и используется). Для осуществления чтения и записи данных из файла в произвольном порядке существует специальный класс RandomAccessFile, экземпляр которого создается следующим образом:
<source lang = "java">
RandomAccessFile raf = new RandomAccessFile(pathToFile, mode);
</source>
При этом pathToFile — путь до файла, а mode — режим работы. mode может принимать значения: r (только чтение), rw (чтение-запись), rws (чтение-запись с синхронным сохранением содержимого и метаданных), rwd (чтение-запись с синхронным сохранением содержимого файла). К сожалению, кодировку указать нельзя. Огромным преимуществом подхода является то, что с помощью метода getFilePointer() можно узнать текущее месторасположение указателя, а с помощью метода seek() можно передвинуть указатель в необходимое место в файле. Я предпочитаю не использовать данный класс — считайте это личным предубеждением.

=== Протоколирование работы программы ===
Для контроля и анализа работы приложения существуют методы протоколирования. Популярным инструментом для этих целей в мире
Java является библиотека Log4j, которая разрабатывается в Apache Software Foundation. Текущую версию можно загрузить с [http://logging.apache.org/[http://logging.apache.org/]].

Для использования библиотеки необходимо создать конфигурационный файл, который описывает, что, куда и как нужно протоколировать. Log4j имеет три базовые составляющие: logger, appender и layout.

layout — это элементы, определяющие вид и содержание записей. Изначально имеется несколько заранее созданных layout-ов, а в случае необходимости можно создать свой собственный.

Appender — это элемент, определяющий местоположение протокола, с его помощью задается тип протоколирования:
* файловое протоколирование (FileAppender);
* консольное протоколирование (ConsoleAppender);
* протоколирование в базы данных (JDBCAppender);
* протоколирование на SMTP-сервера (SMTPAppender) и др.

Logger — это элемент, который обеспечивает протоколирование какого-либо события. Если обратиться к ранее приведенной аналогии
ленточного конвейера, logger — это и есть тот самый конвейер, вызывая методы которого, мы формируем протокол работы программы.
Элемент logger предусматривает следующие уровни протоколирования: DEBUG, INFO, WARN, ERROR, FATAL; уровням соответствуют методы класса org.apache.log4j.Logger: debug; info; warn; error; fatal.

Ниже представлен пример записей для конфигурационного файла нашего приложения, которые нужно сохранить в файл с названием '''log.properties''' (название файла может быть любым).

<code>
log4j.logger.simple=DEBUG, nameLogAppender
log4j.appender.nameLogAppender=org.apache.log4j.FileAppender
log4j.appender.nameLogAppender.File=nameLogFile.log
log4j.appender.nameLogAppender.layout=org.apache.log4j.SimpleLayout
</code>

Первая строка указывает используемый уровень logger (DEBUG) и appender (nameLogAppender). Далее идут настройки appender: указание типа — FileAppender. В третьей строке указываем путь до файла журнала, а в последней — формат записи. Использовать экземпляр класса Logger можно примерно так (пример протоколирования приведен на диске в каталоге '''examples 3'''):
<source lang = "java">
File propertiesFile = new File("log.properties");
PropertyConfigurator.configure(propertiesFile.toString());
Logger logger = Logger.getLogger("simple");
logger.info("the program has started");
</source>

=== Документы XML ===
Проектируя и создавая ПО, невозможно не столкнутся с миром XML (Extensible Markup Language). XML был создан в недрах World Wide
Web Consortium (W3C) для преодоления ограничений языка HTML. Можно сказать, что HTML — один из самых успешных языков, область
его использования с каждым годом растет (в основном в объемах). Несмотря на это, почему же W3C создал XML, и зачем вам использовать этот язык? В чем ограниченность HTML? Ответ на эти вопросы один:XML был создан для обеспечения взаимодействия разнородных систем.

HTML, как и любой другой текстовый язык, не позволяет перенести смысл тех данных, которые он хранит. XML был разработан для решения этой задачи с прицелом на Web, но получился таким удачным, что его стали использовать практически везде. Суть XML в том, что он хранит семантический смысл данных, поэтому выполнив анализ такого XML-документа, система может «понять» полученные данные. В Интернете существует большое количество информации, посвященной XML (например, [http://www.ibm.com/developerworks/xml/[www.ibm.com/developerworks/xml/]]), поэтому не будем подробно останавливаться на его преимуществах, а сразу приступим к использованию.

<source lang = "xml">
<?xml version="1.0" ?>
<line name="firstLine">
<point id="1" theX="1" theY="1"/>
<point id="2" theX="2" theY="2"/>
</line>
</source>

Выше приведен простой пример XML-документа, содержащего корневой элемент line, который, в свою очередь, содержит два узла с
тремя атрибутами (id, theX, theY) каждый.

=== Создание XML-документа ===
Говоря про создание XML-документа, я подразумеваю создание дерева XML-документа в памяти системы, то есть объекта DOM (Document Object Model). DOM была создана W3C, и это – официальная Рекомендация консорциума. В противовес DOM существует SAX (Simple API for XML). С моделью SAX можно ознакомиться более подробно в
[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp]]. Основная разница между методами заключается в том, что DOM обеспечивает виртуальное представление XML-файла в памяти системы, в то время как SAX – это событийная модель обработки, в которой в момент встречи определенного элемента вызывается соответствующее событие.

Для создания «отображения» XML-файла в памяти системы необходимо воспользоваться классом Document, экземпляр которого можно получить следующим образом:
<source lang = "java">
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
</source>
Создание корневого узла XML документа можно выполняется так:
<source lang = "java">
Element root = doc.createElement("line");
root.setAttribute("name", "firstLine");
</source>
С помощью метода createElement(name) производится создание элементов, в то время как создание и установка значений атрибутов
элементов производится с помощью метода setAttribute(name, value), где name – имя атрибута, а value – его значение. С помощью метода appendChild можно добавить узел в элемент или произвести запись элемента в документ XML, например, так:
<source lang = "java">
root.appendChild(item);
doc.appendChild(root);
</source>
Более детально процесс создания XML документа на примере класса Line изложен в директории '''examples 4'''. При вызове метода
createDoc() этого класса создается экземпляр класса Document, идентичный приведенному ранее коду XML.

=== Сохранение XML-документа ===

=== Загрузка XML-документа ===

=== Извлечение данных из XML-документа ===

LXF86:Java

2008-03-13T10:21:50Z

Skryabin yuri: /* Документы XML */

LXF86:Java

2008-03-13T10:20:01Z

Skryabin yuri: /* Документы XML */

LXF86:Java

2008-03-13T10:11:55Z

Skryabin yuri: /* Протоколирование работы программы */

LXF86:Java

2008-03-13T10:00:25Z

Skryabin yuri: /* Свободный доступ */

LXF86:Java

2008-03-13T09:57:15Z

Skryabin yuri: /* Запись данных */

LXF86:Java

2008-03-13T09:53:14Z

Skryabin yuri: /* Чтение данных */

LXF86:Java

2008-03-13T09:52:19Z

Skryabin yuri: /* Чтение данных */

LXF86:Java

2008-03-13T09:36:27Z

Skryabin yuri: /* Файлы — потоки */

LXF84:OSDL

2008-03-13T09:30:12Z

Skryabin yuri: Содержание

=== Что сделала для нас OSDL? ===
''Кажется, что The Open Source Development Labs (Лаборатория Разработки Открытого Кода) сидит на нескольких стульях – но знает ли кто-нибудь, чем конкретно она занимается? Расследование ведет '''Грэм Моррисон'''.''

Прочтя интервью со Стюартом Коэном [Stuart Cohen] пару номеров назад, вы, наверное, захотели узнать побольше о его нанимателе.
Коэн – исполнительный директор OSDL, организации, образованной в 2000 г. консорциумом больших компаний, в том числе, CA, Hitachi, HP, IBM, Intel и NEC. Эти фирмы предоставили финансирование и получили центр разработки Open Source, беспристрастный и некоммерческий, который посвящен продвижению Linux (на что многие из них делают ставку) в большой бизнес. Это мир подготовительных комитетов и спецификаций, рабочих групп и официальных документов: частично – мозговой центр, частично – глобальный консорциум, и частично – Международное Спасение.

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

За лабораторией стоят хорошо продуманные и хорошо финансируемые проекты. Например, она сформировала фонд юридической защиты для помощи в борьбе пользователей Linux против угроз возбуждения судебных дел, ее рабочие группы разрабатывают исключительно подробные спецификации; ею нанято по меньшей мере 10 разработчиков из тех, что напрямую влияют на функции Linux-систем, используемых нами ежедневно – половина годового бюджета лаборатории, а это $5 млн., тратится на развитие технологий.

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

Хотя OSDL и «открытая», но все же оставляет ощущение некоторой загадочности. Поэтому мы собираемся присмотреться к некоторым сотрудникам OSDL и крупнейшим ее проектам и решить, что же служит стимулом для этой организации. Для сначала сразу предупредим: поскольку это большой бизнес, то будет много акронимов. Мы пытаемся поменьше употреблять их, но все же их будет
много. С другой стороны, мы постарались свести к функциональному минимуму использование слова «рычаг», так что можете читать без опасения запутаться.

[[Image:Img_84_39_1.jpg|right|thumb|Трудоустройство Линуса Торвальдса дало OSDL рекламную раскрутку.]]
[[Image:Img_84_39_2.jpg|right|thumb|Эндрю Мортон все время пребывания в OSDL занимался ядром.]]
[[Image:Img_84_39_3.jpg|right|thumb|Тридж ушел, как только закончил работу над Samba 4.]]

=== Хакеры высокого полета ===
''Вот реальные причины важности OSDL.''

Одной из причин известности OSDL является то, что в ней работают высококлассные хакеры ядра. Отчасти это потому, что она любит фанфары, а отчасти потому, что никто не сможет игнорировать организацию, трудоустроившую Торвальдса. Альтруистический аспект мотивации найма на работу Линуса Торвальдса, Эндрю Мортона и иже с ними в том, что OSDL хотела предоставить им условия разработки без конфликтов с другими обязанностями, чтобы эти два разработчика смогли целиком сосредоточиться на разработке ядра Linux. Но нельзя отрицать, что OSDL получает свою долю аплодисментов, когда люди видят ее логотип на их визитных карточках.

Нет ни одного пресс-релиза от OSDL, который бы не включал следующую сноску: «OSDL – спонсор Линуса Торвальдса,
создателя ядра Linux – призвана ускорить рост и адаптацию операционных систем на основе Linux на предприятиях». Без сомнения, немалой частью оказываемого ей доверия OSDL обязана найму Линуса Торвальдса, человека, с которого все началось. До перехода в OSDL в июне 2003 г., Торвальдс был сотрудником корпорации Transmeta (члена OSDL), разрешавшей ему в рабочее время повозиться с ядром Linux, помимо разработки ее собственного ПО. Переход позволил Торвальдсу сосредоточиться исключительно на основных
компонентах ядра Linux.

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

Эндрю Мортон присоединился к Линусу в OSDL через месяц, в июле 2003 г. Мортон – «хранитель» ядра 2.6 (Торвальдс работает над текущей версией ядра), то есть лицо, ответственное за включение заплаток от третьих лиц в древо ядра текущей версии. Недавно, он, к недоумению многих, предложил посвятить следующий цикл разработки ядра исправлению ошибок, закравшихся в текущую версию.
Было очень ценно, что два основных разработчика Linux работают в одной компании, причем бок о бок. Но в августе Мортон ушел в Google. Это может нарушить нейтральность, которой разработчики наслаждались в OSDL, где отсутствовало прямое давление со стороны крупных фирм, являющихся частью OSDL.

==== Теплица для ядра ====

OSDL получила своего второго сотрудника в январе 2005 г., когда ее ряды пополнил Эндрю Триджелл, ведущий разработчик Samba – одного из самых важных существующих проектов с открытым кодом. Без Samba мы не могли бы совместно использовать любые файлы или принтеры с Windows-машинами в локальной сети, а это необходимое звено при развертывании Linux в любом офисе или на предприятии. OSDL позволила Триджеллу работать над ней полный рабочий день, но, завершив запланированные работы над четвертой версией комплекса приложений Samba, он ее покинул и вернулся на свою предыдущую должность в IBM, оставаясь лидером проекта Samba. Уходя, Триджелл выразил благодарность OSDL за ее участие в проекте: «Обладать временем, позволяющим сосредоточиться только на одном проекте, действительно здорово. Большое спасибо OSDL за участие и поддержку разработки Samba».

=== Устанавливая стандарты ===

''Если для внедрения Linux на предприятии требуется поработать с бумагами, то OSDL как раз и может здесь помочь.''

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

Наверху – рабочая группа Carrier Grade Linux (CGL), проталкивающая Linux в бурно разрастающийся телекоммуникационный бизнес. Посередине – группа Data Center Linux (DCL). Ее любимое слово – «рычаги», и она старается открыть для Linux рынок вычислительных центров крупных корпораций. И, наконец, группа Desktop Linux (DTL) сосредоточена на том, что понятно нам всем, а именно на продвижении Linux в настольные среды, типичные для офисов.

==== Для телекоммуникаций ====

Внедрение в области, традиционно использующие проприетарные решения – одна из главных задач OSDL, и есть одна область, в которой можно особенно поживиться. Это индустрия телекоммуникаций. Здесь традиционно вкладываются средства в проприетарные оборудование и программное обеспечение, и безопасная, стабильная и расширяемая Linux-альтернатива принесла бы немало выгоды. Решение от OSDL известно как Carrier Grade Linux (CGL – отказоустойчивый Linux): это спецификации системы, надежной более чем на 99.999% – всего пять минут на отказ в год. Но некоторые установки требуют даже большей надежности, около 99.9999%, то есть не более 30 секунд на отказ в год. Даже при знаменитой безопасности Linux необходимо многое изменить, чтобы гарантировать такое качество.

В январе 2002 г. OSDL сформировала рабочую группу CGL (для коллекционеров акронимов – CGL-WG), чтобы создать для Linux комитет по телекоммуникациям. Основная задача группы – утверждение стандарта, который обеспечит доступную и высокоэффективную операционную систему Linux с прекрасной поддержкой, способную напрямую конкурировать с готовыми и заказными проприетарными решениями, получающими все большее распространение. Участие в ней приняли 24 организации – члены OSDL, а учредительские
обязанности легли на плечи IBM, MontaVista (известной благодаря своей real-time версии ядра Linux), Intel и NTT Network Service Systems Labs, возглавляющей подкомитет разработки. К настоящему моменту имеется пять версий спецификации. Версия 3.1 вышла в июне 2005. Заговорщики из OSDL работают над версией 3.2 и намерены выпустить ее в этом году.

В спецификации CGL-WG девять основных положений, среди которых:
*Соответствие стандартам

Это действительно залог нормальной работы CGL-WG с другими стандартами Linux и индустрии телекоммуникаций. Сюда включаются Linux Standard Base (LSB), POSIX, IPv6 и PCI Industrial Computer Manufacturer’s Group.
*Платформа

Любая CGL-система накладывает специфические требования на оборудование. Сюда входит «горячая» замена, удаленная загрузка, бездисковое выполнение приложений через сеть и архитектура Advanced Telecom Computing Architecture [Продвинутая архитектура телекоммуникационных вычислений – серия спецификаций промышленных стандартов, разработанных для следующего поколения отказоустойчивого оборудования и ПО].

*Работоспособность

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

*Удобство обслуживания

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

*Кластеризация

Запуск приложений на кластерах часто является единственным способом получения высоких уровней доступности, требуемых CGL. Кластер обеспечивает повышенную производительность и резервирование использованием параллельных ресурсов. Кластеризация настолько важна, что породила свой собственный проект OSDL.

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

OSDL хочет выглядеть скорее сторонником Linux корпоративного уровня, уровня вычислительных центров, а не проталкивать открытый код на машины меньшего размера или даже на настольные компьютеры. Частично это связано с техническими аспектами CGL, а также с тем, что OSDL содержит и управляет рабочую группу DCL, цель которой – установка Linux в хранилищах данных с водяным и воздушным охлаждением некоторых крупных корпораций, многие из которых, так уж вышло, являются членами OSDL, но есть и фирмы вроде Siemens AG и Unisys.

==== В базе данных – пингвины?! ====

Поскольку CGL-спецификация очень тщательна, рабочая группа DCL может использовать ее в качестве стартовой точки для
высококлассного центра обработки данных. Вычислительные центры, объединяющие корпоративные сервера приложений,
базы данных и т.д., лежат в сфере ИТ с высокими стандартами. Цели группы DCL разбиты на три области деятельности,
обозначенные как Передний край (Edge), Приложения, База данных. Группа определяет «Край» как сервер, где наряду
с web-сервисами имеются edge-приложения – в основном ради улучшения производительности путем использования
промежуточного сервера для передачи запросов к сервисам, запущенным на других машинах. Приложения и База данных
в объяснениях не нуждаются.

Плодом работы группы является версия 1.2 документа, озаглавленного «Цели и Возможности DCL» и впервые выпущенного еще в 2004. Это огромный документ с добавками от Sun, HP, IBM и Intel. Он похож скорее на техническую спецификацию, в нем приводится список более 300 возможностей, которые, как считает группа, важны для принятия Linux предприятиями. Например, приоритет номер один – возможность расширения до 16 CPU (пожалуй, уже маловато), асинхронный сетевой ввод/вывод и «горячая» замена процессоров,
памяти, а также устройств PCI/PCI-X.

==== На рабочем столе ====

Не удивительно, что самая молодая рабочая группа OSDL нацелена на настольный Linux. OSDL, видимо, понадеялась, что образование группы – в начале 2003 г. – будет ответом на критику заботы о внедрении Linux только на корпоративный рынок. И верно, образование рабочей группы DTL дало всему сообществу Linux возможность включиться в то, в чем оно имеет непосредственный опыт, и OSDL признает, что потенциальный размах этого проекта может затмить обе другие ее инициативы. Но группа отнюдь не чурается предприятий, и Desktop Linux включает области, которые вы не сразу отнесете к открытому рабочему столу – например, киоски и рабочие станции с фиксированным набором функций.

Вы будете разочарованы, если ожидали больше действий и меньше создания спецификаций – количество бумажной работы остается обильным. DTL формулирует свою миссию как «работа с сообществом Open Source с целью выявления большого набора моделей настольного Linux, разработки спецификации и предоставлению рекомендаций.» Вы можете найти спецификацию версии 1.0 на web-сайте OSDL, и в отличие от спецификаций CGL и DCL, она удобочитаема!

В настоящее время DTL работает при содействии представителей AMD, Novell, Intel и IBM. Одной из их наиболее интересных работ является не код, а результаты исследования, проведенного в октябре 2005 г., чтобы определить фокус действий рабочей группы.
ИТ-профессионалам, внедрившим или думающим о внедрении настольного Linux в своих учреждениях, были заданы вопросы об использовании Linux. Было опрошено 3300 респондентов, и результаты удивили многих. Самым неожиданным оказался ответ на вопрос о причине выбора Linux ИТ-профессионалами. Это не экономия денег и не повышенная безопасность, как предсказывали многие
эксперты, а чей-то совет. Люди использовали Linux и были им так довольны, что рекомендовали коллегам. Электронная
почта, офисные инструменты и web-браузеры были признаны критически важными приложениями, а дистрибутив Ubuntu оказался самым популярным. Естественно, что результаты опроса (см. [http://www.osdl.org/dtl/DTL_Survey_Report_Nov2005.pdf[www.osdl.org/dtl/DTL_Survey_Report_Nov2005.pdf]]) вызвали много разговоров в сообществе Linux.

==== Молчаливый партнер ====
Критиковать OSDL за разработку одной спецификации за другой без написания хотя бы строки кода легко, но как раз это
и необходимо корпоративному рынку, на который OSDL пытается пробиться. Что нам нравится меньше, так это отсутствие
диалога с большим сообществом Linux – обычные пользователи Linux остаются за бортом любых разработок, выполняе-
мых для соответствия большому бизнесу. Хороший пример – написание данной статьи, потому как даже нам было трудно
получить комментарии или отзывы от людей из OSDL. А каковы шансы среднего раздраженного пользователя Linux?

Если бы OSDL не твердила столь часто, что она является «центром тяжести» разработки Linux, мы были бы счастливы причислить OSDL к компаниям вроде CollabNet, продвигающей открытые стандарты и изменяющей способ ведения бизнеса крупными предприятиями. Но это не так. OSDL финансируется несколькими крупнейшими фирмами ИТ-бизнеса и наняла двух самых влиятельных из имеющихся разработчиков Linux. Если OSDL желает рассеять дымовую завесу, скрывающую ее действия и мотивы, то ей необходимо уделять
больше внимания взаимодействию с сообществом. Когда это случится, Linux действительно созреет для предприятий.
----
=== Проект Open Driver (врезка) ===
В поисках новых альтернатив, OSDL часто затевает и финансирует проекты. Наиболее масштабные ее кампании выросли из поддержки открытого форума San Francisco Linux World Expo в августе 2005. Форум был посвящен обсуждению препятствий разработке драйверов с открытым кодом, и на нем присутствовало много разработчиков драйверов ядра. Форум обозначил потребность в централизации разработки драйверов – явно в унисон с философией «центра притяжения» OSDL, и лаборатория взяла на себя создание web-сайта, способного играть роль центра разработки драйверов.

В результате возник проект Open Driver, с домашней страницей [http://developer.osdl.org/dev/opendrivers[http://developer.osdl.org/dev/opendrivers]]. Сайт содержит новейшую информацию, необходимую для создания и установки ваших собственных драйверов. Число категорий драйверов стало заметно
больше изначальных пяти (носители, сеть, принтеры, видео и звук), охватив большинство других настольных устройств; среди них – сканеры, MP3-плейеры и цифровые камеры.

Оригинального контента на сайте не слишком много. Вместо этого, каждая категория предоставляет список самых свежих сетевых ресурсов по вашему оборудованию. Цель сайта в том, чтобы разработчики драйверов, начинающие свой путь в Linux и Open Source, имели центральный репозиторий и понимание, с чего начать. Проект Open Driver содержит свои собственные wiki и списки рассылки, а также учебный семинар, в этом году совпавший с OSCon в Портленде, штат Орегон.

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

=== Проекты, о которых стоит знать... (врезка) ===
OSDL наделала много шума из продвижения Linux на корпоративный рынок, но она не только готовит спецификации. Вот несколько более приземленных проектов:
*Создание Фонда Юридической защиты Linux
В начале 2004 г., когда была серьезная угроза судебных исков со стороны группы SCO ко всем использующим ОС Linux, OSDL создала Фонд Юридической Защиты Linux, выделив $10 млн. для помощи конечным пользователям, втянутым в битву с SCO.
*Сертификат разработчика о Происхождении (Developer’s Certificate of Origin)
Другим результатом тяжбы с SCO стало понимание необходимости отслеживания вклада отдельных программистов в разработку ядра. OSDL приняла меры (и не удивительно, коли в ней работают два основных разработчика ядра) и выступила с Сертификатом Разработчика о Происхождении. Он состоит из нескольких параграфов, снабженных цифровой подписью, чтобы корректно описать ваш
вклад в древо исходного кода ядра.
*Проект Patent Commons
Законодательство о патентах на ПО изменило лицо разработки приложений в США и вызвало резонанс в остальном мире. Это еще одна угроза будущему разработки приложений с открытым кодом. Проект был создан в августе 2005 г. после внезапного ливня патентов, пожертвованных сообществу Open Source крупными организациями вроде Sun Microsystems, IBM и Nokia. Проект, как и другие инициативы OSDL, разработан для того, чтобы играть роль центра и способствовать использованию открытых патентов на законных основаниях.

LXF85:Java

2008-03-13T09:28:03Z

Skryabin yuri: Содержание

=== Считалочки ===
''ЧАСТЬ 2: Мало сыграть свадьбу – надо еще научиться вести семейный бюджет, выполнять одну и ту же работу каждый день и принимать судьбоносные решения. '''Антон Черноусов''' продолжает учить монархическую чету премудростям Java.''

В предыдущей статье были рассмотрены основы объектно-ориентированного языка программирования Java: инкапсуляция,
наследование, полиморфизм. Мы создали простое приложение, в котором женили короля на царевне Несмеяне.

Сегодня мы поговорим о простых типах (числах), о ветвлениях, циклах, а также об исключениях.
=== Простые числа и их братья ===
Итак, мы оставили нашу царевну Несмеяну в семейном гнезде, где она в скором времени добралась до казны государства. Ей пришлось
освоить нехитрую математику – отнимать и делить: ведь казна требует строго учета, и никакая программа не обходится без вычислений. Без них невозможно создать даже самую простую систему учета и контроля, а мадам необходимо наладить нетривиальный учет бюджетных средств.

Для реализации арифметических операций в Java существует семь арифметических операторов, которые работают с любыми числовыми типами: сложение +, вычитание –, умножение *, деление /, остаток %, унарный минус -val и унарный плюс +val, а также шесть примитивных типов переменных для выполнения арифметических операций:
{| border = "1" cellpadding="2"
!Тип переменной
!Разрядность
!Описание
|-
|Byte||align="center"|8||Целое со знаком
|-
|Short||align="center"|16||Целое со знаком
|-
|Int||align="center"|32||Целое со знаком
|-
|Long||align="center"|64||Целое со знаком
|-
|Float||align="center"|32||Число с плавающей точкой
|-
|Double||align="center"|64||Число с плавающей точкой
|}

Значение типов byte и short при выполнении вычислений переопределяется int, поэтому использование этих типов целесообразно для
хранения небольших значений для уменьшения объема используемой оперативной памяти.
<source lang = "java">
int iA = 10;
byte bB = 12;
int iC = iA + bB;
System.out.println("Сумма А и B = " + iC);
</source>
Выше приведен пример выполнения арифметической операции с использованием переменных различных типов. Результат – целое число типа int. Для преобразования типа переменной, например, в тип с более низкой разрядностью, необходимо воспользоваться специальными языковыми конструкциями:
<source lang = "java">
double dD = 10.2;
double dE = 12.23;
float fF = (float) (dD + dE);
System.out.println(fF);
</source>

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

Для представления логических значений в Java присутствует простой тип boolean, который принимает значения true или false. Для проведения различных логических операций можно использовать ниже перечисленные операторы:

{| border = "1" cellpadding="2"
!Тип операторов
!Операторы
|-
|операторы отношений
|align = "center"| <     >     >=     <=     instanceof
|-
|операторы равенства||align = "center"|==     !=
|-
|поразрядное И||align = "center"|&
|-
|поразрядное исключающее ИЛИ||align = "center"|^
|-
|поразрядное включающее ИЛИ||align = "center"|ǀ
|-
|логическое И||align = "center"|&&
|-
|логическое ИЛИ||align = "center"|ǁ
|}

Пока Несмеяна разбирается в дебрях налогового кодекса, мы для иллюстрации работы с логическими выражениями обратимся к методу
primeNumberCheckUp(int numberForCheck), который выясняет, является ли переданное ему число простым.
<source lang = "java">
private boolean primeNumberCheckUp(int numberForCheck) {
boolean result = true;
if (numberForCheck != 1 || numberForCheck != 2 || numberForCheck != 3) {
for (int currentNumber = 2; currentNumber < numberForCheck; currentNumber++) {
if (numberForCheck % currentNumber == 0) {
result = false;
}
}
}
return result;
}
</source>
В primeNumberCheckUp использованы две замечательные конструкции: оператор выбора по условию или условный оператор, и цикл.
Условный оператор if имеет следующий синтаксис:
<source lang = "java">
if (логическое выражение) {
операторы группы 1;
}
else {
операторы группы 2;
}
</source>

В вышеописанном методе использована упрощенная конструкция (без else), а для вычисления логического выражения использованы
операторы: != (не равно) и || (логическое «или»). В полной конструкции в случае истинности логического выражения выполняются операторы группы 1, иначе – группы 2.

Вместо if для управления выполнением кода может быть использована специальная конструкция switch. В рамках этой конструкции
вычисляется целочисленное выражение, и в соответствии с полученным результатом ведется поиск соответствующего значения блока
case.
<source lang = "java">
int flag = 6;
switch (flag) {
case 1: {
System.out.println("Царевна в спальне №1");
break;
}
case 5: {
System.out.println("Царевна в спальне №5");
break;
}
default: {
System.out.println("Кто тут знает, где царевна?");
break;
}
}
</source>
Обратите внимание на оператор break, который обеспечивает немедленный выход из любого блока, а в примере выше прекращает дальнейшую обработку операторов конструкции switch, а также на блок операторов default – этот блок необязательный, он выполняется в случае, если выражение, удовлетворяющие условию, не было найдено среди case.

=== Циклы ===
Разобравшись, как все устроено в королевстве, Несмеяна поняла, что все подчиняется принципу «Украл, выпил, в тюрьму» – точнее, во Дворец до следующего месяца. По кругу.

Для реализации «кругового» процесса в Java существует три вида циклов: for, while и do-while. С циклом for мы уже вы встречались в методе primeNumberCheckUp, продемонстрированном ранее, синтаксис этой конструкции следующий:
<source lang = "java">
for (инициализация; логическое выражение; приращение) {
операторы;
}
</source>
В рамках инициализации производится объявление и установка значений временных переменных. Цикл выполняется до тех пор, пока
логическое выражение истинно. На каждой итерации цикла производится приращение временных переменных.

Две другие конструкции циклов можно назвать однояйцевыми близнецами, если бы не маленькое отличие в их использовании. При
использования цикла while проверка условия осуществляется до выполнения блока операторов, а в конструкции do-while – после него, то есть действия внутри цикла отрабатывают хотя бы раз. Например, процесс одиночной попойки короля от счастья, что он женат, на языке Java можно описать так:
<source lang = "java">
int i = 100;
while (i > 0) {
System.out.println(i + " бутылок пива стояло на столе, одну уговорил");
i--;
}
System.out.println("Все выпил, да!");
int tankard = 1;
int allTankards = 10;
do {
System.out.println(tankard + " стакан помыт");
tankard++;
}
while (tankard <= allTankards);
System.out.println("Ну вот и все стаканы помыл");
</source>

=== Массивы ===
Для организации хранения однотипных данных в Java можно использовать массивы. Массивом называется структура данных, которая
позволяет хранить несколько значений в одной переменной (определение расплывчатое, но суть передает верно). Объявить массив можно несколькими способами, но я предпочитаю следующий как наиболее логичный:
<source lang = "java">
int[] arrayName = new int[length]
</source>
При этом int – это тип переменных массива, а length – его размерность (число элементов). После того, как массив создан,
значения всех переменных равны null.

Многомерный массив – это обыкновенный массив, элементами которого являются массивы, причем совсем не требуется, чтобы они
имели одинаковую размерность, например:
<source lang = "java">
int[][] arrayName = new int[2][];
arrayName[0] = new int[5];
arrayName[1] = new int[2];
</source>
В некоторых задачах требуется создать массив, состоящий из произвольных чисел. Генерация произвольных чисел возможна благодаря
классу Random, который входит в пакет java.util. К слову, пакеты – это иерархически именованные контейнеры, применяемые для изолирования имен классов в некотором пространстве имен, то есть пакеты применяются во избежание конфликтов с именами классов.

Подключение класса Random к программе происходит при использовании зарезервированного слова import и команды import java.util.Random; традиционно объявляемой в начале файла, содержащего разрабатываемый класс.
<source lang = "java">
import java.util.Random;
public class RandomGenerator {
private static Random random = new Random();
private int base;
public RandomGenerator(int base) {
this.base = base;
};
public RandomGenerator() {
this.base = Math.abs(random.nextInt());
};
public int getInt(){
return Math.abs(random.nextInt(this.base));
};
}
</source>
Далее, приведенный код позволяет сгенерировать массив псевдослучайных чисел с использованием класса RandomGenerator, код
которого приведен выше:
<source lang = "java">
int[] newArray = new int[100];
RandomGenerator currentRG = new RandomGenerator(500);
for (int currentNumber = 0; currentNumber < 100; currentNumber++) {
newArray[currentNumber] = currentRG.getInt();
System.out.println("newArray[" + currentNumber + "] = " + newArray[currentNumber]);
}
</source>
Иногда невозможно установить точное количество элементов в массиве, в таком случае на помощь приходят динамические массивы ArrayList. ArrayList – это класс, который входит в Collection API. Объекты, созданные на основе ArrayList, более ресурсоемки. Давайте посмотрим на работу динамических массивов на примере задачи по поиску всех простых чисел в диапазоне от 1 до N:
<source lang = "java">
private Integer[] getAllPrimeNumbers (int numberForCheck){
ArrayList primeNumbers = new ArrayList();
for (int currentNumber = 1; currentNumber <= numberForCheck; currentNumber++) {
if (this.primeNumberCheckUp(currentNumber)) {
primeNumbers.add(currentNumber);
}
}
Integer[] result = (Integer[]) primeNumbers.toArray(new Integer[0]);
return result;
}

public int[] getIntArray(){
Integer[] arrayOfPrimeNumbers = (Integer[]) GetAllPrimeNumder(this.number);
int[] result = new int[arrayOfPrimeNumbers.length];
for (int currentNumber = 0; currentNumber<resault.length; currentNumber++){
result[currentNumber] = arrayOfPrimeNumbers[currentNumber].intValue();
}
return resault;
};

public Integer[] getIntegerArray(){
return this.GetAllPrimeNumder(this.number);
};
</source>
В getAllPrimeNumder формируется динамический массив primeNumbers – объект класса ArrayList (для его использования необходимо подключить пакет java.util.ArrayList). Добавление нового объекта в динамический массив производится методом add(Object). После того, как динамический массив сформирован, из него извлекается простой массив методом toArray(Object[]). Обратите внимание, что из ArrayList извлекается массив объектов типа Integer, несмотря на то, что в него помещаются переменные типа int. Для получения массива состоящего из переменных типа int используется метод getIntArray().

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

Для логического завершения работы с простыми числами включим ранее описанные методы (primeNumberCheckUp, getAllPrimeNumder,
getIntArray(), getIntegerArray()) в представленный далее класс ArrayOfPrimeNumbers.
<source lang = "java">
import java.util.ArrayList;
public class ArrayOfPrimeNumbers {
private int number;

public ArrayOfPrimeNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
</source>
Класс, в зависимости от вызываемого метода, возвращает массив, состоящий из элементов int или Integer.

=== Куча хлама ===
Вернемся к нашей Несмеяне. Так как королевство ей досталось, прямо скажем, маленькое, пришлось ей еще и за порядком следить, что значит знать, где и что. Здесь ей помог HashMap – такая интересная структура для хранения данных, класс который входит в '''java.util.''' Экземпляры класса HashMap позволяют хранить различные именованные объекты, которые хранятся в виде пар «ключ – значение». Снаружи объекта типа HashMap нельзя узнать (как в хорошем бардаке), что же там лежит, однако, зная ключ, можно получить то, что ищешь, ну а если ключ неизвестен, то необходимо начать разбирать бардак до тех пор, пока не будет найдено то, что требуется. HashMap часто используется для хранения параметров системы. Как царевна разбирала бардак
мужа с помощью HashMap, можно посмотреть ниже.
<source lang = "java">
HashMap sameHeap = new HashMap();
sameHeap.put("Key1", "Левый носок");
sameHeap.put("Key2", "Грязная футболка");
sameHeap.put("Key3", "Правый носок");
String sameObj = (String) sameHeap.get("Key1");
System.out.println("Key1 = " + sameObj);
Map.Entry entry = null;
Iterator it = sameHeap.entrySet().iterator();
while (it.hasNext()) {
entry = (Map.Entry) it.next();
System.out.println("For key = " + entry.getKey() + " value = " + entry.getValue());
}
</source>
Для компиляции понадобится подключить java.util.HashMap, java.util.Iterator, java.util.Map – это можно сделать с помощью всего одной строкой вместо трех – import java.util.*;.

Как вы можете убедиться, для помещения объекта в HashMap необходимо использовать метод put, где первым параметром будет ключ, а
вторым – ассоциируемый с ним объект. Извлечение объекта возможно с помощью метода get при передаче ключа или с помощью последовательного перебора записей в HashMap.

После выполнения кода вы можете увидеть, что элементы в куче лежат не в том порядке, в котором вы их туда кинули (как в жизни, и не только короля). Порядок элементов в коллекции также может меняться во времени. HashMap обеспечивает постоянное время доступа для операций put и get. Как для ключей, так и для элементов допускаются значения типа null.

=== Пятый угол ===
В хорошо написанной программе, как и в сказочном королевстве, все должно идти своим чередом, но непредвиденные ситуации все равно бывают, так как программа соприкасается с внешним миром (другими программами, файлами, пользователями). Для решения непредвиденных ситуаций в Java существуют исключения и специальные операторы позволяющие отловить и обработать их.
<source lang = "java">
try{
// небезопасный код
} catch(Exception e) {
// обработка исключительной ситуации
} finally {
// гарантированно выполняющийся блок
}
</source>
Выше представлена структура, с помощью которой производится обработка исключительных ситуаций: в блоке try производятся
потенциально опасные операции, а в блоке catch производится обработка возникшего исключения (блоков catch может быть несколько). Под блоком подразумевается последовательность операторов, объявлений локальных классов или локальных переменных, заключенных в фигурные скобки. Область видимости локальных переменных и классов ограничена блоком, в котором они определены.

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

Исключительная ситуация может быть сгенерирована виртуальной машиной Java, а также программистом. Исключение "выбрасывается"
с помощью оператора throw.
<source lang = "java">
public float calculate(int sameA, int sameB) throws Exception {
float result;
if (sameB != 0) {
result = sameA / sameB;
} else
throw new Exception("Параметр для вычисления не должен быть равным нулю");
return result;
}
</source>
Предложенный метод обеспечивает деление, а так как Царевна и король никогда не делят на ноль, они все делят поровну, то с помощью оператора throw порождается исключение в случае неправильно введенных данных. Это исключение можно «отловить» с помощью catch по месту использования метода.

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

LXF84:Java

2008-03-13T09:26:20Z

Skryabin yuri: Содержание

=== Сказка Java ===
''ЧАСТЬ 1: От кофеварок до промышленных серверов и биллинговых систем - Java можно встретить буквально везде. Начните изучение этой технологии вместе с '''Антоном Черноусовым'''.''

Начиная ряд статей о программировании на объектно-ориентированном языке Java, хотел бы выразить свое мнение относительно корпоративного рынка разработки программного обеспечения, на котором в данный момент борются за лидерство два гиганта, две платформы: J2EE и .NET.

В основе платформы J2EE лежит язык программирования Java – приложения, созданные с его помощью, являются кроссплатформенными, сам язык, средства разработки и технология активно поддерживаются многими корпорациями: Sun, Google, IBM, Oracle, BEA. Платформа пользуется большой популярностью и среди компаний, ориентированных на OpenSource, таких как Apache Foundation. В противовес J2EE, корпорация Microsoft предлагает свою технологию .NET, которая является колоссом, построенным на мощи программного обеспечения Microsoft.

Сегодня еще нельзя сказать, какая технология станет доминирующей, и, возможно, от вас зависит скорость распространения современной кроссплатформенной технологии создания приложений J2EE и языка программирования Java.

Предложенные вашему вниманию уроки позволят овладеть основными понятиями ООЯ Java и создавать различные приложения с его помощью. Рассмотрев основы языка, мы сможем изучить типовые решения (паттерны) в программировании и приступить к изучению J2EE.
В первом уроке мы создадим свое первое приложение и разберемся с основными понятиями: инкапсуляция, наследование и полиморфизм. Для выполнения этого урока нам понадобится пакет Java SDK 1.5, текстовый редактор и немного терпения.
=== Героический объект ===
Приступая к этой серии материалов, я вспомнил, что, как правило, изучение языков программирования начинается с написания приложения "Hello World!", но такой прием настолько изъезжен, что я намереваюсь предложить пример поинтереснее: мы напишем приложение, рассказывающее сказку. Основа приложения – два класса. Каждый класс содержит члены двух видов: атрибуты и методы. Атрибуты – это данные, принадлежащие самому классу. Совокупное значение атрибутов определяет состояние объекта или класса. Метод – это последовательность операторов, изменяющих значения атрибутов и, как следствие, состояние класса или объекта.

В каждой интересной сказке должен быть свой герой. Предлагаю взглянуть на класс, который реализует нашего героя. Итак, по порядку. Следующий код необходимо сохранить в файл '''FirstHero.java.'''
<source lang = "java">
public class FirstHero {
private String quest;
public FirstHero(String Quest) {
this.quest = Quest;
}
public void setQuest(String Quest){
this.quest = Quest;
};
public String getQuest(){
return quest;
};
}
</source>
Расположение одного класса в одном файле считается хорошим тоном среди программистов на Java – так что приучайтесь к нему сразу. Имя файла должно совпадать с названием класса, расширение у файла – '''.java.'''

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

Вы можете заметить, что первый метод (третья строка представленного ранее листинга) имеет то же название, что и класс – FirstHero. Такой метод называется конструктором. Конструктор – это метод, который используется при создании экземпляра класса для задания внутреннего состояния объекта, например:
<source lang = "java">
FirstHero ourNewHero = new FirstHero("Спасти царевну");
</source>
Единственный атрибут нашего класса quest имеет тип строка (String). Для установки значения атрибута quest используется метод
setQuest. Метод setQuest является public и не возвращает никакого значения. Для обозначения методов, не возвращающих значение, используется зарезервированное слово void. Для вызова метода setQuest необходим обязательный параметр: Quest типа String. Для получения значения атрибута quest используется метод getQuest, который вызывается без параметров, является открытым и возвращает значение типа String.

Вызов описанных выше методов для объекта ourNewHero осуществляется следующим образом:
<source lang = "java">
ourNewHero.getQuest();
ourNewHero.setQuest("какая-то строка");
</source>
Парные методы, различающиеся приставками set и get, принято создавать для работы с закрытыми атрибутами. Это обязательное
условие для реализации объекта в виде JavaBean. Что такое JavaBean, мы обсудим позже – сейчас запомните, что такое наименование методов позволяет избавиться от ряда проблем в больших системах.

Приступим к написанию самой сказки. Возьмите следующий код и поместите его в файл '''Story.java'''.

<source lang = "java">
public class Story {
public static void main(String[] args) {
FirstHero ourNewHero = new FirstHero("Спасти царевну ");
System.out.println(“Наш герой хочет отправиться в путь и “ + ourNewHero.getQuest());
}
}
</source>

Это класс Story, он имеет всего один метод main, который является статичным (static-методы и переменные принято называть переменными класса и методами класса, т.к. они общие для всех объектов) и используется для работы с классом в целом. Метод main – это стартовая точка для запуска программы, с которой начинается интерпретация кода.

В ходе интерпретации метода main создается новый объект ourNewHero, а также вызывается метод println объекта out, который обеспечивает вывод в стандартный выходной поток строковойпеременной.

Откомпилируем код и увидим, что у нас получилось. Для компиляции переместитесь в каталог, где вы разместили свои файлы и выполните следующую команду:
<source lang = "java">
# javac *.java
</source>
При желании вы можете откомпилировать классы по отдельности, следующим образом:
<source lang = "java">
# javac Story.java
# javac FirstHero.java
</source>
В итоге вы получите два файла '''Story.class''' и '''FirstHero.class'''. Теперь посмотрим на результат:
<source lang = "java">
# java Story
Наш герой хочет отправиться в квест и Спасти царевну
</source>

Первая программа на Java готова и работает! Вы создали два класса и научились выводить информацию в консоль. Но мы забыли о
комментариях...

Комментарии бывают нескольких типов:
*Строчные начинаются с символа // и длятся до окончания строки.
*Многострочные комментарии заключаются между /* и */.
*Комментарии JavaDoc – это многострочные комментарии, заключенные между /** и */, например:

<source lang = "java">
/**
* Класс является прототипом объекта "герой"
* @author Chernousov Anton
* @version 0.1
*/
public class FirstHero {
…
/**
* Метод предназначен для установки внутренней переменной
quest
* в значение Quest.
* У этого метода один параметр
* @param Quest это переменная означает задание для Героя
*/
public void setQuest(String Quest)
…
</source>

Комментарии JavaDoc предназначены для формирования документации к проекту из исходных кодов. Если добавить в файл '''FirstHero.java''' только что приведенные строки, то с помощью команды '''javadoc -author -version *.java''' можно сформировать документацию к нашему проекту.

JavaDoc позволяет создавать подробную документацию, которая просто необходима для любого достаточно крупного проекта.
=== Наследование, интерфейсы и их реализация ===
Наша сказка написана, но что делать, если проект большой и над ним работает много людей? Как реализовать одновременное программирование разных классов так, чтобы результаты, полученные отдельными разработчиками, можно было без труда соединить в единое целое? Для решения этой задачи, а также задачи множественного наследования в Java существуют интерфейсы – interface. Но обо всем по порядку.

Наследование – это одна из парадигм программирования, которая связана с инкапсуляцией. Суть наследования заключается в следующем: если есть класс, инкапсулирующий в себе некоторые атрибуты и методы, то класс, наследующий его, автоматически наследует все его атрибуты и методы.
<source lang = "java">
public class SecondHero extends FirstHero{
public SecondHero(String Quest) {
super(Quest + " Несмеяну");
}
}
</source>
Расположенный выше код объявляет класс SecondHero, который с помощью зарезервированного слова extends наследует (расширяет) класс FirstHero. В Java класс может наследовать (расширять)только один класс. При наследовании класса FirstHero, содержащего
конструктор, обязательно требуется переопределить его (например, как это делается в методе SecondHero). При выполнении оператора super(Quest) будет вызван аналогичный метод из суперкласса (класс-родителя). Строкой super(Quest + “Несмеяну”) мы переопределяем поведение конструктора. Естественно, класс SecondHero может содержать новые атрибуты и методы.

Для проверки механизма наследования сохраните приведенный текст класса SecondHero в файл '''SecondHero.java''' и в файле '''Story.java''' измените имя класса FirstHero на SecondHero. Откомпилируйте и запустите программу, в результате вы должны увидеть следующее:
<source lang = "java">
# java Story
Наш герой хочет отправиться в путь и Спасти царевну Несмеяну
</source>
При разработке программы, перед тем, как приступить к программированию, сначала проводится процесс проектирования (например, через UML-нотации). В результате проектирования появляется документация к проекту, а также спецификации классов. Интерфейс – это явно указанная спецификация набора методов, которые должны быть представлены в классе, реализующий эту спецификацию. В серьезном проекте на момент начала программирования перед программистом оказываются интерфейсы, которые он должен реализовать в классах.

Интерфейс в Java – это специальный класс, в котором отсутствует реализация! Давайте напишем интерфейс для нашего класса FirstHero. Следует скопировать следующий далее код и поместить его в файл '''Hero.java''' – именно этот интерфейс мы будет использован далее. Как вы видите, в отличие от других классов, интерфейс объявляется с помощью зарезервированного слова interface. В нашем случае интерфейс представляет собой следующий набор методов:
<source lang = "java">
public interface Hero {
public void setQuest(String Quest);
public String getQuest();
}
</source>
Чтобы класс FirstHero реализовывал интерфейс Hero, необходимо изменить первую строчку в файле '''FirstHero.java''' на public class FirstHero implements Hero {. Интерфейс может наследовать (расширять) множество других интерфейсов. Наример:
<source lang = "java">
public interface Lord {
public String sendToQuest();
public void setBodyguard(Hero hisHero);
public Hero getBodyguard();
}

public interface King extends Hero, Lord{
public void setWife (String PrincesName);
public String getWife();
}
</source>
Класс может одновременно наследовать класс и реализовывать один или несколько интерфейсов. Например, как в классе LandLord,
который наследует класс FirstHero и реализует интерфейс Lord:
<source lang = "java">
public class LandLord extends FirstHero implements Lord{
private Hero bodyguard;
public LandLord(String Quest, Hero hisHero) {
super(Quest);
this.bodyguard = hisHero;
}
public String sendToQuest() {
bodyguard.setQuest(this.getQuest());
return null;
}
public void setBodyguard(Hero hisHero) {
this.bodyguard = hisHero;
}
public Hero getBodyguard() {
return bodyguard;
}
}
</source>
Чтобы окончательно закрыть тему наследования, необходимо поговорить про абстрактные классы – те, что занимают промежуточное
место между интерфейсами и реальными классами. Объявление абстрактного класса или метода выполняется с помощью специального
слова abstract:
<source lang = "java">
abstract public class Knight
</source>
Абстрактный класс представляет собой неполную реализацию всех объявленных методов, и его можно наследовать, как и любой из классов. Обязательным условием при наследовании является полная реализация абстрактных методов.

=== Полиморфизм ===
Полиморфизм – это концепция, реализованная в Java, которая позволяет одному и тому же объекту выступать в разных формах. Например, экземпляр класс LandLord можно использовать как объект класса FirstHero. Это стало возможным благодаря тому, что класс LandLord наследует класса FirstHero.

=== Перегруженные методы ===
Иногда при создании сложных (и не очень) систем есть необходимость реализовать два различных метода, названых одинаково – это возможно с помощью перегруженных (overloading) методов. Выбор реализации зависит от типа объектов, переданных в качестве параметров.
<source lang = "java">
public class GreatKing extends LandLord implements King{
private String wife;
private boolean theftedWife;

public GreatKing(String Quest, Hero hisHero) {
super(Quest, hisHero);
}

public void setWife(String PrincesName) {
this.wife = PrincesName;
this.theftedWife = false;
}

public String getWife() {
if (theftedWife){return null;}
else{ return wife;}
}

public String getWife(boolean flag) {
if (flag){ this.theftedWife = true;}
return wife;
}
}
</source>
В представленном классе GreatKing существуют две реализации перезагруженного метода getWife, которые можно вызвать следующим образом:
<source lang = "java">
GreatKing ourKing = new GreatKing("Править мудро", (Hero) new FirstHero("Охранять господина"));
String hisWife = ourKing.getWife();
String theftedHisWife = ourKing.getWife(true);
</source>

=== Вместо заключения ===
Ну вот, мы создали всех героев. Разместите интерфейсы Lord, King, а также классы LandLord и GreatKing в соответствующих файлах.
Немного измените класс Story, чтобы завершить сказку:
<source lang = "java">
public class Story {
public static void main(String[] args) {
// создадим наших героев
Hero ourNewHero = (Hero) new FirstHero("Спасити царевну");
GreatKing ourKing = new GreatKing("Править мудро", (Hero) new FirstHero("Охранять господина"));
LandLord ourNewLandLord = new LandLord("Похитить царевну", (Hero) new FirstHero("Охранять господина"));
// Женим нашего короля
ourKing.setWife("Несмеяна");
// И начнем повествование
System.out.println("Жил был мудрый король, и должен был он " + ourKing.getQuest());
System.out.println("Была у него жена, и звали ее " + ourKing.getWife());
System.out.println("Был в королевстве коварный Визирь и хотел он " + ourNewLandLord.getQuest());
System.out.println("И сделал это");
String wife = ourKing.getWife(true);
//
System.out.println("А наш герой жаждал " + ourNewHero.getQuest() + " ..и добился этого");
ourKing.setWife(wife);
System.out.println("Король был счастлив.");
System.out.println("Ну а что случилось дальше вы можете придумать сами...");
}
}
</source>
Откомпилируйте и насладитесь результатом выполнения урока.

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

LXF86:Java

2008-03-13T09:21:48Z

Skryabin yuri: Начало, содержание

LXF86:Java

2008-03-13T09:03:16Z

Skryabin yuri: Начало, содержание

== Хранение данных ==
''ЧАСТЬ 3: Даже самой замечательной программе надо откуда-то черпать данные для своей работы. Данные, как известно, хранятся в файлах. Тему продолжает '''Антон Черноусов'''.''

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

В течение третьего урока мы поговорим о работе с файлами, о протоколировании работы программы и коснемся методов работы с
XML-данными.

=== Файлы — потоки ===

=== Чтение данных ===

=== Запись данных ===

=== Свободный доступ ===

=== Протоколирование работы программы ===

=== Документы XML ===

=== Создание XML-документа ===

=== Сохранение XML-документа ===

=== Загрузка XML-документа ===

=== Извлечение данных из XML-документа ===