Lecture05

Технологии программирования. Компонентный подход
В. В. Кулямин
Лекция 5. Язык программирования Java и технологии Java.
После разработки архитектуры можно переходить к разработке отдельных
компонентов будущей системы.
Одним из наиболее распространенных подходов к созданию систем, решающих
бизнес-задачи общего характера (хранение и обработка данных о клиентах, заказах,
поставщиках, имеющихся на складе товарах, поставках и пр), является компонентная
разработка. В рамках этого подхода система строится на основе набора компонентов,
каждый из которых решает некоторую небольшую бизнес-задачу, и каркаса, основной
задачей которого является поддержка жизненного цикла компонентов и взаимодействий
между ними. Наиболее известными каркасами и технологиями для построения сложных
компонентных систем на сегодняшний момент являются платформы Java Enterprise
Edition и .NET. В рамках данного курса мы рассмотрим первую из них.
Технологии Java представляют собой набор стандартов, интерфейсов, инструментов и
библиотек, предназначенных для разработки приложений разных типов и связанных друг
с другом использованием языка программирования Java и принципом обеспечения
независимости разработки от конкретных реализаций инструментов и библиотек,
удовлетворяющих этим стандартам.
В этот набор входят следующие основные элементы.
 Платформа Java Platform, Standard Edition (J2SE).
Предназначена для разработки обычных однопользовательских приложений.
 Платформа Java Platform, Enterprise Edition (J2EE).
Предназначена для разработки распределенных приложений уровня предприятия.
 Платформа Java Platform, Micro Edition (J2ME).
Предназначена для разработки встроенных приложений, работающих на ограниченных
ресурсах.
 Платформа Java Card.
Предназначена для разработки ПО, управляющего функционированием цифровых карт.
В рамках данного курса будут рассмотрены основные элементы платформы J2EE, а
также элементы J2SE, на которых базируются первые.
Основные элементы языка Java
Язык Java является объектно-ориентированным языком со строгой типизацией,
поддержкой обработки исключений и разработки многопоточных программ.
30 сентября 2004 года вышла версия платформы J2SE, основанная на языке Java 5.
Основные элементы языка Java в версии 5 следующие.
 Код компонентов Java программы хранится в файлах с расширением .java (имя такого
файла без расширения совпадает с именем единственного общедоступного класса,
декларированного в нем). При компиляции программы для каждого класса или
интерфейса строится .class файл, содержащий его байт-код — код в командах
виртуальной машины Java.
Файлы с исходным кодом и файлы с байт-кодом должны располагаться в
поддиректориях некоторых корневых директорий в соответствии с именами их пакетов.
Набор имен корневых директорий для поиска в них Java-кода перечисляется в опции
компилятора -sourcepath, набор имен корневых директорий для поиска в них байт-кода
перечисляется в опции компилятора и Java-машины -classpath.
Пример: Java-код класс ru.msu.cmc.prtech.examples.ClassA должен лежать в
поддиректории ru/msu/cmc/prtech/examples некоторой директории, упомянутой в
sourcepath, в файле ClassA.java. Его байт-код должен находиться в файле
ClassA.class поддиректории с тем же именем одной из директорий, упомянутых в
classpath.
Кроме имен корневых директорий, опция classpath может содержать имена архивных
JAR-файлов, каждый из которых содержит упакованный с сохранением структуры
пакетов набор class-файлов классов. Программа, исполняемая Java машиной,
запущенной с указанием такого архива в classpath может использовать классы, байткод которых содержится в этом архиве.
При работе Java программы виртуальная машина выполняет метод public static void
main(String[]) указанного при ее запуске класса, подгружая при необходимости код
других классов из директорий или архивов, перечисленных в classpath.
 Программы разрабатываются как набор взаимодействующих объектов-потоков,
использующих другие объекты и значения в качестве данных. Объявления типов
объектов и других данных помещаются в структурированную систему пакетов,
играющих роль пространств имен (имена пакетов образуются из нескольких
идентификаторов, разделяемых точкой, типы пакета можно использовать, добавляя к их
собственным именам в качестве префикса имя пакета с точкой на конце, использовать
тип в рамка файла с помощью его короткого имени можно, декларировав его как
импортируемый в самом начале файла, можно также импортировать все типы заданного
пакета). Типы данных бывают следующие.
o Примитивные типы. Это базовые, встроенные в язык, типы простых данных,
которые являются значениями, а не объектами, не имея собственной идентичности
(т.е два равных значения такого типа не различимы). Все примитивные типы
имеют классы-обертки, с помощью которых их значения можно представлять в
виде объектов. Примитивные типы включают

для данных логического типа. Обертка — java.lang.Boolean.
Константы этого типа — true и false.
Для таких данных определены операции
boolean
== , !=, !, &&, ||, &, |, ^
проверки равенства и неравенства, отрицание, короткие конъюнкция и
дизъюнкция, длинные конъюнкция и дизъюнкция, исключающее или.

char

Целочисленные типы
byte для значений [-128..127]. Обертка — java.lang.Byte.
short для значений [-32768..32767]. Обертка — java.lang.Short.
int для значений [-231..231-1]. Обертка — java.lang.Integer.
long для значений [-263..263-1]. Константы этого типа помечаются
суффиксом l или L — 9223372036854775808L. Обертка — java.lang.Long.
Для них определены операции
для данных символьного типа. Обертка — java.lang.Character.
Используются символы в кодировке Unicode, on '\u0000' до '\uffff'.
Константы этого типа — '<символ>', '\<n, t, b, r, f, \, ', ''>', '\<одна-две-три
восьмеричные цифры>', '\u<четыре шестнадцатеричных цифры>'.
Определены те же операции, что и для целочисленных данных.
==, !=, <, <=, >, >=, +, -, *, /, %, ++, --, <<, >>, >>>, ~, &,
|, ^
<< — побитовый сдвиг влево
>> — побитовый сдвиг вправо, с учетом знакового бита
>>> — побитовый сдвиг вправо, без учета знакового бита
~, &, |, ^ — побитовые операции дополнения, конъюнкции,
дизъюнкции
и исключающего или

Типы данных с плавающей точкой.
float и double для типов данных с плавающей точкой, соответствующих
стандарту IEEE 754-1985 в 32-х и 64-хбитном представлении.
Соответствующие классы-обертки — java.lang.Float и
java.lang.Double.
Константы этих типов — 0.0, -213.568e-6f. Константы типа float
помечаются суффиксом f или F, константы типа double могут быть
непочены или помечены суффиксом d или D.
Такие числа представляются в виде набора битов длины 32 или 64,
делящегося на знаковый бит s, экспоненту e (8 или 11 бит) и мантиссу m (23
или 52 бита). Итоговое число вычисляется как (+/-)m*2(e-N+1), где N — 24
или 53, соответственно (m вычисляется некоторым образом по своему
битовому представлению).
Значения float 0x7f800000 и 0xff800000, и double 0x7ff0000000000000 и
0xfff0000000000000 представляют положительную и отрицательную
бесконечности (Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY,
Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY). Все значения, у
которых экспонента больше указанных или равна им, но мантисса отлична
от 0, представляют специальное значение NaN — Not a Number (Float.NaN,
Double.NaN).
Значения этих типов упорядочены, кроме NaN. Любая операции сравнения,
кроме !=, с одним из аргументов NaN возвращает false (!= возвращает
всегда true). Поэтому, для проверки равенства числа NaN надо
пользоваться специальными операциями Float.isNaN(float),
Double.isNaN(double). Кроме того, отдельные (!) значения -0.0 и 0.0
считаются равными.
Определены операции
==, !=, <, <=, >, >=, +, -, *, /, %, ++, --
Операции соответствуют требованиям стандарта IEEE 754-1985, кроме %.
Это, в частности, означает, что если один из аргументов операции NaN, то
результат ее тоже NaN. Кроме того, действуют достаточно естественные
правила: 1/0.0 = +, -1/0.0 = -, 0/0.0 = NaN, -+1 = -, +*1 = +, +- =
NaN, +/- = NaN, и пр. — операции дают бесконечные результаты и
обрабатывают бесконечные аргументы в соответствии с их математическим
смыслом, NaN возникает при неопределенностях.
Операция % действует не в соответствии со стандартом IEEE 754-1985—
если b != 0, +/-, NaN, то выполнено тождество (a/b)*b + (a%b) == a
o Классы и интерфейсы.
Представляют собой объявления типов объектов, чаще всего имеющих операции
(методы). Объекты классов моугт иметь внутренние данные (описываемые в
классе как поля). Интерфейсы содержат набор деклараций констант (final
static полей) и методов, без реализаций последних. Неабстракные классы
определяют реализации для всех своих методов. Абстракные (abstract) классы
могут не определять реализации для некоторых методов, задавая только их
декларации. Объекты, принадлежащие непосредственно к интерфейсу или
абстрактному классу, нельзя создать — в программе можно создавать лишь
объекты неабстракных классов, реализующих данный интефрейс или
наследующих данному абстрактному классу.
Классы могут наследовать друг другу, переопределяя методы (но не поля, которые
можно только перекрыть, использовав их имена в наследниках — по такому
имени становится доступно поле наследника, а поле предка становится недоступно
напрямую). Класс может наследовать только одному классу и реализовывать
несколько интерфейсов. Метод, определенный в классе-наследнике всегда
переопределяет метод с той же сигнатурой в классе-предке.
Сигнатура метода включает его имя и типы параметров. В Java 5 появились
методы с неопределенным числом параметров — последний параметр может быть
декларирован как <тип>… <имя> и при конкретных вызовах передаваться как в
виде массива данных этого типа, так и в виде последовательности таких данных.
При переопределении метода требуется соблюдать следующие правила: помимо
такой же сигнатуры, переопределяющий метод должен иметь не больший список
возможных исключений (убирать исключения из списка можно) и (в Java 5) тип
его результата должен быть подтипом типа результата переопределяемого метода
(в версиях до Java 5 требовалось в точности сохранять тип результата).
Все эти требования являются синтакисческой поддержкой для принципа
подстановки Лисковой (Liskov substitution principle), утверждающего, что объект
класса-наследника в хорошо спроектированной системе должен быть в состоянии
использоваться без возникновения ошибок в любом месте, где может
использоваться объект класса-предка (это означает, в частности, что во всякой
ситуации, в которой можно вызвать некоторый метод предка, должно быть
возможно вызвать и соответствующий метод потомка, а также, что множество
ситуаций, в которых система может оказаться в результате работы метода потомка,
должно быть подмножеством ситуаций, возможных после работы метода предка).
Методы и поля могут быть статическими (static), что означает, что они
принадлежат не объектам, а самому классу. Такие методы не могут быть
переопределены, но могут быть перекрыты в классах-наследниках (т.е., вызывая
этот метод в классе, где он определен, мы всегда будем обращаться к нему, но
вызывая его в классах-наследниках, мы будем обращаться к нему же, если он не
перекрыт в этом наследнике, и к другому методу, если в классе-наследнике
определен статический метод с той же сигнатурой).
Методы и поля могут быть final, что для методов означает невозможность их
переопределения в потомках, а для полей — невозможность изменить значение,
присвоенное им в конце работы конструктора объекта, если поле не static, или
инициализации класса, если оно статическое. Класс может быть объявлен как final
— такой класс не может быть унаследован.
Декларации полей могут содержать инициализации их некоторыми значениями
соответсвующих типов. Поле (так же, как и локальная переменная) будет
инициализированы автоматически значением по умолчанию (для объектных типов
— null, для числовых — 0, для логического — true), даже если явной
инициализации у него нет — при этом использование значения
неициализированного поля или переменной считается ошибкой во время
компиляции.
Помимо этого, в классах и интефейсах могут объявляться константы (final
static поля) и вложенные типы — классы, интерфейсы, перечисления.
Вложенные классы могут быть статическими или нет (последние — довольно
запутанная конструкция, поскольку такой класс привязан к конкретному объекту
объемлющего класса и в своих методах может использовать ссылку на этот
объект).
Классы, интерфейсы, шаблоны, перечисления, методы, поля и конструкторы могут
иметь модификатор доступа — private, пустой, protected или public. В первом
случае соответствующий элемент доступен только внутри кода объемлющего
класса, во втором — всюду в объемлющем пакете, в третьем — в объемлющем
пакете и в наследниках объемлющего класса, в последнем — из любого места. При
этом классы и интерфейсы верхнего уровня (не вложенные в другие) могут быть
только public или без модификатора доступа, причем в файле с именем
<имя>.java должен быть декларирован ровно один public класс или интерфейс
верхнего уровня с именем <имя> (регистр существенен!).
Классы могут иметь инициализаторы — блоки кода в фигурных скобках,
расположенные непосредственно в рамках декларации класса и, возможно,
помеченные модификатором static. Статические инициализаторы выполняются
при загрузке класса в виртуальную машину, после инициализации статических
полей, в порядке их появления в теле класса. Нестатические инициализаторы
выполняются тоже в порядке их появления в теле класса при конструировании
объекта данного класса после выполнения конструкторов всех его классов-предков
и инициализации нестатических полей, но до выполнения тела конструктора
самого этого класса.
Методы, конструкторы и инициализаторы класса могут обращаться к методам,
конструкторам и полям его непосредственного предка, используя для этого
специальный идентификатор super. Обращение к полю в этом случае выглядит
как super.<имя поля предка>, к методу — super.<имя метода>(<аргументы>), к
конструктору (возможно только в конструкторах) — super(<аргументы
конструктора предка>)
o Массивы.
Представляют собой типы упорядоченных совокупностей данных определенного
типа. Каждый массив имеет определенную длину, задаваемую при его создании и
далее неизменяемую. Обратиться к ней можно как к специальному полю length в
объекте-массиве.
Массиву данных некоторого типа может быть присвоен объект- массив значений
его потипа.
o Шаблонные классы и интерфейсы. (Введены в Java 5).
Представляют собой классы и интерфейсы с типовыми параметрами.
o Перечисления. (Введены в Java 5).
Представляют собой классы специального вида, объявляющие несколько констант
данного класса и не имеющие конструкторов.
 Операторы Java ключают в себя, помимо обычного вычисления выражений, оператор
возврата значения return …, условный оператор if(…) … (возможно, продолжающийся
else …), оператор выбора switch(…), операторы циклов for(…; …; …), while(…) …, do …
while(…); (все они имеют синтаксис и смысл, аналогичный их смыслу в С++). Кроме
того, имеются операторы break и continue, которые могут сопровождаться именем
метки. Без метки они прекращают/продолжают работу непосредственно включающего
их цикла (а break также выводит управление из непосредственно включающего его
блока), с меткой — соответственно, цикла/блока, начало которого помечено этой
меткой.
Про операторы создания/проверки исключительных ситуаций и синхронизации потоков
см. далее.
 Выражения Java включают создание новых объектов при помощи оператора new <вызов
конструктора>. Создание массивов выглядит как new <тип элемента>[<длина>]. Кроме
того, используются инициализаторы массивов при декларации вида
<тип элемента>[] <имя> = new <тип элемента>[] { <список элементов через запятую>
};
Выражения Java могут использовать ссылку this (в рамках нестатических методов и
конструкторов) для указания на объект, в котором выполняется данный метод, super —
для указания на соответствующий объект класса-предка.
Кроме того, можно использовать выражение <имя класса>.class для получения ссылки
на объект, представляющий в виртуальной машине указанный класс.
Операция +, помимо обычного сложения числовых значений, обозначает также
конкатенацию строк, имеющих тип java.lang.String.
 Исключения.
Исключения могут быть только объектных типов, наследующих классу
java.lang.Throwable.
Создаются исключения при помощи оператора throw <выражение типа исключения>;
Проверка возникновения исключения и его обработка оформляются в виде оператора
try {…} catch(…) {…} finally {…}, в котором блоков catch может быть несколько для
разных типов исключений, блок finally может отсутствовать (как и блок catch, но не
оба сразу). Если блок finally есть, он выполняется после выполнения блока try (и, если
возникло исключение, после соответствующего обработчика catch) всегда.
При этом типы исключений, которые могут дойти не обработанными до границ тела
метода, должны декларироваться в заголовке метода, если эти типы проверяемы, т.е. не
наследуют классам java.lang.RuntimeException или java.lang.Error. Для
наследников этих двух типов декларация их в заголовке метода, способного создать
такие исключения, необязательна.
 Помимо поддержки обычных вычислений, Java имеет встроенные в язык конструкции
для разрабокти многопоточных программ.
Для определения участков синхронизации используется модификатор synchronized,
который может помечать метод (тогда работать в рамках этого метода в одном объекте,
или классе, если метод статический, одновременно может только один поток, все
остальные потоки приостанавливаются на входе в метод и ожидают, пока он не
освободится) или блок внутри тела метода, вместе с некоторым выражением
synchronized(<выражение>) {...} (в этом случае только один поток из множества
тех, где это выражение разрешается в один объект, может войти в данный блок).
Приведенная ниже программа на Java вычисляет факториал числа, вводимого в
качестве первого аргумента при ее запуске. Делает она это не вполне эффективным
способом, запуская много потоков — каждый поток умножает поле, хранящее
промежуточный результат, на число, заданное при его создании.
package ru.msu.cmc.prtech.examples;
import java.util.ArrayList;
public class Program
{
static long result = 1;
static int counter = 0;
public static void main (String[] args)
{
int n = 0;
switch(args.length)
{
case 0:
System.out.println("No arguments provided");
return;
default:
n = Integer.parseInt(args[0]);
break;
}
ArrayList<MyThread> threads = new ArrayList<MyThread>();
for(int i = 0; i < n; i++)
threads.add(new MyThread(i+1));
for(Thread t : threads)
t.start();
while(true)
{
if(counter >= n) break;
}
System.out.println("Final result = " + result);
}
static class MyThread extends Thread
{
long d = 1;
public MyThread(long d)
{
if(d != 0) this.d = d;
}
public void run()
{
synchronized(Program.class)
{
System.out.println("
thread " + d + " is working");
result *= d;
counter++;
System.out.println("
result = " + result);
}
}
}
}
Библиотеки
J2SE включает богатый набор библиотек, который достаточен для разработки
широкого диапазона приложений общего вида.
Сообщество Java-разработчиков ведет работу по выработке стандартных интерфейсов
компонентов для решения различных задач, и, по мере их готовности, соответствующие
библиотеки включаются в виде пакетов в J2SE и J2EE. На настоящий момент можно
отметить следующие бибилиотеки в составе J2SE.
 java.lang
Содержит базовые классы языка, а также вспомогательные математические библиотеки.
Классы этого пакета могут использоваться с короткими именами без импортирования.
o Object — является базовым типом для всех типов объектов Java машины.
Имеет следущие методы
boolean equals(Object) — сравнение объектов на равенство
int hashCode() — возвращает хэш-код объекта для использования в хэштаблицах (при переопределении одного из методов equals(Object) и hashCode()
другой также следует переопределять так, чтобы равные объекты имели равные
хэш-коды)
String toString() — возвращает строковое представление объекта
void notify(), void notifyAll(), void wait(), void wait(long), void
wait(long, int) — предназначены для синхронизации потоков с помощью
данного объекта как монитора. К сожалению, соответствующие конструкции
достаточно громоздки и неудобны, поэтому, начиная с версии Java 5,
рекомендуется использовать для таких задач библиотеку вспомогательных классов
java.util.concurrent.
Class<?> getClass() — возвращает объект, представляющий в Java машине
класс данного объекта
o String — тип неизменяемых символьных строк.
Константы этого типа имеют вид “aaabbc12345~,diDu){%$WW”.
Имеет методы (перчислены лишь некоторые)
char charAt(int) — символ по индексу
int compareTo(String) — лексикографическое сравнение строк
String concat(String) — конкатенация строк (вместо этого метода может
использоваться операция +)
boolean contains(CharSequence) — проверка того, что в строке содержится
заданная последовательность символов
static String format(String, Object…) — представление набора объектов в
виде строки по заданному формату
int indexOf(char), int indexOf(char, int) — первый индекс данного
символа в строке или -1 (во втором случае поиск начинается со второго аргумента)
Аналогично для методов lastIndexOf() — последний индекс
Аналогичные методыс первым аргументом типа String
int length() — длина строки
String replace(char, char) — возвращает строку, полученную из данной
заменой первого символа на второй
String[] split(String) — разбивает строку на части по заданным регулярным
выражение разделителям
o Для работы с изменяемыми строками служат классы StringBuffer и
StringBuilder. Оба эти класса и String реализуют общий интерфейс
последовательности символов CharSequence.
Основные методы StringBuffer и StringBuilder — append() и insert() с
аргументами различных типов, вставляющие строковые представления аргументов
в конец данной строки или в указанное место. Различие между этими классами в
том, что StringBuffer синхронизирован и его объект может правильным образом
использоваться несколькими потоками одновременно, но с потерей
производительности, а StringBuilder — не синхронизирован, его методы
работают быстрее, но некорректно, если используются в одном объекте из
нескольких параллельных потоков.
o Integer, Boolean, Byte, Char, Short, Long, Float, Double — обертки примитивных
типов, все обертки числовых типов наследуют классу Number.
Содержат декларации констант, представляющих максимальные и минимальные
значения числовых типов (MAX_VALUE, MIN_VALUE), бесконечности для типов с
плавающей точкой, методы преобразования значения типа в строку toString() и
обратные parseInt(), parseFloat() и пр., методы работы с битовым
представлением значений.
o System — класс, предоставляющий набор статических методов, выполняющих
операции с Java машиной в целом.
Поля
static PrintStream err, in, out — стандартные потоки вывода сообщений об
ошибках, ввода и вывода обычных сообщений
Методы
static void arrayCopy(Object src, int pos, Object dest, int pos, int
num) — вспомогательный метод для быстрого копирования блоков массивов
static long currentTimeMillis() — возвращает текущее системное время в
милисекундах
static void exit(int)
— прекращение работы Java машины с заданным
статусом
— уникальный хэш-код данного объекта,
позволяет различать объекты, для которых метод hashCode() возвращает
одинаковые значения
static void loadLibrary(String) — загружает динамическую библиотеку с
данным именем
staic void identityHashCode(Object)
o Thread — класс объектов-потоков. Каждый потоко выполнения в Java машине
представляется объектом этого класса или его наследников.
Методы
static Thread currentThread() — возвращает текущий поток
static void dumpStack() — печатает в System.out стек методов текущего
потока
void join() — ожидает окончания работы данного потока
void join(long) — ожидает окончания работы данного потока не более
указанного числа милисекунд
void run() — основной метод потока, его надо перегружать при оперделении
собственного класса потоков
static void sleep(long) — текущий поток приостанавливается на указанное
число милисекунд
void start() — запускает основной метод данного потока в виде отдельного
потока выполнения
static void yield() — временно приостанавливает выполнение текущего
потока, давая возможность работать другим
o Math — класс, объединяющий большинство часто используемых математических
операций в виде статических методов.
Методы
static <тип> abs(<тип>) — абсолютное значение для всех числовых типов
static double acos(double), static double asin(double), static double
atan(double) — арккосинус, арксинус, арктангенс
static double atan2(double y, double x) — аргумент точки с координатами
(x, y)
static double cbrt(double), static double sqrt(double)
— кубический и
квадратный корень
static double cos(double), static double sin(double), static double
tan(double) — косинус, синус, тангенс
static double cosh(double), static double sinh(double), static double
tanh(double) — гиперболические косинус, синус, тангенс
static double ceil(double), static double floor(double), static long
round(double) — округление до целого вверх и вниз, до ближайшего
static double exp(double), static double log(double), static double
log10(double), static double pow(double, double) — экспонента,
натуральный и десятичный логарифмы, возведение в степень
static <тип> max(<тип>, <тип>), static <тип> min(<тип>, <тип>) —
максимум и минимум для числовых типов
o Enum<E extends Enum<E>> — базовый класс перечислений.

int compareTo(E)

String name()

int ordinal()
— сравнивает элементы перчисления с учетом порядка,
т.е. возвращает 0, если они равны, 1, если данный элемент больше
аргумента, -1, если данный элемент меньше аргумента
— возвращает имя константы перечисления,
представляющей данный объект
— возвращает номер данного элемента в перечислении
o Class<T> — класс объектов, представляющих в Java машине загруженные классы.
Используется для получения мета-информации о типе объекта и атрибутах этого
типа.
Методы
static Class<?> forName(String) — возвращает объект, представляющий класс
с заданным именем, если его удается загрузить
Class[] getClasses(), Class[] getDeclaredClasses() — возвращает список
классов и интерфейсов, декларированных внутри данного как public и всех
вообще
Class<?> getComponentType() — возвращает тип элемента массива, если данный
класс представляет тип массива
Constructor[] getConstructors(),Constructor[] getDeclaredConstructors()
— возвращает список конструкторов, декларированных внутри данного класса как
public и всех вообще
Method[] getMethods(), Method[] getDeclaredMethods() — возвращает
список методов, декларированных внутри данного класса как public и всех
вообще
Field[] getFileds(), Field[] getDeclaredFields() — возвращает список
полей, декларированных внутри данного класса как public и всех вообще
Constructor<T> getConstructor(Class…), Method getMethod(String,
Class…), Field getField(String), Constructor<T>
getDeclaredConstructor(Class…), Method getDeclaredMethod(String,
Class…), Field getDeclaredField(String) — возвращает конструктор (по
типам параметров), метод (по имени и типам параметров) или поле (по имени),
декларированные как public или любые
String getName() — полное имя класса
T[] getEnumConstants() — список объектов-констант перечисления, если
данный класс — перечисление
Class[] getInterfaces() — возвращает список реализуемых интерфейсов
Class<? extends T> getSuperclass() — возвращает класс-предок данного
T newInstance() — создает новый объект данного класса с помощью
конструктора без параметров
boolean isArray(), boolean isEnum(), boolean isInterface(), boolean
isMemberClass(), boolean isPrimitive() — проверяют, является ли данный
класс массивом, перечислением, интерфейсом, вложенным классом, примитивным
типом
 java.lang.ref
Классы данного пакета представляют различные виды ссылок в системе. Класс
WeakReference, представляющий слабые сслыки, полезен при организации
«самоочищающихся» коллекций объектов. Они бывают нужны при решений следующей
проблемы.
Все объекты Java располагаются в динамической памяти, управление которой
автоматическое — иногда запускается сборщик мусора и удаляет часть объектов, не
нужных ни одному из имеющихся потоков (т.е., не доступных по ссылкам из объектовпотоков и их текущих контекстов). Объект, на который есть ссылка из одного из нужных
объектов, тоже считается нужным. При этом иногда объект нужно сохранять в
некоторой коллекции, но только пока на него ссылаются еще какие-то объекты, а как
только такие ссылки пропадают, объект становится не нужен и в коллекции, но сборщик
мусора его не удалит, пока ссылка из коллекции на него остается. Для того, чтобы
объект X удалялся, как только он стал недоступен отовсюду, кроме выделенного набора
объектов, в этих объектах ссылку на X нужно заменить на объект класса WeakReference,
построенный на основе X. При этом, пока сборщик мусора не удалил X, он будет
доступен при помощи метода get(), а если он удален , то get() вернет null. Ссылки из
объектов класса WeakReference сборщик мусора не учитывает, поэтому он сможет
удалить X после того, как на него не останется других ссылок, кроме как из объектов
WeakReference.
 java.lang.reflect
Этот пакет содержит набор классов, представляющих элементы самого языка. Они
предоставляют интерфейс для получения метаинформации о классах и методах из кода
на Java.
Основные классы
o Array
Предоставляет набор утилит для работы с общими массивами. Это статические
методы для получения элемента массива по индексу static Object get(Object,
int), для получения значения примитивного типа по индексу, если массив хранит
значения примитивного типа (это не шаблонный метод, а набор методов, по
одному для каждого примитивного типа Java) static <type> get<Type>(Object,
int), для получения длины массива static int getLength(Object), для замены
значения по индексу static <type> set<Type>(Object, int, <type>).
o Constructor<T>
Представляет тип конструкторов типа T.
Методы

Class<T> getDeclaringClass()
— возвращает класс, в котором данный
конструктор декларирован

Class<?>[] getExceptionTypes()
— возвращает массив классов
декларированных исключений

Class<?>[] getParameterTypes()
— возвращает массив классов
параметров

T newInstance(Object…)
— вызывает конструктор с указанными
параметрами
o Method
Представляет тип методов.
Методы

Class<T> getDeclaringClass()
— возвращает класс, в котором данный
метод декларирован

Class<?>[] getExceptionTypes()
декларированных исключений
— возвращает массив классов

Class<?>[] getParameterTypes()
— возвращает массив классов
параметров

String getName()

Object invoke(Object, Object…)
— возвращает имя метода
— вызывает метод в указанном объекте
с указанными параметрами
o Field
Представляет тип полей классов.
Методы

Class<T> getDeclaringClass()
— возвращает класс, в котором данное
поле декларировано

String getName()

Object get(Object)

void set(Object, Object)

<type> get<Type>(Object)
— возвращает имя поля
— возвращает значение поля в заданном объекте
— устанавливает значение поля в объекте,
указанном первым аргументом, в значение, указанное вторым аргументом
— возвращает значение поля примитивного
типа в заданном объекте

— устанавливает значение поля
примитивного типа в объекте, указанном первым аргументом, в значение,
указанное вторым аргументом
void set<Type>(Object, <type>)
 java.util
Этот пакет содержит набор часто используемых при построении приложений
вспомогательных классов, прежде всего, классов коллекций и классов, предназначенных
для работы с датами.
Основные классы этого пакета с некоторыми их методами описаны ниже.
o ArrayList<T>, LinkedList<T>
Реализуют автоматически раширяемый список объектов типа T. Перечисленные
ниже методы соответствуют реализуемому ими интерфейсу List<T>.

boolean add(T)

void add(int, T)

void clear()

boolean contains(Object) — проверяет,
(при помощи метода equals()) в списке

T get(int)

int indexOf(Object)

int lastIndexOf(Object)

Iterator<T> iterator()

T remove(int)
— удалить элемент по индексу

T set(int, T)
— заменить элемент по индексу на заданный

int size()
— добавляет элемент в конец списка (возвращает true)
— вставляет элемент на указанное место
— удаляет из списка все элементы
содержится ли такой элемент
— возвращает элемент списка по указанному индексу
— возвращает индекс первого вхождения такого
элемента (при помощи метода equals()) в список или -1
— возвращает индекс последнего вхождения
такого элемента (при помощи метода equals()) в список или -1
— возвращает итератор для перебора списка
— возвращает число элементов в списке
o BitSet
Реализует множество битов и набор операций с такими множествами.

void and(BitSet), void andNot(BitSet), void or(BitSet), void
xor(BitSet) — побитовые операции, преобразующие данное множество
битов в конъюнкцию, штрих Шефера, дизъюнкцию или сумму по модулю 2
от него и параметра.

int cardinality(), int size(), int length()— возвращают число
битов в множестве, установленных в true, всех битов, и битов до
последнего, установленного в true, включая его самого

void set(int), void clear(int), void set(int, boolean) —
устанавливают указанный бит в true, false или указанное значение

boolean get(int)
— возвращает значение указанного бита
o HashMap<K, V> — реализует хэшированный ассоциативный массив (map)
элементов типа V с индексами (ключами) типа K.
TreeMap<K, V> — реализует такой же ассоциативный массив на базе
сбалансированного дерева — индексы должны быть линейно упорядочены. Оба
эти класса реализуют следующие методы общего интефейса ассоциативных
массивов Map<K, V>. При определении содержащихся ключей и поиске по ним
используется метод equals(). Если нужно считать ключи равными, только если
они являются один и тем же объектом, используйте класс IdentityHashMap<K, V>
с таким же интерфейсом. Кроме того, для создания самоочищающихся коллекций
(см. выше о пакете java.lang.ref), объекты в которых уничтожаются сборщиком
мусора как только они становятся недоступны из любых других объектов, кроме
такой коллекции, можно использовать класс WeakHashMap<K, V>.

void clear()

boolean containsKey(Object), boolean containsValue(Object)

V get(Object) — выдать значение по ключу (при помощи
equals()), или null, если такой ключ не используется

Set<K> keySet()

V put(K, V)

V remove(Object) — удалить пару с данным ключем (при
equals()) и вернуть значение по нему (или null)

int size()
— очистить ассоциативный массив
—
проверить нахождение в массиве пары с заданным ключем или заданным
значением (при помощи метода equals())
метода
— возвращает множество ключей
— установить по заданному ключу заданное значение и
вернуть старое значени по этому ключу (или null)
помощи метода
— вернуть число пар в массиве
o HashSet<E>, TreeSet<E> — классы, реализующие множество значений типа E,
описываемое общим интерфейсом Set<E>. Для определения наличия или
отсутствия объекта в множестве используют метод equals(). Объекты в классе
TreeSet<E> должны быть линейно упорядочены.

boolean add(E)

void clear()

boolean contains(Object)
множеству
— добавляет объект в множество
— очищает множество
— проверяет принадлежность объекта

Iterator<E> iterator()
— возвращает итератор для перебора множества

boolean remove(Object)
— удаляет объект из множества

int size()
— возвращет число элементов в множестве
o Iterator<E> — интерфейс итератора коллекций элементов типа E

boolean hasNext()

E next()

void remove()
— проверяет наличие еще не выданных элементов
— возвращает очередной элемент и сдвигает итератор
— удаляет последний элемент, возвращенный next()
o Queue<E> — интерфейс очереди

E element()

boolean offer(E)

E peek()
— возвращает, но не удаляет голову очереди или null

E poll()
— возвращает и удаляет голову очереди или возвращает null

E remove()
— возвращает, но не удаляет голову очереди (создает
исключение для пустой очереди)
— добавляет, если возможно, элемент в конец очереди
— возвращает, но не удаляет голову очереди (создает
исключение для пустой очереди)
o Arrays, Collections — содержат набор статических методов для работы с
массивами и коллекциями. Основные методы Arrays обеспечивают бинарный
поиск в упорядоченных масивах и сортировку — static int
binarySearch(<тип>[], <тип>), static void sort(<тип>[]), сравнение
массивов — static boolean equals(<тип>[], <тип>[]), преобразование
массива в единую строку — static String toString(<тип>[]).
Основные методы Collections реализуют бинарный поиск и сортировку списков
— static <T> int binarySearch(List<? extends Comparable<? super T>>,
T)? static <T extends Comparable<? super T>> void sort(List<T>),
копирование элементов из одного списка в другой — static <T> void
copy(List<? super T>, List<? extends T>), определение минимального и
максимального элемента в коллекции — static <T extends Object &
Comparable<? super T>> T min(Collection<? extends T>), static <T
extends Object & Comparable<? super T>> T max(Collection<? extends T>).
o Классы для работы с датами

Calendar

Date
и GregorianCalendar служат для представления произвольного и
григорианского календарей. Содержат наборы полей, представляющих
единицы отсчета времени — часы, дни, месяцы, годы, эры и пр. — и набор
методов для определения значений этих полей у объектов, представляющих
временные точки.
— представляет временные точки. Основные методы — сравнение
временных точек и получение текущей точки.
o Currency — представляет различные валюты
o Formatter — содержит методы форматированного вывода объектов в потоки
вывода (поток, связанный с данным форматером дается ему в качестве аргумента
конструктора). Основной метод — Formatter format(String, Object…),
выводящий набор объектов, отформатированный согласно формату, заданному
первым аргументом.
o Observable — класс, реализующий наблюдаемый объект в образце
«наблюдатель». Наблюдатели за данным объектом должны реализовывать
интерфейс Observer. Позволяет привязывать к себе или отключать наблюдателей
и оповещать их о существенных событиях.
o Timer и TimerTask — представляют объекты-таймеры, которые можно установить
на запуск некоторых задач в определенное время, и сами запускаемые таймером
задачи.
o Scanner — простой сканер текстов, способный разбирать строковые
представления чисел и других примитивных типов в соответствии с регулярными
выражениями.
o StringTokenizer — разбивает строку на набор токенов.
o Random — представляет объекты-генераторы случайных чисел.
 java.util.regex — пакет, содержащий классы для работы с регулярными
выражениями.
o Pattern — представляет регулярные выражения.

Static Pattern compile(String)
— строит регулярное выражение на
основе строки

String pattern()
— возвращает строку, из которой построено данное
выражение

Matcher matcher(CharSequence)

static boolean matches(String, CharSequence)

String[] split(CharSequence)
— создает объект для обработки
заданной последовательности символов с попмощью регулярного
выражения
— проверяет, подходит
ли заданная последовательность под регулярное выражение, заданное
строкой
— разбивает последовательность символов
на части, разделенные подстроками. Подходящими под данное выражение
o Matcher —реализует методы для поиска соответствия регулярным выражениям.

Matcher region(int, int)

Matcher reset(CharSequence)
— возвращает обработчика, действующий на
подинтевале интервала данного обработчика
— задает новую последовательность
символов для обработки

Matcher usePattern(Pattern)

boolean find()

boolean lookingAt()
— задает новое выражение для обработки
— ищет очередное вхождение регулярного выражения в
обрабатываемый регион
— пытается найти соответствие выражению с начала
региона

— пытается соотнести весь обрабатываемый регион с
регулярным выражением
boolean match()
 java.util.concurent
Этот пакет и его подпакеты добавлены в JDK, начиная с версии 1.5. Он содержит набор
классов, реализующих коллекции с различными эффективными моделями
синхронизации обращений к ним из нескольких параллельных потоков (коллекции в
являются либо полностью синхронизированными, т.е. при работе одного
потока с такой коллекцией все остальные стоят, либо не поддерживают корректной
работы с несколькими потоками, например, в результате параллельного добавления в
множество двух одинаковых элементов может быть создано исключение). Также в этот
пакет и его подпакеты входят вспомогательные классы, реализующие различные модели
синхронизации параллельных потоков.
java.util
o ConcurrentHashMap, ConcurrentLinkedQueue — реализуют ассоциативный массив
и очередь с эффективными моделями синхронизации
o CopyOnWriteArrayList, CopyOnWriteArraySet — реализуют список и множество,
копирующие внутренние данные при попытке их изменить. Итераторы таких
коллекций перебирают только те элементы, которые присутствовали в коллекции
при создании итератора.
o CountDownLatch — реализует синхронизационную модель «щеколды» — создается
щеколда (с натуральным числом в качестве параметра-счетчика), которая
постепенно вынимается с выполнение каких-то операций (как только такая
операция выпонена, вызывается метод void countDown(), уменьшающий
счетчик). Потоки, которые должны подождать конца выполнения данной цепочки
операций, вызывают метод await() и блокируются. Как только щеколда будет
вынута (счетчик упадет до нуля), все ожидающие потоки разблокируются и
продолжают выполнение.
o CyclicBarrier — реализует синхронизационную модель «барьер» — каждый
поток из некоторой группы доходит до барьера (созданного с числом потоков в
группе в качестве параметра) и ждет, пока все они не дойдут до него (ожидание
начинается при вызове await()). Как только число ожидающих потоков достигнет
заданного, барьер убирается и все они могут продолжать выполнение. Кроме того,
в качестве параметра конструктора можно задать некотоые действия (в виде
объекта Runnable), которые будут выполняться после того, как все потоки
достигнут барьера, но до их освобождения.
o Semaphore — недвоичный семафор. Обеспечивает одновременную работу не
более чем некоторого числа потоков. Такой объект создается с параметром-числом
(доступных ресурсов), каждый поток, желающий захватить семафор, вызывает
метод aquire(), каждый поток, желающий его освободить, вызывает метод
release(). Если число захватов сравнилось с заданным при построении
значением, каждый очередной захватывающий поток будут приостановлен, пока
не семафор не будет освобожден одним из уже захвативших его потоков (после
чего только один из ожидающих продолжит выполнение).
o ThreadPoolExecutor — реализует пул потоков, предназначенных для обработки
асинхронно поступающих заданий.

void execute(Runnable)
— передает пулу на выполнение некотрую
задачу

int getTaskCount()
— возвращает примерное число задач, переданных на
выполнение

int getCompletedTaskCount()
— возвращает примерное число
выполненных задач

boolean remove(Runnable)
выполняться
— удаляет задачу, если она еще не начала

int getMaximumPoolSize()
— возвращает макимально возможное число
потоков в пуле

int getPoolSize()
— возвращает число потоков в пуле на данный момент
 java.util.concurrent.locks
Содержит дополнительные реализации моделей синхронизации потоков.
o ReenterantLock — двоичный семафор с возможностью многократного захвата
одним потоком.

void lock()

void unlock()

Condition newCondition()
захватывает семафор для текущего потока
освобождает семафор, захваченный текущим потоком
— возвращает объект-условие, связанный с
данным семафором. Можно использовать это условие для блокировки
потоков до его наступления. Поток блокируется вызовом await() у
объекта-события и освобождается, когда у того же события будет вызван
метод signal() (освобождает только один поток) или signalAll()
(освобождает все блокированные потоки).
o ReenterantReadWriteLock — реализует модель синхронизации «чтение-запись»,
позволяющую читать данные одновременно нескольким потокам, а изменять
только одному.

ReenterantReadWriteLock.ReadLock readLock()
— возвращает объект для
блокировки чтения

— возвращает объект
для блокировки записи. Оба объекта реализуют общий интерфейс lock()unlock() для установки или отключения соответствующих блокировок.
ReenterantReadWriteLock.WriteLock writeLock()
 java.io
Этот пакет содержит набор классов, реализующих различные способы организации
потокового ввода-вывода. Основные классы этого пакета — абстрактные классы
Reader, Writer, InputStream, OutputStream и неабстрактный класс File. Reader
содержит методы для чтения символа read(char), массива символов read(char[]) и
пропуска набора символов skip(long) в потоке, Writer — аналогичные методы для
вывода символа write(int) или массива символов write(char[]). InputStream и
OutputStream отличаются от них тем, что вместо символов они читают/пишут байты.
Кроме того, в данном пакете содержится большое число наследников этих классов,
организующих чтение/запись с помощью различных источников/направлений —
CharArrayReader, FileReader, StringReader и пр.
Класс File реализует методы работы с файлами — проверки возможности чтения и
записи boolean canRead(), boolean canWrite(), создания файла boolean
createNewFile() или директории boolean mkdir(), удаления файла boolean delete(),
и пр.
 java.math
Вспомгательный пакет, содержащий классы, реализующие вычисления с большой
точностью («длинная арифметика»). BigInteger реализует действия с произвольно
большими целыми числами, BigDecimal — с действительными числами произвольной
величины и точности.
 java.awt
Этот пакет и его подпакеты содержат библиотеку класоов, представляющих элементы
графического интерфейса — окна, кнопки, выпадающие списки, меню и пр. элементы
управления.
Другая реализация аналогичного набора компонентов, опирающаяся на интерфейсы,
определенные в java.awt, находится в пакете и подпакетах javax.swing.
 java.beans
Этот пакет и его подпакеты содержат основные классы и интерфейсы для поддержки
технологии JavaBeans. JavaBeans служит для построения компонентов, определяющих
обработку событий, набор свойств, механизмы помещения компонента в постоянное
харанилище и его извлечения оттуда, интерфейс для интроспекции — динамического
определения свойств и методов компонента и набора обрабатываемых им событий,
интерфейс для взаимодействия среды разработки с компонентом во время разработки.
 java.net и javax.net
Эти пакеты содержат набор классов и интерфейсов, образующих основу для разработки
сетевых приложений. Основные классы этого пакета связаны с двумя уровнями
интерфейса — низкоуровневыми классами, представляющими адреса, сокеты и сетевые
интерфейсы, и высокоуровневыми, связанными с URI, URL и соединениями.
 java.nio
Данный пакет и его подпакеты предоставляет интерфейсы для реализации
высокоэффективного ввода/вывода с учетом особенностей платформ — сами
интерфейсы платформенно-незаивисмы.
Основные классы представляют буфера, наборы символов и каналы обмена данными.
 java.rmi
Содержит интерфейсы и классы для реализации распределенных приложений на основе
удаленного вызова методов (Remote Method Invocation). О лежащих в основе этого
подхода механизмах речь пойдет на следующей лекции.
 java.security
Содержит основные интерфейсы и классы для поддержки обеспечения безопасных
соединений, шифорования, использования различных протоколов безопасности и
различных моделей управления ключами и сертификатами.
 java.sql и javax.sql
Эти пакеты содержат основные интерфейсы для организации работы с базами данных,
образующие так называемый интерфейс JDBC 3.0.
 java.text
Содержит набор классов, решающих различные задачи преобразования данных в
форматированный текст.
Литература
[1] http://java.sun.com/j2ee/1.4/docs/index.html
Документация по платформе J2EE
[2] http://java.sun.com/j2se/1.5.0/docs/index.html
Документация по платформе J2SE
[3] К. Арнолд, Д. Гослинг, Д. Холмс. Язык программирования Java. М., Вильямс, 2001.
(Язык в версии Java 2, до введения assert)
[4] B. Joy, G. Steele, J. Gosling, G. Bracha. Java Language Specification. 2-nd Edition.
Addison-Wesley Pub Co., 2000.
(Язык в версии Java 2, до введения assert)
Доступна по ссылке ftp://ftp.javasoft.com/docs/specs/langspec-2.0.pdf
[5] Э. Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес. Приемы объектноориентированного проектирования. Паттерны проектирования. Питер-ДМК, 2001.
[6] П. Аллен, Дж. Бамбара, М. Ашнаульт, Зияд Дин, Т. Гарбен, Ш. Смит. J2EE.
Разработка бизнес-приложений. ДиаСофт, 2002.
[7] http://java.sun.com/products/javabeans/reference/index.html
[8] Б. Керниган, Р. Пайк. Практика программирования. Бином-Невский диалект, 2001.
[9] B. Meyer. Object-Oriented Software Construction. 2-тв edition, Prentice Hall, 2000.
[10] Б. Лисков, Дж. Гатег. Использование абстракций и спецификаций при разработке
программ. М., Мир,1989.
[11] Э. Дж. Брауде. Технология разработки программного обеспечения. Питер, 2004.