Часть 2. использование классов и библиотек
Глава 7. ОБРАБОТКА СТРОК ...................................................................................... 160
Класс String ................................................................................................. 160
Классы StringBuilder и StringBuffer ...................................................... 165
Форматирование строк ........................................................................... 167
Лексический анализ текста .................................................................... 173
Регулярные выражения ........................................................................... 174
Интернационализация текста ............................................................... 178
Интернационализация чисел ................................................................ 181
Интернационализация дат ..................................................................... 182
Задания к главе 7 ....................................................................................... 184
Тестовые задания к главе 7 .................................................................... 188
Глава 8. ИСКЛЮЧЕНИЯ И ОШИБКИ ..................................................................... 190
Иерархия и способы обработки ........................................................... 190
Оператор throw .......................................................................................... 195
Ключевое слово finally ............................................................................ 197
Собственные исключения ...................................................................... 198
Наследование и исключения ................................................................. 199
Отладочный механизм assertion ........................................................... 201
Задания к главе 8 ....................................................................................... 202
Тестовые задания к главе 8 .................................................................... 203
Глава 9. ФАЙЛЫ. ПОТОКИ ВВОДА/ВЫВОДА ..................................................... 205
Класс File ..................................................................................................... 205
Байтовые и символьные потоки ввода/вывода ................................ 207
Предопределенные потоки .................................................................... 212
Сериализация объектов .......................................................................... 214
Консоль ....................................................................................................... 218
Класс Scanner ............................................................................................ 219
Архивация ................................................................................................... 222
Задания к главе 9 ....................................................................................... 226
Тестовые задания к главе 9 .................................................................... 227
Глава 10. КОЛЛЕКЦИИ .................................................................................................. 229
Общие определения ................................................................................. 229
Списки .......................................................................................................... 231
Deque ............................................................................................................ 239
Множества .................................................................................................. 240
Карты отображений ................................................................................ 245
Унаследованные коллекции .................................................................. 249
Класс Collections ....................................................................................... 250
Класс Arrays ............................................................................................... 253
Задания к главе 10 ..................................................................................... 255
Тестовые задания к главе 10 ................................................................. 257
Глава 11. ГРАФИЧЕСКИЕ ИНТЕРФЕЙСЫ ПОЛЬЗОВАТЕЛЯ ..................... 259
Основы оконной графики ....................................................................... 259
Апплеты ....................................................................................................... 261
Фреймы ........................................................................................................ 270
Задания к главе 11 ..................................................................................... 272
Тестовые задания к главе 11 ................................................................. 273
Глава 12. СОБЫТИЯ ........................................................................................................ 275
Основные понятия .................................................................................... 275
Классы-адаптеры ..................................................................................... 281
Задания к главе 12 ..................................................................................... 284
Тестовые задания к главе 12 ................................................................. 285
Глава 13. ЭЛЕМЕНТЫ КОМПОНОВКИ И УПРАВЛЕНИЯ ............................. 287
Менеджеры размещения ......................................................................... 287
Элементы управления ............................................................................. 293
Визуальные компоненты JavaBeans ................................................... 318
Задания к главе 13 ..................................................................................... 325
Тестовые задания к главе 13 ................................................................. 326
Глава 14. ПОТОКИ ВЫПОЛНЕНИЯ ......................................................................... 328
Класс Thread и интерфейс Runnable ................................................... 328
Жизненный цикл потока ......................................................................... 329
Управление приоритетами и группы потоков .................................. 330
Управление потоками ............................................................................. 331
Потоки-демоны .......................................................................................... 333
Потоки в графических приложениях ................................................... 335
Методы synchronized ............................................................................... 337
Инструкция synchronized ........................................................................ 340
Состояния потока ..................................................................................... 342
Потоки в J2SE 5 ......................................................................................... 344
Задания к главе 14 ..................................................................................... 347
Тестовые задания к главе 14 ................................................................. 348
Глава 15. СЕТЕВЫЕ ПРОГРАММЫ ......................................................................... 350
Поддержка Интернет ............................................................................... 350
Сокетные соединения по протоколу TCP/IP ..................................... 354
Многопоточность ..................................................................................... 356
Датаграммы и протокол UDP ................................................................ 359
Задания к главе 15 ..................................................................................... 361
Тестовые задания к главе 15 ................................................................. 362
Глава 16. XML & Java ................................................................................................... 364
DTD ............................................................................................................... 367
Схема XSD .................................................................................................. 370
XML-анализаторы ................................................................................... 380
SAX-анализаторы ..................................................................................... 381
Древовидная модель ................................................................................ 388
Xerces ............................................................................................................ 388
JDOM ............................................................................................................ 392
StAX .............................................................................................................. 399
XSL ................................................................................................................ 404
Элементы таблицы стилей ..................................................................... 407
Задания к главе 16 ..................................................................................... 408
Тестовые задания к главе 16 ................................................................. 412
Часть 3. ТЕХНОЛОГИИ РАЗРАБОТКИ WEB-ПРИЛОЖЕНИЙ
Глава 17. ВВЕДЕНИЕ В СЕРВЛЕТЫ И JSP ........................................................... 414
Первый сервлет ......................................................................................... 414
Запуск контейнера сервлетов и размещение проекта .................... 416
Первая JSP ................................................................................................... 419
Взаимодействие сервлета и JSP ............................................................ 421
Задания к главе 17 ..................................................................................... 424
Тестовые задания к главе 17 ................................................................. 424
Глава 18. СЕРВЛЕТЫ ..................................................................................................... 426
Интерфейс ServletContext ....................................................................... 426
Интерфейс ServletConfig ......................................................................... 427
Интерфейсы ServletRequest и HttpServletRequest ............................ 428
Интерфейсы ServletResponse и HttpServletResponse ....................... 432
Обработка запроса .................................................................................. 432
Многопоточность ..................................................................................... 436
Электронная почта .................................................................................. 439
Задания к главе 18 ..................................................................................... 443
Тестовые задания к главе 18 ................................................................. 444
Глава 19. JAVA SERVER PAGES .................................................................................. 446
Стандартные элементы action .............................................................. 447
JSP-документ .............................................................................................. 449
JSTL .............................................................................................................. 451
Неявные объекты ...................................................................................... 453
JSTL core....................................................................................................... 454
JSTL fmt ...................................................................................................... 458
JSTL sql ........................................................................................................ 461
JSTL xml ...................................................................................................... 461
Включение ресурсов ................................................................................ 462
Обработка ошибок ................................................................................... 463
Извлечение значений полей ................................................................... 465
Технология взаимодействия JSP и сервлета ..................................... 467
Задания к главе 19 ..................................................................................... 476
Тестовые задания к главе 19 ................................................................. 477
Глава 20. JDBC ................................................................................................................... 479
Драйверы, соединения и запросы ........................................................ 479
СУБД MySQL ............................................................................................. 481
Простое соединение и простой запрос ............................................... 482
Метаданные ............................................................................................... 485
Подготовленные запросы и хранимые процедуры ......................... 486
Транзакции ................................................................................................. 489
Точки сохранения ..................................................................................... 493
Пул соединений ......................................................................................... 495
Задания к главе 20 ..................................................................................... 497
Тестовые задания к главе 20 ................................................................. 502
Глава 21. CЕССИИ, СОБЫТИЯ и ФИЛЬТРЫ ...................................................... 504
Сеанс (сессия) ............................................................................................ 504
Cookie ........................................................................................................... 509
Обработка событий ................................................................................. 512
Фильтры ...................................................................................................... 516
Задания к главе 21 ..................................................................................... 519
Тестовые задания к главе 21 ................................................................. 521
Глава 22. ПОЛЬЗОВАТЕЛЬСКИЕ ТЕГИ ................................................................ 523
Простой тег ................................................................................................. 523
Тег с атрибутами ...................................................................................... 526
Тег с телом .................................................................................................. 528
Элементы action ........................................................................................ 531
Задания к главе 22 ..................................................................................... 533
Тестовые задания к главе 22 ................................................................. 534
УКАЗАНИЯ И ОТВЕТЫ .................................................................................................. 536
Приложение 1.HTML ........................................................................................................ 552
Приложение 2.JavaScript .................................................................................................. 574
Приложение 3.UML ........................................................................................................... 599
Приложение 4.Базы данных и язык SQL ..................................................................... 608
Приложение 5.Hibernate ................................................................................................... 625
Приложение 6.Struts .......................................................................................................... 645
Приложение 7.Журнал сообщений (Logger) ............................................................... 667
Приложение 8.Apache Ant ............................................................................................... 676
Приложение 9.Портлеты .................................................................................................. 690
Список рекомендуемой литературы и источников .................................................... 703
Глава 1
Вопрос 1.1.
Для того чтобы быть запускаемым приложением, класс может быть объявлен как public, так и friendly (без спецификатора). Метод main() не может быть объявлен как private, так как в этом случае он будет недоступен для выполнения. Для запуска приложения метод main() должен получить в качестве параметра массив строк, а не строку, иначе он будет являться просто перегруженным методом.
Ответ: 2, 3.
Вопрос 1.2.
Слово goto в Java не может быть использовано даже в качестве идентификатора, но оно является резервированным словом, так же как и const. Методы создаются только в классах. Операторы при программировании перегружать нельзя. Множественное наследование, как и циклическое, запрещено.
Ответ: 4, 5.
Вопрос 1.3.
Если переменная объявлена в методе, то до своего использования она должна быть проинициализирована, иначе компилятор сообщает об ошибке.
При инициализированном значении переменной argsв методе print() ошибка не возникает, так как оператор сложения инициирует действия по преобразованию в строку всех участвующих в конкатенации объектов.
Параметр String[] args в main() – просто соглашение, и может быть использован любой приемлемый идентификатор для массива строк.
Ответ: 2.
Вопрос 1.4.
Все методы, производящие чтение из потока, являются потенциальными источниками возникновения ошибок ввода (IOException), которые должны быть обработаны в случае их появления.
Длина считываемых данных может не совпадать с длиной объявленного массива. Лишние данные будут просто утеряны.
Метод read(byte[] b) помещает считываемую информацию в массив, передаваемый ему в качестве параметра.
Ответ: 2.
Вопрос 1.5.
Методы main() являются корректно перегруженными, поэтому никаких ошибок не произойдет, а будет вызван только метод, запускающий приложение.
Ответ: 4.
Ответы:
1.1. 2), 3)
1.2. 4), 5)
1.3. 2)
1.4. 2)
1.5. 4)
Глава 2
Вопрос 2.1.
Строка float f=7.0;не скомпилируется, поскольку встроенный тип числа компонента с плавающей точкой – double. Следует компилировать
float f=(float) 7.0 или float f=7.0f;
Строкаchar c="z"; не скомпилируется, поскольку char должен определяться одинарными кавычками. Следует компилировать
char c='z';
Строкаbyte b=255; не скомпилируется, поскольку байт может определить числа между –128 и +127;
значение типа boolean может быть только true или false.
Ответ: 5, 6.
Вопрос 2.2.
Условие может находиться только в круглых скобках, после которых может располагаться один оператор либо блок кода, заключенный в фигурные скобки.
Ответ: 1, 5.
Вопрос 2.3.
Идентификатор может начинаться с буквы или знака доллара ‘$’, или подчеркивания ‘_’. Идентификатор не может начинаться с других символов, как, например, цифра или ‘#’, причем последний не может находиться и внутри него.
Ответ: 3, 4, 5.
Вопрос 2.4.
Объявление а1 корректно, длина такого массива равна нулю. Объявление а5 некорректно, так как одновременно задано количество элементов для выделения памяти и определяются сами элементы, что является избыточной информацией.
Ответ: 1, 2, 4.
Ответы:
2.1. 5), 6)
2.2. 1), 5)
2.3. 3), 4), 5)
2.4. 1), 2), 4)
Глава 3
Вопрос 3.1.
Конструктор может быть объявлен только со спецификаторами public, private, protected или без спецификатора. В случае использования private и protected объект класса может быть создан с помощью статического метода класса, который вызывает такой конструктор.
Применение final или abstract при объявлении конструктора не имеет смысла, потому что он не участвует в наследовании.
Спецификатор volatile применяется только к полям классов, используемых потоками (Thread).
Применение native с конструктором не предусматривается спецификацией языка.
Ответ: 1, 5.
Вопрос 3.2.
Метод или логический блок могут вызывать конструктор только с помощью оператора new.
Ответ: 3.
Вопрос 3.3.
Статический метод может быть вызван из нестатического, обратное неверно, так как статический метод может быть вызван без создания экземпляра класса и имеет доступ только к статическим полям и методам класса. Использование спецификатора private не ограничивает видимость поля или метода внутри объявления класса. Ничто не мешает методу быть объявленным
final static.
Ответ: 1.
Вопрос 3.4.
При запуске приложения выполняются только статические логические блоки класса приложения и тело метода main().
Ответ: 4.
Ответы:
3.1. 1), 5)
3.2. 3)
3.3. 1)
3.4. 4)
Глава 4
Вопрос 4.1.
Во время выполнения при попытке преобразования с сужением типа будет сгенерировано исключение ClassCastException.
Ответ: 3.
Вопрос 4.2.
Класс Object при наследовании может быть указан явно только в том случае, если класс не наследует другой класс. В данной ситуации для корректности кода необходимо убрать один из двух классов после extends, причем неважно какой.
Ответ: 3.
Вопрос 4.3.
Компилятор создаст конструктор по умолчанию для класса В, который для создания объекта попытается вызвать несуществующий конструктор без параметров класса А. В итоге будет сгенерирована ошибка компиляции в строке 2.
Ответ: 2, 4.
Вопрос 4.4.
В одном файле не может быть двух public классов.
Ответ: 1.
Вопрос 4.5.
Методы, объявленные как private, не наследуются, поэтому на них не распространяются принципы полиморфизма. Так что метод с такой же сигнатурой, объявленный в подклассе, не имеет никакой связи с методом из суперкласса.
В таком случае при вызове через ссылку на суперкласс происходит попытка вызвать его private-метод, что приводит к ошибке компиляции.
Ответ: 1.
Вопрос 4.6.
В строке 1 ошибки не будет, так как происходит безопасное преобразование вверх. Во второй строке вызывается полиморфный метод. Ошибка компиляции произойдет при попытке вызова метода, принадлежащего только подклассу, через ссылку на суперкласс, через которую он просто недоступен.
Ответ: 5.
Вопрос 4.7.
Вместо первого и третьего комментариев вызовы конструкторов ставить нельзя, так как явный вызов конструктора может осуществляться только с помощью super() или this() соответственно только из конструкторов подкласса или текущего класса.
Ответ: 3.
Ответы:
4.1. 3)
4.2. 3)
4.3. 2), 4)
4.4. 1)
4.5. 1)
4.6. 5)
4.7. 3)
Глава 5
Ответы:
5.1. 2)
5.2. 1), 4)
5.3. 2)
5.4. 3)
5.5. 3)
Глава 6
Вопрос 6.1.
Объявление пакета должно предшествовать любому другому коду, причем оно должно быть единственным. Комментарии могут находиться везде.
Ответ: 2, 3.
Вопрос 6.2.
Интерфейсы не могут включать реализованные методы и неинициализированные поля. Все поля интерфейса трактуются как константы. Абстрактный метод не может быть статическим из-за нарушения принципов полиморфизма, также он не может быть protected и private из-за того, что не может быть использован и переопределен. Атрибуты по умолчанию перед полями и методами интерфейса можно записать в явном виде.
Ответ: 2, 4.
Вопрос 6.3.
Объявить объект внутреннего (нестатического) класса можно, только предварительно создав объект внешнего класса. Конструкторы обоих классов должны вызываться так же, как и для всех других классов, т.е. с помощью оператора new.
Ответ: 4.
Вопрос 6.4.
В результате выполнения кода Owner ob=new Owner() будет создан объект Owner. Его метод meth() создаст объект типа Inner в результате выполнения кода Abstract abs=ob.meth(). При его выполнении ничего выведено на консоль не будет, так как метод meth() класса Inner, выводящий на консоль строку inner, будет вызван только один раз командой abs.meth().
Ответ: 1.
Вопрос 6.5.
В первой строке объявляется поле, во второй – метод, в третьей – внутренний класс. Все они могут иметь одинаковое имя, что не мешает компилятору различать их.
Ответ: 4.
Ответы:
6.1. 2), 3)
6.2. 2), 4)
6.3. 4)
6.4. 1)
6.5. 4)
Глава 7
Вопрос 7.1.
Метод substring(i,j) извлекает подстроку из вызывающей строки, начиная с символа в позиции i и заканчивая символом в позиции j, не включая его. Первый символ строки находится в позиции 0.
Ответ: 2.
Вопрос 7.3.
Java не допускает перегрузки оператора, как в C++, но для удобства оператор + переопределен для строк и преобразует объекты любых типов в его строковый эквивалент.
Ответ: 1, 2.
Вопрос 7.4.
Ошибок компиляции не возникнет, так как, во-первых, ch получит соответствующее коду 0H74 значение ‘t’ и, во-вторых, сложение символа со строкой в результате даст строку “tava”.
Ответ: 6.
Вопрос 7.5.
Метод insert() вставляет строку в указанную позицию вызывающего объекта класса StringBuffer и сохраняет в нем изменения.
Ответ: 1.
Ответы:
7.1. 2)
7.2. 3)
7.3. 1), 2)
7.4. 6)
7.5. 1)
Глава 8
Вопрос 8.1.
Блок try может завершаться инструкцией catch или finally. В данном случае во избежание ошибки компиляции необходимо поставить инструкцию catch(java.io.IOException e), т.к. метод write() способен генерировать исключение, которое сам не обрабатывает. Метод inc() возвращает значение, поэтому необходимо завершить код метода инструкцией return counter. Так как в вопросе предлагалось выбрать два правильных ответа, то возможное добавление в код инструкции finally не представляется возможным.
Ответ: 2, 5.
Вопрос 8.2.
При вызове метода meth() с параметром 5 переменная y последовательно будет принимать следующие значения: в строке 1 в десятичной системе счисления будет 8; в строке 2 будет значение 13 (8 + 5); строка 3 генерирует исключение, поэтому строка 4 будет пропущена, а в результате выполнения инструкции catch значение будет уменьшено на единицу. Если бы в строке 3 исключение генерировалось без использования оператора if, то возникла бы ошибка компиляции из-за принципиальной невозможности выполнения строки 4.
Ответ: 1.
Вопрос 8.3.
При генерации исключения последовательно выполняются блоки catch и finally, причем возвращаемое методом значение переменной count будет взято из инструкции return блока finally.
Ответ: 4.
Вопрос 8.4.
Варианты 1 и 4 не скомпилируются, т.к. они включают классы
IOExceptionи Exception, не обработанные в базовом классе. Поскольку в случаях 2 и 3 в качестве параметра выступают типы long и short, то эти
методы являются перегруженными, для которых таких ограничений не
существует.
Ответ: 2, 3.
Вопрос 8.5.
При подстановке варианта 3 будет скомпилирована ошибка, т.к.
IOException является проверяемым исключением, и в блоке try должна быть предусмотрена возможность его генерации. При использовании варианта 4 ошибка компиляции возникнет вследствие того, что исключению типа Exception
не предоставлен соответствующий блок catch. Вариант 2 содержит синтаксическую ошибку.
Ответ: 1.
Ответы:
8.1. 2), 5)
8.2. 1)
8.3. 4)
8.4. 2), 3)
8.5. 1)
Глава 9
Вопрос 9.1.
Методы класса File могут создавать, удалять, изменять имя каталога, но изменять корневой каталог можно только через переменные окружения.
Вопрос 9.3.
Методы класса File могут создавать файл, удалять его, изменять его имя, но к информации, содержащейся в файле, доступа не имеют.
Вопрос 9.5.
Использование transient указывает на отказ от сохранения значения помеченного поля объекта при записи объекта в поток.
Ответ: 3.
Ответы:
9.1. 4)
9.2. 2)
9.3. 2), 3)
9.4. 4)
9.5. 3)
Глава 10
Вопрос 10.1.
Интерфейсы List, Vector допускают наличие одинаковых элементов в своих реализациях. Коллекция Map запрещает наличие одинаковых ключей, но не значений. Множество Set по определению не может содержать одинаковых элементов.
Ответ: 1.
Вопрос 10.2.
Объект, не являющийся коллекцией, может быть добавлен в коллекцию только при помощи метода add(). Класс ArrayList содержит конструкторы вида ArrayList(), ArrayList(int capacity)и ArrayList(Collection c). Интерфейс List конструктора не имеет по определению.
Ответ: 1, 4.
Вопрос 10.3.
Класс Hashtable реализует интерфейс Map и наследует абстрактный класс AbstrаctMap.
Ответ: 5.
Вопрос 10.4.
Класс HashSet реализует интерфейс Set. Интерфейс SortedSet реализует класс TreeSet. Проверка instanceof проводится не по ссылке, а по объекту.
Ответ: 1.
Вопрос 10.5.
Stack, HashMap и HashSet являются классами, а AbstractMap – абстрактный класс. Интерфейсами являются SortedSet и SortedMap.
Ответ: 1, 4.
Ответы:
10.1. 1)
10.2. 1), 4)
10.3. 5)
10.4. 1)
10.5. 1), 4)
Глава 11
Вопрос 11.1.
Правильным вариантом является следующий код:
int i =
newInteger(getParameter("count")).intValue();
Метод getParameter() извлекает из формы значение параметра count в
виде строки, которая используется для инициализации объекта класса
Integer. Метод intValue() используется для преобразования к базовому
типу.
Ответ: 1.
Вопрос 11.2.
Для того чтобы изменения цвета фона стали видны пользователю, требуется перерисовка всего апплета вызовом метода paint(). Это действие можно выполнить, вызвав методы repaint()или update().
Ответ: 4.
Вопрос 11.5.
Объекты из пакета AWT могут объявляться и вызывать свои методы в любых приложениях.
Ответ: 2.
Ответы:
11.1. 1)
11.2. 4)
11.3. 5), 6)
11.4. 1), 4)
11.5. 2)
Глава 12
Вопрос 12.1.
Чтобы класс был апплетом, достаточно, чтобы его суперклассом был класс Applet. Переопределение методов производится при необходимости закрепления за апплетом каких-либо действий.
Ответ: 2.
Вопрос 12.3.
Попытка компилировать данный код приведет к ошибке вследствие того, что часть методов интерфейса WindowListener не реализована в классе
Quest3.
Ответ: 1.
Ответы:
12.1. 2)
12.2. 1)
12.3. 1)
12.4. 1), 5)
12.5. 1), 2)
Глава 13
Вопрос 13.2.
По умолчанию фреймы используют менеджер размещений BorderLayout, поэтому если при добавлении элемента на фрейм не было указано его месторасположение, то элемент займет весь фрейм. Следующий добавленный таким же образом элемент будет прорисован поверх предыдущего.
Ответ: 3.
Вопрос 13.4.
Команда add(b), вызванная во второй раз, пытается добавить на апплет уже существующий там объект. Команда add(new Button(“NO”)) каждый раз добавляет новый объект.
Ответ: 2.
Вопрос 13.5.
Метод всегда вызывается объектом, который необходимо зарегистрировать. В качестве параметра должен передаваться объект приложения или апплета, в котором размещается данный компонент.
Ответ: 2.
Ответы:
13.1 2)
13.2 3)
13.3 3)
13.4 2)
13.5 2)
Глава 14
Вопрос 14.1.
Объект потока создается только после вызова конструктора класса Thread или его подкласса, но к ошибке компиляции создание такого объекта, как в примере, не приведет. Поток всегда запускается вызовом метода start(). Результатом же вызова метода run() будет выполнение кода метода run(), никак не связанное с потоком. В данной ситуации ошибка компиляции произойдет из-за того, что сигнатура метода run() в интерфейсе Runnable не совпадает с его реализацией в классе Q, т.е. метод не реализован и класс Q должен быть объявлен как abstract.
Ответ: 4.
Вопрос 14.2.
Поток t1 не входит ни в одну группу, поэтому его приоритет останется неизменным, т.е. 7. Вызов метода setMaxPriority() для группы потоков с параметром 8 большим, чем 5, приведет к тому, что приоритет группы потоков, а следовательно, и потока t2 будет установлен как NORMAL_PRIORITY.
Ответ: 1.
Вопрос 14.3.
Поток t1 не может быть создан, т.к. класс T1 не имеет метода start(), но создать его можно, например, командой
Thread t1 = new Thread(new T1());
Объект t2 не может быть создан, т.к. у класса T2 нет конструктора, способного принимать параметры.
Ответ: 3, 4.
Вопрос 14.4.
Методы sleep(), wait() приводят к временной остановке и переходу в состояние “неработоспособный”. Методы notify() и notifyAll() не имеют отношения к изменению состояния потоков, они лишь уведомляют другие потоки о снятии изоляции с синхронизированных ресурсов. Метод stop() и завершение выполнения метода run() приводят поток в состояние “пассивный”, из которого запуск потока с тем же именем возможен только после инициализации ссылки.
Ответ: 2, 3.
Вопрос 14.5.
При запуске приложения будет создано два потока r и t, но стартует только второй. Поток t инициализирован с использованием ссылки на первый поток. Это обстоятельство в данном контексте не оказывает влияния на выполнение второго потока. В итоге метод run() будет вызван только один раз.
Ответ: 3.
Ответы:
14.1. 4)
14.2. 1)
14.3. 3), 4)
14.4. 2), 3)
14.5. 3)
Глава 15
Вопрос 15.1.
Класс Socket поддерживает TCP-соединения. Порт 23 зарезервирован для протокола Telnet, являющегося подчиненным протоколом TCP/IP. Для UDP-соединений существует класс DatagramSocket.
Ответ: 3.
Вопрос 15.2.
Для получения содержимого страницы сначала создается объект URL, затем вызывается метод getContent().
Ответ: 2.
Вопрос 15.4.
Соответствующий конструктор класса Socket имеет вид:
public Socket(String host, int port)
throws UnknownHostException, IOException
Ответ: 1, 3.
Вопрос 15.5.
Команда p.flush() поместит сообщение в поток, ассоциированный с сокетом, а команда s.close() закроет сокет после обмена информацией с клиентом.
Ответ: 1, 4.
Ответы:
15.1. 3)
15.2. 2)
15.3. 1)
15.4. 1), 3)
15.5. 1), 4)
Глава 16
Вопрос 16.1.
Для описания структуры данных используются только XSD и DTD. XSL используется для преобразований документа XML. CSS – каскадная таблица стилей для HTML.
Ответ: 1, 3.
Вопрос 16.2.
В строке 5 для тега </name> отсутствует открывающий тег. В строке 6 для тега <name> отсутствует закрывающий тег.
Ответ: 5, 6.
Вопрос 16.3.
Имя тега не может содержать пробельные символы или начинаться с цифры.
Ответ: 2, 4.
Вопрос 16.4.
Значения атрибутов XMLмогут помещаться только в двойные кавычки или апострофы.
Ответ: 1, 2.
Ответы:
16.1. 1), 3)
16.2. 5), 6)
16.3. 2), 4)
16.4. 1), 2)
16.5. 5)
Глава 17
Ответы:
17.1. 6)
17.2. 3)
17.3. 1), 4)
17.4. 1)
17.5. 3)
17.6. 2)
Глава 18
Вопрос 18.1.
Вызов getServletConfig(), как правило, осуществляется из метода init() и возвращает объект ServletConfig, соответствующий этому сервлету, а вызов метода getInitParameter(String str) класса ServletConfig возвращает значение требуемого параметра. Объект класса HttpServlet также может вызвать этот метод. Параметры инициализации хранятся в XML-файле.
Ответ: 2, 3.
Вопрос 18.2.
Щелчок по ссылке посылает GET запрос по умолчанию, который обрабатывается методом doGet() сервлета. Чтобы вызвать метод doPost(), тип запроса нужно указывать явно.
Ответ: 1.
Вопрос 18.3.
Перед обработкой самого первого запроса контейнер сервлетов вызывает метод init() сервлета. После того как метод выполнился, сервлет может отвечать на запросы пользователей. При этом не имеет значения, отслеживалась сессия пользователя или нет, создавался новый поток выполнения или нет.
Ответ: 4, 5.
Вопрос 18.5.
ServletOutputStream и ServletContextEvent – классы пакета javax.servlet. PageContext – класс пакета javax.servlet.jsp. Интерфейсами указанного пакета являются ServletRequest и Servlet.
Ответ: 1, 4.
Вопрос 18.6.
Следует обратить внимание на тип тега <input> на форме. На самом деле форма посылает файл. Данные из файла могут быть получены в сервлете из объектов ServletInputStream (для бинарных файлов) или Reader (для текстовых файлов), извлеченных из запроса.
Ответ: 3, 4.
Ответы:
18.1. 2), 3)
18.2. 1)
18.3. 4), 5)
18.4. 3)
18.5. 1), 4)
18.6. 3), 4)
Глава 19
Вопрос 19.1.
Для объявления переменных предназначен тег <%! %>, внутри которого должен находиться компилируемый без ошибок код Java, завершаемый символом ‘;’ или заключенный в фигурные скобки.
Ответ: 3.
Вопрос 19.2.
Неявные переменные существуют на протяжении всего жизненного цикла сервлета и ограничены только областью видимости. Переменные this и page суть одна и та же переменная, представляющая текущий экземпляр JSP. Переменная exception создается только при возникновении ошибки на странице и до-
ступна только на странице обработки ошибок.
Ответ: 2, 3, 4.
Вопрос 19.4.
Созданный экземпляр будет обладать областью видимости в пределах приложения и представляет собой контейнер для исполнения JSP типа ServletContext.
Ответ: 3.
Вопрос 19.5.
Для получения значения свойства компонента используется действие jsp:getProperty в виде:
<jsp:getProperty name="имяКом" property="имяСв" />
Ответ: 4.
Ответы:
19.1. 3)
19.2. 2), 3), 4)
19.3. 4)
19.4. 3)
19.5. 4)
Глава 20
Вопрос 20.1.
Объект DriverManager для установки соединения с БД использует драйвер БД и ее URL. Объект DataSource использует имя для поиска объекта.
Ответ: 1, 2.
Вопрос 20.2.
Производитель СУБД должен создать и предоставить драйвер для
соединения с БД. Все драйвера должны реализовывать интерфейс java.sql.Driver.
Ответ: 1.
Вопрос 20.3.
МетодgetMetaData()извлекает из установленного соединения объект DatabaseMetaData, в котором определен целый ряд методов, позволяющих получить информацию о состоянии БД и ее таблиц.
Ответ: 1.
Вопрос 20.5.
Метод executeUpdate()используется для выполнения SQL-операторов, производящих изменения в БД. Метод execute() применяется, если неизвестен тип данных, возвращаемых оператором SQL. Метод executeBatch() применяется для выполнения группы команд SQL. Метод executeQuery() возвращает результат выполнения оператора SELECT, упакованный в объект ResultSet.
Ответ: 2.
Ответы:
20.1. 1), 2)
20.2. 1)
20.3. 1)
20.4. 4)
20.5. 2)
Глава 21
Вопрос 21.3.
У метода getSession() объекта-запроса есть две разновидности: без параметров и форма getSession(boolean create). Вызов getSession(true) указывает на необходимость создания объекта-сессии, если он не существует. Других способов извлечения сессии из объекта-запроса нет.
Ответ: 1, 7.
Вопрос 21.4.
Имя файла cookie передается конструктору и далее не может быть изменено. Метода setName(String name) у файла cookie не существует. В то же время значение файла передается конструктору и впоследствии может быть изменено при помощи вызова метода setValue(String value). Браузер накладывает ограничение на размер каждого файла cookie (не более 4 Kb) и общее количество cookie (не более 20 cookie для одного Web-сервера и всего не более 300). Максимальное время существования файла cookie устанавливается с помощью метода setMaxAge(int expiry), но значение параметра должно быть задано в секундах.
Ответ: 1, 3, 4.
Вопрос 21.5.
Конструктор Cookie(String name, String value) использует два параметра: имя файла в качестве первого, а его значение – в качестве второго. Имя не должно начинаться с символа ‘$’ и содержать запятых, точек с запятой, пробелов. Подобные требования накладываются и на значение cookie, т.е. оно не должно содержать круглых и фигурных скобок, пробелов, знака равенства, запятых, двойных кавычек, слэшей, двоеточия, точки с запятой и т.д.
Ответ: 5, 6.
Вопрос 21.6.
Объекты, представляющие cookies, присоединяются к объекту-ответу HttpServletResponse req только при помощи метода addCookie().
Ответ: 2.
Ответы:
21.1. 2)
21.2. 1), 2), 5)
21.3. 1), 7)
21.4. 1), 3), 4)
21.5. 5), 6)
21.6. 2)
Глава 22
Вопрос 22.2.
Если метод doAfterBody()вернет значение EVAL_BODY_TAG, то контейнер вызовет метод еще раз. Контейнер прекратит обработку, если будет возвращено значение SKIP_BODY.
Ответ: 5.
Вопрос 22.3.
Если метод doStartTag() вернет значение SKIP_BODY, то это значит, что тело тега не будет обработано и должен вызваться метод, завершающий работу тега, – doEndTag().
Ответ: 4.
Вопрос 22.6.
Метод имеет сигнатуру
public void doInitBody() throws JSPException,
поэтому он не возвращает конкретных значений и может быть переопределен.
Ответ: 2, 4.
Ответы:
22.1. 2)
22.2. 5)
22.3. 4)
22.4. 5)
22.5. 2), 3)
22.6. 2), 4)
22.7. 1)
Пособие расширяет и включает переработанную и обновленную версию предыдущей книги авторов «Java 2. Практическое руководство», изданную в 2005 г. Рассмотренный материал относится к программированию на Java SE 6 и J2EE.
Книга написана на основе учебных материалов, использующихся в процессе обучения студентов механико-математического факультета и факультета прикладной математики и информатики Белгосуниверситета, а также слушателей курсов повышения квалификации и преподавательских тренингов EPAM Systems, Sun Microsystems и других учебных центров по ряду направлений технологий Java. При изучении Java знание других языков необязательно, книгу можно использовать для обучения программированию на языке Java «с нуля».
Интересы авторов, направленные на обучение, определили структуру этой книги. Она предназначена как для начинающих изучение Java-технологий, так
и для продолжающих обучение на среднем уровне. Авторы считают, что «профессионалов» обучить нельзя, ими становятся только после участия в разработке нескольких серьезных Java-проектов. В то же время данный курс может служить ступенькой к мастерству. Прошедшие обучение по этому курсу успешно сдают различные экзамены, получают международные сертификаты и в состоянии
участвовать в командной разработке промышленных программных проектов.
Книга разбита на три логических части. В первой части даны фундаментальные основы языка Java и концепции объектно-ориентированного программирования. Во второй части изложены наиболее важные аспекты применения языка,
в частности коллекции, многопоточность и взаимодействие с XML. В третьей части приведены основы программировании распределенных информационных систем с применением сервлетов, JSP и баз данных, а также сформулированы основные принципы создания собственных библиотек тегов.
В конце каждой главы даются тестовые вопросы по материалам данной главы и задания для выполнения по рассмотренной теме. Ответы и пояснения к тестовым вопросам сгруппированы в отдельный блок.
В приложениях приведены дополнительные материалы, относящиеся к использованию HTML в информационных системах, основанных на применении Java-технологий, краткое описание портальных приложений и популярных технологий Struts и Hibernate для разработки информационных систем, а также Apache Ant для сборки этих приложений.
В создании некоторых приложений участвовали сотрудники EPAM Systems: приложение «UML» написано совместно с Валерием Масловым; приложение «Базы данных и язык SQL» написано Тимофеем Савичем; корректировка главы «XML&Java» и приложений «Struts» и «Hibernate» выполнена Сергеем Волчком; корректировка приложения «Apache Ant» и раздел «Основные понятия ООП» выполнены Евгением Пешкуром; приложение «JavaScript» создано при участии Александра Чеушева.
В разработке примеров принимали участие студенты механико-математического факультета и факультета прикладной математики и информатики БГУ. Авторы благодарны всем, принимавшим участие в подготовке этой книги.
ОСНОВЫ ЯЗЫКА JAVA
В первой части книги излагаются вопросы, относящиеся к основам языка Java и технологии объектно-ориентированного программирования.
Глава 1
ВВЕДЕНИЕ В КЛАССЫ И ОБЪЕКТЫ
Основные понятия ООП
Возможности программирования всегда были ограничены либо возможностями компьютера, либо возможностями человека. В прошлом веке главным ограничением были низкие производительные способности компьютера. В настоящее время физические ограничения отошли на второй план. Со всё более глубоким проникновением компьютеров во все сферы человеческой деятельности, программные системы становятся всё более простыми для пользователя и сложными по внутренней архитектуре. Программирование стало делом команды и на смену алгоритмическим идеологиям программирования пришли эвристические, позволяющие достичь положительного результата различными путями.
Базовым способом борьбы со сложностью программных продуктов стало объектно-ориентированное программирование (ООП), являющееся в настоящее время наиболее популярной парадигмой. ООП предлагает способы мышления
и структурирования кода.
ООП – методология программирования, основанная на представлении программного продукта в виде совокупности объектов, каждый из которых является экземпляром конкретного класса. ООП использует в качестве базовых элементов эвристическое взаимодействие объектов.
Объект – реальная именованная сущность, обладающая свойствами и проявляющая свое поведение.
В применении к объектно-ориентированным языкам программирования понятие объекта и класса конкретизируется, а именно:
Объект – обладающий именем набор данных (полей объекта), физически находящихся в памяти компьютера, и методов, имеющих доступ к ним. Имя используется для доступа к полям и методам, составляющим объект. В предельных случаях объект может не содержать полей или методов, а также не иметь имени.
Любой объект относится к определенному классу.
Класс содержит описание данных и операций над ними.
В классе дается обобщенное описание некоторого набора родственных, реально существующих объектов. Объект – конкретный экземпляр класса.
В качестве примера можно привести чертеж танка или его описание (класс)
и реальный танк (экземпляр класса, или объект).
Рис. 1.1. Описание класса (чертеж) и реальный объект
| Tank |
| - |
| cannon: int |
| - |
| model: String |
| - |
| speed: int |
| + |
| go() : void |
| + |
| init() : void |
| + |
| repair() : void |
| + |
| shoot() : void |
Класс принято обозначать в виде прямоугольника, разделенного на три части:
Рис. 1.2. Графическое изображение класса
Объектно-ориентированное программирование основано на принципах:
- абстрагирования данных;
- инкапсуляции;
- наследования;
- полиморфизма;
- «позднего связывания».
Инкапсуляция (encapsulation) – принцип, объединяющий данные и код, манипулирующий этими данными, а также защищающий в первую очередь данные от прямого внешнего доступа и неправильного использования. Другими словами, доступ к данным класса возможен только посредством методов этого же класса.
Наследование (inheritance) – это процесс, посредством которого один объект может приобретать свойства другого. Точнее, объект может наследовать основные свойства другого объекта и добавлять к ним свойства и методы, характерные только для него.
Наследование бывает двух видов:
одиночное – класс (он же подкласс) имеет один и только один суперкласс (предок);
множественное – класс может иметь любое количество предков (в Java запрещено).
| Auto |
| Tank |
Графически наследование часто изображается в виде диаграмм UML:
Рис. 1.3. Графическое изображение наследования
Класс «Auto» называется суперклассом, а «Tank» – подклассом.
Полиморфизм (polymorphism) – механизм, использующий одно и то же имя метода для решения двух или более похожих, но несколько отличающихся
задач.
Целью полиморфизма применительно к ООП является использование одного имени для задания общих для класса действий. В более общем смысле концепцией полиморфизма является идея «один интерфейс, множество методов».
Механизм «позднего связывания» в процессе выполнения программы определяет принадлежность объекта конкретному классу и производит вызов метода, относящегося к классу, объект которого был использован.
Механизм «позднего связывания» позволяет определять версию полиморфного метода во время выполнения программы. Другими словами, иногда невозможно на этапе компиляции определить, какая версия переопределенного метода будет вызвана на том или ином шаге программы.
Краеугольным камнем наследования и полиморфизма предстает следующая парадигма: «объект подкласса может использоваться всюду, где используется объект суперкласса».
При вызове метода класса он ищется в самом классе. Если метод существует, то он вызывается. Если же метод в текущем классе отсутствует, то обращение происходит к родительскому классу и вызываемый метод ищется у него. Если поиск неудачен, то он продолжается вверх по иерархическому дереву вплоть до корня (верхнего класса) иерархии.
Язык Java
Объектно-ориентированный язык Java, разработанный в Sun Microsystems, предназначен для создания переносимых на различные платформы и операционные системы программ. Язык Java нашел широкое применение в Интернет-приложениях, добавив на статические и клиентские Web-страницы динамическую графику, улучшив интерфейсы и реализовав вычислительные возможности. Но объектно-ориентированная парадигма и кроссплатформенность привели к тому, что уже буквально через несколько лет после своего создания язык практически покинул клиентские страницы и перебрался на сервера. На стороне клиента его место занял язык JavaScript.
При создании язык Java предполагался более простым, чем его синтаксический предок С++. На сегодняшний день с появлением версий J2SE 1.5.0 (Тигр) и Java SE 6 (Мустанг) возможности языка Java существенно расширились и во многом перекрывают функциональность С/С++/С#. Отсутствие указателей (наиболее опасного средства языка С++) нельзя считать сужением возможностей,
а тем более недостатком, это просто требование безопасности. Возможность работы с произвольными адресами памяти через бестиповые указатели позволяет игнорировать защиту памяти. Отсутствие в Java множественного наследования легко заменяется на более понятные конструкции с применением, например, интерфейсов.
Системная библиотека классов языка Java содержит классы и пакеты, реализующие и расширяющие базовые возможности языка, а также сетевые возможности, взаимодействие с базами данных, графические интерфейсы и многое другое. Методы классов, включенных в эти библиотеки, вызываются из JVM (Java Virtual Machine) во время интерпретации программы.
В Java все объекты программы расположены в динамической памяти – куче (heap) и доступны по объектным ссылкам, которые, в свою очередь, хранятся в стеке (stack). Это решение исключило непосредственный доступ к памяти, но усложнило работу с элементами массивов и сделало ее менее эффективной по сравнению с программами на C++. В свою очередь, в Java предложен усовершенствованный механизм работы с коллекциями, реализующими основные динамические структуры данных и списки. Необходимо отметить, что объектные ссылки языка Java содержат информацию о классе объектов, на которые они ссылаются, так что объектные ссылки – это не указатели, а дескрипторы объектов. Наличие дескрипторов позволяет JVM выполнять проверку совместимости типов на фазе интерпретации кода, генерируя исключение в случае ошибки. В Java изменена концепция организации динамического распределения памяти: отсутствуют способы программного освобождения динамически выделенной памяти. Вместо этого реализована система автоматического освобождения памяти (сборщик мусора), выделенной с помощью оператора new.
Стремление разработчиков упростить Java-программы и сделать их более понятными привело к необходимости удаления из языка файлов-заголовков
(h-файлов) и препроцессорной обработки. Файлы-заголовки С++, содержащие прототипы классов и распространяемые отдельно от двоичного кода этих классов, усложняют управление версиями, что дает возможность несанкционированного доступа к частным данным. В Java-программах спецификация класса и его реализация всегда содержатся в одном и том же файле.