Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
yjГЛАВА
1
ГЛАВА
1
ГЛАВА 1
Краткий обзор
Спешите увидеть Европу!
Десять стран за семнадцать дней!
Из рекламного плаката,
выставленного в витрине
одной туристической фирмы
в этой главе мы с вами бегло рассмотрим различные вопросы программирова ния на языке Java™, чтобы вы смогли почувствовать жажду новых знаний и по быстрее приступить к работе. Мы вкратце осветим основные аспекты языка, не погружаясь в детали, - подробностям, касающимся тех или иных особенностей применения Java, посвящены все остальные главы книги.
1.1. На старт ...
Программы на языке Java создаются из классов (classes). Используя объявле ние класса, можно построить любое число объектов (objects), или, как еще гово рят, экземпляров (instances), класса. Класс легко представить в виде сборочного цеха, действующего на основании четких инструкций и чертежей, а объекты в роли изделий, которые цех производит.
Класс содержит члены, которые относят к двум основным категориям- полям (fields) и методам (rnethods). Поля - это элементы данных, принадле жащие либо непосредственно самому классу, либо его объектам; значения полей в совокупности определяют состояние объекта или класса, Методы - это набо ры выражений (expressions), предназначенные для выполнения операций с полями объекта/класса и изменения его состояния. Выражениями задаются харак теристики поведения класса: с помощью методов можно изменять содержимое полей класса и иных переменных программы, выполнять арифметические операции, вызывать другие методы и управлять потоком вычислений.
Давняя традиция гласит: первым делом при изучении любого языка программирования следует рассмотреть код, который должен вывести на экран приветствие "Здравствуй, мир!". Что ж, мы так и поступим:
class HelloWorld {
Public static void main(String[] args) {
System.out.println (“Здравствуй, мир!”);
}
}
Воспользуйтесь своим любимым текстовым редактором, введите с его помощью код программы и сохраните результат в виде файла. Затем обратитесь к
компилятору, чтобы преобразовать набранный исходный текст (soиrce code) в байт-код (bytecodes) - совокупность инструкций "машинного языка", который способна воспринимать так называемая виртуальная машина Java (Java virtual machine) (позже мы остановимся на этом подробнее). Приемы набора исходных программных текстов и их компиляции существенно зависят от того, с какой системой вы работаете. За конкретной информацией по подобным вопросам об ращайтесь к соответствующей документации. В системе, которой мы, например, пользуемся особенно часто - Java 2 Software Development Kit (Java 2 SDK), бесплатно предлагаемой компанией Sиn Microsystems, - вам достаточно сохра нить текст программы He110Wor1d в одноименном файле, He110wor1d.java. Чтобы осуществить компиляцию, введите команду
javac HelloWorld.java
Следующая команда позволяет выполнить программу: java HelloWorld
Команда вызывает метод main класса HelloWorld. Во время своей работы про грамма отображает на экране сообщение
Здравствуй, мир!
Теперь у вас есть крошечное приложение, способное делать нечто полезное, но как все-таки оно работает?
Про грамма состоит из объявления класса под названием HelloWorld, содер жащего единственный член - метод main. Описания членов класса заключают между фигурными скобками, { и }, которые следуют за наименованием класса.
Метод main служит специальной цели: будучи объявленным в тексте класса в строгом соответствии с тем, как показано выше, он вызывается всякий раз, когда класс играет роль исполняемого приложения. После вызова метод main способен создавать объекты, вычислять выражения, обращаться к другим методам и осущест влять буквально все, что может быть предусмотрено логикой конкретной задачи.
Метод main объявляется как public, с тем чтобы обратиться к нему мог ка ждый субъект (в данном случае, виртуальная машина Java), и как statiс последнее означает, что метод принадлежит самому классу и не "привязан" ни к одному из частных экземпляров этого класса.
Непосредственно перед наименованием метода задается тип возвращаемого им значения. Метод main объявлен как void - это значит, что он не возвращает каких бы то ни было значений и поэтому говорить об их типе не имеет смысла.
За наименованием метода следует список его параметров (parameters) - по следовательность (возможно, пустая) пар, каждая из которых состоит из обозна чения типа и имени-идентификатора. Параметры разделяются символом запятой и заключаются в круглые скобки, ( и ). Единственный параметр метода main это массив (array) объектов типа string, снабженный именем args. Массивы объектов обозначаются парой квадратных скобок, [], которая располагается по сле наименования типа. В данном случае args предназначается для хранения параметров командной строки программы, передаваемых при ее запуске. О мас сивах и строковых объектах класса String мы расскажем в этой главе чуть ни же, а смысл параметра метода main поясним в разделе 2.9 на странице 83.
Имя-идентификатор метода совместно со списком его параметров образуют сигнатуру (signature) метода. Сигнатура вместе со списком модификаторов
(modifiers) (таких как public и static), именем типа возвращаемого значения (retиrn type) и перечнем исключений (о последних мы расскажем в конце главы) формирует заголовок (header) метода. Наконец, об7Jявление (declaration) метода состоит из заголовка, за которым следует тело (body) метода - блок выраже ний, заключенных в фигурные скобки { И }.
В нашем примере тело метода main состоит из единственного выражения, в кото-
ром вызывается метод println (примите во внимание завершающий символ точки с запятой, ;). Обращение к методу выполняется с указанием иерархии объектов более высокого уровня (в данном случае, system.out - поле out принадлежит классу System) и названия метода (println), разделенных символом точки (.) ..
В классе HelloWorld метод print1n объекта out применяется для передачи последовательности символов, завершаемой признаком перехода на новую строку, в стандартный поток вывода. Здесь в качестве параметра метода используется строковая константа-литерал "здравствуй, мир!". Строковый литерал это набор символов, заключенный в двойные кавычки, " и
Упражнение 1.1. Наберите исходный код программы HelloWorld, откомпи лируйте и выполните ее в своей системе.
Упражнение 1.2. Попробуйте что-то намеренно нарушить в тексте HelloWorld и посмотрите, к чему это приведет.
1.2. Переменные
в следующем примере на экран выводится часть бесконечной последовательности чисел Фибоначчи, начало которой выглядит так:
1
1
2
3
5
8
13
21
34
Последовательность чисел Фибоначчи начинается с двух единиц, и каждое последующее число представляет собою сумму двух предыдущих. Программа отображения чисел Фибоначчи на экране довольно проста, но привлекательна тем, что позволяет продемонстрировать приемы использования переменных (variables), организации циклов (loops) и выполнения основных арифметических Операций. Ниже приведен текст программы.
class Fibonacci {
/** Вывод на экран последовательности
* чисел Фибоначчи, меньших 50 */
public static void main(String[] args){
int lo = 1;
int hi = 1;
System.out.println(lo);
while(hi<50){
System.out.println(hi);
1.2. ПЕРЕМЕННЫЕ 25
hi = lo + hi; // новое значение hi
lo = hi - lo; /* новое значение lo
* равное старому значению hi */
}
}
}
В примере объявляется класс Fibonacci, который, подобно HelloWorld, со держит метод main. Две первые строки main - это выражения объявления ло кальных (local) переменных, lo и hi. Переменная hi предназначена для хранения последнего найденного числа последовательности, а 1 о - предыдущего. Локальные переменные объявляются внутри блока кода, такого как тело метода, I! отличие от полей, которые входят в набор членов класса. Объявление каждой переменной должно быть снабжено описанием ее типа, которое располагают не посредственно перед идентификатором переменной. Так, переменные lo и hi от носятся к типу int, предназначенному для хранения целых 32-битовых знако вых чисел из интервала от -2³¹ до 2³¹ -1.
Язык программирования Java поддерживает встроенные «простые» типы данных, позволяющие хранить целые и булевы значения, числа с плавающей запятой и символы. Простые типы естественны и легки для понимания, чего I! общем случае не скажешь об "объектных" типах, определяемых программистом. Тип любой переменной программы должен быть задан явно. Ниже приведено краткое описание простых типов Java.
Наименование типа Допустимые значения____________________
boolean true или false
char 16-битовый символ стандарта Unicode 2.1
byte 8-битовое целое число со знаком
short 16-битовое целое число со знаком
int 32-битовое целое число со знаком
long 64-битовое целое число со знаком
float 32-битовое число с плавающей запятой, соответствующее спецификации IEEE 754-1985
double 64-битовое число с плавающей запятой, соответствующее спецификации IEEE 754-1985
__________________________________________________________________________________________
В программе Fibonacci переменные hi и lo объявлены с одновременной ини циализацией их значением 1. При объявлении переменной ее исходное значение за дается посредством выражения инициализации и оператора =. Оператор = (называемый еще оператором присваивания) сохраняет в переменной, расположен ной в левой части конструкции, результат вычисления выражения из правой части.
Локальные переменные после объявления остаются в неопределенном состоя нии до момента их инициализации. Вы вовсе не обязаны всегда инициализиро вать локальные переменные непосредственно при их объявлении, но если попы таться использовать переменную, которой исходное значение еще не присваива лось, компилятор укажет на ошибку.
Поскольку обе переменные, lo и hi, относятся к одному типу, int, мы могли бы воспользоваться краткой формой их объявления. Допустимо объявлять не-
сколько переменных одного типа, разделяя их идентификаторы (с выражениями инициализации, если таковые имеются) символом запятой. Две начальные строки тела метода main можно заменить одной, равнозначной:
int lo = 1, hi = 1;
Более удобочитаемая форма выглядит так:
int lo = 1,
hi = 1;
обратите внимание на то, что наличие в приведенном тексте символов перехода
на новую строку не изменяет смысла выражения - любые символы пробела (т.е. собственно пробелы, признаки табуляции и переход а на новую строку) используются только для удобства программиста и читателя.
Конструкция while в нашем примере демонстрирует один из способов организа
ции циклических вычислений. Значение аргумента while(логического выражения hi < 50) проверяется - если утверждение истинно (true), выполняется тело цик ла, после чего выражение вновь подвергается проверке. Процесс повторяется до тех пор, пока проверка не выявит значения ложь (false). Вообще говоря, возможны случаи, когда логическое выражение whilе никогда не принимает значения "ложь", _ такой цикл способен выполняться бесконечно, если не будет принуди тельно прерван командой break либо возникшей исключительной ситуацией.
Тело цикла whilе остоит из единственного выражения. В этом качестве мо жет выступать простое выражение (скажем, вызов не которого метода), вложен ная управляющая структура либо блок (block) - последовательность (возможно,
пустая) выражений, заключенная в фигурные скобки.
Аргументом whilе служит логическое булево выражение, которое может прини-
мать одно из двух предопределенных значений - true (истина) или false (ложь). Булевы выражения обычно формируют с помощью операторов сравнения - < (меньше), <= (меньше или равно, или не больше), > (больше), >= (больше или равно, или не меньше), == (равно) и 1= (не равно). Булево выражение hi < 50 в рассматри ваемом нами примере обозначает следующее условие: действительно ли текущее зна чение переменной hi меньше числа 50. Если условие истинно, выполняется тело Цикла, в котором предусмотрены вывод на экран текущего числа Фибоначчи и вы числение следующего. Если же переменная hi приобретает значение, большее или равное 50, управление передается на первую строку кода, следующую за телом цик ла whilе, в данном случае, это скобка, обозначающая конец объявления метода main, так что наша программа попросту завершает работу.
Чтобы вычислить очередное число последовательности Фибоначчи, мы выполня ем несколько простых арифметических операций и, как легко видеть, вновь приме няем оператор присваивания (=), сохраняющий значение из правой части выражения в переменной, расположенной в левой его части. Как вы легко догадались, оператор + (плюс) вычисляет сумму своих аргументов (операндов), а оператор - (минус) - их разность. В языке Java предусмотрено множество арифметических операторов, при меняемых по отношению к целым и вещественным числовым типам. Наиболее потребительны операторы сложения (+), вычитания (-), умножения (~) и деления (/), а некоторые другие будут рассмотрены позже.
Обратите внимание, что в примере программы Fibonacci; методу println передается числовой аргумент, в то время как ранее, в тексте HelloWor1d, нами использовался строковый. ргintln это характерный пример одной из многочис-
1.2. ПЕРЕМЕННЫЕ 27
ленных групп перегруженных методов, которые способны воспринимать аргументы различных типов. Исполняющая система Java, анализирующая типы передавае мых аргументов и их количество, самостоятельно определяет, к какому из Одноименных методов в конкретной ситуации следует обратиться. Возможность ис пользования перегруженных методов - весьма мощный инструмент языка.
Упражнение 1.3. Снабдите выводимый на экран список чисел Фибоначчи за головком.
Упражнение 1.4. Напишите программу, которая генерирует иную последовательность, например список квадратов чисел.
1.3. Комментарии
Изучая программный код примеров, вы наверняка не могли не заметить текст на обычном "человеческом" языке - он оформлен в виде комментариев (comments). Существуют три стиля комментирования, и все они проиллюстрированы в програм ме Fibonacci. Комментарии позволяют снабдить код внятными описаниями, со держащими дополнительные разъяснения, которые способны помочь будущим поль зователям программы. В роли подобного пользователя можете оказаться и вы са ми - скажем, через пару месяцев или лет. Не ленясь и подробно комментируя собственный программный код сегодня, вы существенно облегчите свою участь зав тра. Кроме того, процесс написания комментариев зачастую помогает отыскать ошибки - это вполне естественно, поскольку, пытаясь описать словами назначение конструкций программы, вы невольно вынуждены еще раз над ними поразмыслить.
Любой текст, расположенный между парами символов /* и */, компилято ром в расчет не принимается. Подобный стиль применим для написания ком ментариев, расположенных в пределах части строки, охватывающих целую строку или, в общем случае, несколько строк (как в нашем примере). Для того чтобы снабдить комментарием целую строку или ее часть, удобно применить па ру символов / /, которая предписывает компилятору игнорировать все, что нахо дится далее в пределах той же строки.
Третий способ комментирования, предусматривающий использование конст рукций /** и */, продемонстрирован в самом начале программы. Комментарии с двумя символами звездочки (*) в начале применяют для документирования про грамм и называют кратким термином doc commeпts. Комментарии документиро вания предназначены для описания следующих за ними объявлений. В рассматри ваемом при мере подобный комментарий предшествует объявлению метода main. Если комментарии оформлены в строгом соответствии с указанным правилом, код может быть успешно обработан специальными программными средствами, позво ляющими автоматически извлечь информацию комментариев и сгенерировать на ее основе удобную справочную документацию. В соответствии с принятым согла шением строки, заключенные в пределах комментария документирования или обычного комментария в стиле /* ... * /, снабжаются начальным символом звез дочки (*), который игнорируется инструментами автоматического документирова ния и позволяет наглядно указать читателю границы комментария.
28 ГЛАВА 1. КРАТКИЙ ОБЗОР
1.4. Именованные константы
Константы (constants) - это значения вида 12, 17.9 или "строка, подоб ная этой". Константы - или, каких еще называют, литералы (literals) предлагают удобный способ задания значений, которые не нуждаются в первоначальных и повторных вычислениях и, по определению, остаются неизменными на протяжении всего сеанса
работы программы.
В примере Fibonacci, мы выводили на экран фрагмент возрастающей последовательности значений, не превышающих 50. Константа 50 была использована :IIУТРИ логического условия цикла whil е и комментария документирования, описывающего метод main. Теперь предположим, что текст программы следует "заменить таким образом, чтобы она отображала все числа Фибоначчи, меньшие 100. Вам придется последовательно просмотреть код с целью обнаружения и ис правления всех экземпляров константы 50. Согласны, в данном примере сделать ЭТО несложно, но в общем случае подобный процесс заведомо трудоемок и чреват ошибками. Кроме того, читателю, встречающему в тексте программы выраже ние, схожее с hi < 50, подчас бывает трудно понять его истинный смысл. По добные числа (о них в шутку говорят как о "магических") серьезным образом сужают возможности восприятия кода и его дальнейшего развития.
Именованная константа (named constant) - это постоянное значение, на кото рое можно сослаться по имени. Например, в программе Fibonacci верхнюю грани цу выводимых значений уместно обозначить идентификатором МАХ. Если говорить о синтаксисе, именованная константа объявляется в виде поля соответствующего типа, инициализированного требуемым значением. Такое выражение само по себе еще не будет именованной константой - это всего лишь обычное поле, значение которого задано с помощью оператора присваивания. Чтобы снабдить значение признаком "постоянства", в объявлении поля надлежит употребить модификатор final. Поле или переменная, обозначенные служебным словом final, будучи инициализирован ными один раз, далее не способны к изменению исходных значений - они приобре тают свойство устойчивости. Кроме того, поскольку именованную константу не имеет смысла различать в составе отдельных экземпляров одного и того же класса, в ее объявлении употребляют модификатор statiс.
Теперь пример программы Fibonacci легко переписать следующим образом:
class Fibonacci2 {
static final int MAX = 50;
/** Вывод на экран последовательности
* чисел Фибоначчи, меньших MAX */
public static void main(String[] args){
int lo = 1;
int hi = 1;
System.out.println(lo);
while(hi<MAX){
System.out.println(hi);
hi = lo + hi;
lo = hi - lo;
}
}
}
1.4. ИМЕНОВАННЫЕ КОНСТАНТЫ 29
Группу взаимосвязанных по смыслу констант удобно разместить в объявлении специального класса. Так, например, в программной реализации карточной игры может применяться следующий класс:
class Suit { // Масть
final static int CLUBS = 1; // трефы
final static int DIAMONDS = 2; // бубны
final static int HEARTS = 3; // черви
final static int SPADES = 4; // пики
}
Для ссылки на статический член класса используется название класса, Сопровождаемое символом точки и именем члена. В контексте приведенного примера значения карточных мастей далее могут быть адресованы как Suit. HEARTS
Упражнение 1.5. Исправьте текст программы HelloWorld таким образом, чтобы на экран выводилось содержимое именованной строковой константы
Упражнение 1.6. Измените программный код упражнения 1.3, предусмотрев использование в качестве заголовка последовательности чисел Фибоначчи име нованной строковой константы.
1.5. СИМВОЛЫ Unicode
Предположим, что нам потребовались класс, предусматривающий вычисление параметров окружностей, и именованная константа, представляющая значение числа π. При использовании большинства других языков программирования по добная константа получила бы такое наименование, как, скажем, pi, поскольку в качестве идентификаторов, как правило, применяются последовательности, со стоящие исключительно из букв, цифр и некоторых других знаков, доступных в привычно м наборе символов ASCII. Однако, программируя на Java, мы совер шенно вправе написать следующее
class CircleStuff {
static final double π = 3.14159265358979323846;
}
Язык программирования Jаvа позволяет нам смело вступить в сферу технологий программного обеспечения, заранее и всесторонне приспособленного к потребностям мирового сообщества: программы пишутся с применением Unicode международного стандарта символов. Символы Unicode представляются 16 битовыми числами, диапазона изменения которых вполне достаточно для набора текстов на большинстве основных языков мира. Вот почему для обозначения константы в рассматриваемом примере мы вправе употребить символ π - допустимую букву из раздела таблицы Unicode, относящегося к греческому языку. Разумеется, большая часть существующего на сегодняшний день программного кода набрана в ASCII, стандарте 7-битовых символов, либо 180 Latin-1 - в соответствии со спецификацией, отводящей каждому символу 8 битов.
30 ГЛАВА 1. КРАТКИЙ ОБЗОР
1.6. Управляющие структуры
Термином управляющие структуры обозначают конструкции языка прогр аммирования, позволяющие регламентировать порядок выполнения выражений программы. В языке Java предусмотрены и другие конструкции for, if ... else, switch и do ... whi1e. Ниже представлен дополненный вариант программы, который позволяет нумеровать числа Фибоначчи и маркировать символом звездочки те из них, которые являются четными.
class ImprovedFibonacci {
/** Вывод на экран последовательности
* нескольких чисел фибоначчи;
* четные числа помечаются символом '*' */
static final int MAX_INDEX = 9;
public static void main(String[] args){
int lo = 1;
int hi = 1;
String mark;
System.out.println("1:" + lo);
for(int i = 2;i <= MAX_INDEX;i++){
if(hi % 2 == 0)
mark = "*";
else
mark = "";
System.out.println(i + ":" + hi + mark);
hi = lo + hi;
lo = hi - lo;
}
}
}
Вот как выглядит результат работы программы:
1: 1
2: 1
3: 2*
4: 3
5: 5
6: 8*
7: 13
8: 21
9: 34*
Чтобы облегчить задачу получения номеров элементов последовательности, циклу while мы предпочли конструкцию for, в которое добавлены секции инициализации переменной цикла и измене-
1.6. УПРАВЛЯЮЩИЕ СТРУКТУРЫ 31
ния ее значения (в данном случае, приращения), можно считать обобщением whi1е. Цикл for, использованный в программе ImprovedFibonacci, равнозначен следующему циклу whi1е:
int i = 2; // объявление и инициализация переменной цикла while (i <= MAX_INDEX) {
// ... операции вычисления очередного числа фибоначчи
// и его вывода на экран ...
i++; // приращение содержимого переменной на единицу
}
Выражение for знакомит вас с новым механизмом объявления переменных: речь идет о переменной цикла, которая вводится в обиход в секции инициализации. Это весьма лаконичный и удобный способ объявления объектов, период существования которых ограничен временем выполнения цикла. Подобный при. ем допустим только в контексте конструкции for - ни одна из остальных управляющих структур не позволяет объявлять переменные непосредственно внутри выражений самой структуры. В рассматриваемом примере переменная i доступна только внутри тела цикла foг. Если переменная цикла объявлена именно таким образом, по его завершении она автоматически уничтожается это значит, что далее в тексте программы вы вновь вправе объявить переменную с тем же именем и пользоваться ею без ограничений.
Оператор ++ (плюс-плюс, или оператор инкремента), который использован в приведенном выше фрагменте кода, возможно, вам еще не знаком, если только у вас нет опыта программирования на языках, родственных С. Оператор предназначен для увеличения значения предшествующей ему переменной (в данном случае, i) на единицу. Оператор ++ может употребляться как в nрефиксной форме, когда он размещается перед идентификатором переменной, так и в постфиксной, если располагается следом. Названные формы обладают незначительными семантическими различиями, которые мы обсудим более подробно в главе 6. Оператор противоположного назначения, -- (минус-минус, или оператор декремента), служит для уменьшения величины на единицу и так же применя ется в двух формах, префиксной и постфиксной. Выражение
i++;
равнозначно следующему: i = i+1;
Выражения, в которых присваиваемое переменной значение вычисляется на основе предыдущего содержимого той же переменной, в практике программиро вания встречаются настолько часто, что в языках (и Java в том числе) преду смотрены соответствующие краткие синтаксические формы. Например, выраже ние i = i+1 может быть переписано таким образом:
i += 1;
Последнее означает, что аргумент правой части оператора += (здесь 1) прибавля ется к текущему значению переменной из левой части (в данном случае, i) и ре зультат сохраняется в той же переменной. Подобным образом разрешенo "совмещать" с оператором = все бинарные (binary) операторы языка (т.е. такие, которые предполагают наличие двух аргументов): -=, *=, /= и Т.д.
32 ГЛАВА 1. КРАТКИЙ ОБЗОР
в примере ImprovedFibonacci внутри тела цикла for мы воспользовались конструкцией if … else для про верки того, является ли текущее значение значение переменной hi четным числом.
В предложении if нашего примера с помощью оператора вычисления остатка, % проверяется условие четности значения hi - оператор определяет остаток от деления аргумента левой части (hi) на операнд правой части (2). Если значение hi четно, остаток равен нулю, Т.е. логическое выражение становится истинным, и следующий оператор присваивания сохраняет в переменной mark специальный признак четности текущего числа Фибоначчи. Предложение еlse выполняется для нечетных чисел - переменной mark присваивается пустая строка.
Команды, в которых вызывается метод println, на сей раз более сложны, поскольку аргументами println служат выражения, сами по себе подлежащие предварительному вычислению. В первом случае используется выражение "1: " + lo, которое предполагает операцию сцепления строкового литерала "1: "с содержимым числовой переменной 1о, преобразованным в символьный вид. По скольку изначально переменная lо содержит значение 1, в результате на экран будет выведена строка 1: 1. Оператор + выполняет функции сцепления строк (иногда употребляют заимствованный англоязычный термин конкатенация. Прим.. перев.), если по меньшей мере один из его аргументов представляет собой строку, и сложения - если все операнды относятся к числовым типам. Употреб ление оператора сцепления строк непосредственно в списке аргументов метода удобная краткая форма кодирования, применяемая взамен более утомительной и многословной:
String temp = "1: " + lo;
System.out.print1n(temp);
Аргументом метода println, вызываемого в теле цикла for, служит строка, со стоящая из символьного представления текущего значения переменной цикла i, к Которому далее "прицеплены" литерал разделителя ": ", преобразованное в строку Содержимое числовой переменной hi и значение строковой переменной mark.
Упражнение 1.7. Измените конструкцию for так, чтобы отсчет переменной цикла велся в обратном, убывающем, порядке.
1.7. Классы и объекты
Java, подобно МНОГИМ другим современным языкам, предоставляет в распоряжение разработчика инструменты объектно-ориентированного программирования. Каждому объекту программы отвечает класс (class), определяющий некую
1.7. КЛАССЫ И ОБЪЕКТЫ 33
структуру данных и набор способов их обработки. В составе класса могут содержаться члены (members), относящиеся к трем категориям, перечисленным ниже.
Поля (fields) - элементы данных (переменные), относящиеся к классу 11: его объектам и предназначенные для хранения информации о состоянии класса (объекта).
Методы (methods), содержащие исполняемый код класса. Методы строятся из выражений. Порядок вызова методов и наборы выражений, из которых они состоят, отвечают существу решаемой задачи.
Классы и интерфейсы (interfaces), выполняющие роль членов класса (Об интерфейсах мы расскажем ниже).
Вот как может выглядеть объявление простого класса, предназначенного для программного представления точки на плоскости:
class Point {
public double х, у;
}
Класс Роint содержит два поля, описывающих значения координат х и у точки; методы в его составе пока отсутствуют. Объявление класса, подобного названно му, определяет характеристики объектов, которые могут быть построены на его основе, и набор инструкций, задающих способы поведения этих объектов.
Члены классов могут относиться к различным уровням видимости (visibility) и доступа (accessibility). Наличие в объявлении полей х и у класса Роint слу жебного слова publiс означает, что любой код, обладающий правами доступа к объекту класса Роint, способен считывать значения этих переменных и изме нять их. Существуют и другие уровни доступа, которые ограничивают возмож ности обращения к коду класса или связанных с ним классов.
1.7.1. Создание объектов
Объекты (objects) классов, зачастую называемые экземплярами (instances), создаются с помощью выражений, содержащих служебное слово new.
Вновь созданные объекты размещаются в области системной памяти, извест ной как куча (heap). Доступ к объектам осуществляется посредством ссылок (references) - любая переменная, которая, как может показаться на первый взгляд, содержит сам объект, на самом деле хранит ссылку на этот объект. Типы подобных переменных называют ссылочными, или объектными, - в отличие от простых, когда переменные непосредственно содержат значения, соответствую щие определенному типу. Ссылке присваивается значение null, если она не от вечает ни одному реально существующему объекту.
В большинстве случаев вы вольны отступать от точной трактовки различий между действительными объектами и ссылками на них. Вполне допустимо вме сто фразы "Передать в качестве аргумента метода ссылку на объект" употреб лять более простую: "Передать методу объект". Мы будем тщательно подбирать термины только в тех ситуациях, когда это необходимо. Таким образом, если не оговорено противное, понятия объект и ссылка на объект можно считать рав ноценными и взаимозаменяемыми.
Вернемся к примеру класса Роint и предположим, что перед нами стоит за дача создания графического приложения, в котором придется иметь дело с мно-
34 ГЛАВА 1. КРАТКИЙ ОБЗОР
жеством точек. Каждая из точек может быть представлена своим собственным объектом класса Point. Приведенный ниже код показывает приемы создания и инициализации объектов класса Point.
Point lowerLeft = new Point();
Point upperRight = new Point();
Point middlePoint = new Point();
lowerLeft.x = 0.0;
lowerLeft.y = 0.0;
upperRight.x = 1280.0;
upperRight.y = 1024.0;
middlePoint.x = 640.0;
middlePoint.y = 512.0;
Каждый объект класса Роint уникален и обладает собственными копиями полей х и у. Если, например, изменить значение переменной х, принадлежащей объекту lowerLeft, это никоим образом не скажется на содержимом одноименных полей объектов upperRight и middlePoint. Такие поля называют переменными экземпляра (instance variables), поскольку в каждом экземпляре класса сущест вует независимая копия поля.
1.7.2. Статические поля
Поля, принадлежащие конкретным объектам, - это именно то, что обычно необходимо. Как правило, поля одного объекта должны быть отличны от одно именных полей других объектов того же класса.
В некоторых ситуациях, однако, полезно иметь возможность объявления по лей, общих для всех объектов класса. Подобные поля носят название перемен ных класса (class variables) и в отличие от переменных экземпляра принадлежат классу в целом.
Вполне правомерен вопрос, когда именно может возникнуть потребность в использовании переменных класса? Рассмотрим, например, фабрику компании Sony, выпускающую компактные кассетные проигрыватели. Каждый проигры ватель обладает уникальным серийным номером. Говоря в терминах объектно-ориентированного программирования, каждый экземпляр класса компактных кассетных проигрывателей содержит собственное поле для хранения серийного Номера. Но производитель обязан вести учет номеров, чтобы знать, какой поряд ковый номер следует присвоить очередному изделию. Текущее значение номера не имеет смысла хранить в каждом объекте - для этой цели достаточно предусмотреть единственную переменную уровня класса.
Чтобы получить поле, относящееся к классу в целом, выражение его объявления Следует снабдить модификатором statiс. Такие поля класса называют статическими (static).
public static Point origin = new point();
1.7. КЛАССЫ И ОБЪЕКТЫ 35
Поместив это объявление в текст класса Роint, мы Сможем гарантировать Существование в точности одной порции данных под названием Роint.огigin, кото рая всегда ссылается на объект точки с координатами (0,0). Это статическое по ле в нашем полном распоряжении, независимо от того, сколько объектов Роint мы создали (либо не создали вовсе). Значения Роint.огigin.x и Роint.огigin.у изначально равны нулю - числовое поле всегда по умолчанию инициализируется нулем, если явно не задана другая величина.
Теперь, вероятно, вы понимаете еще более точно, почему именованные Константы объявляются как статические.
Далее по ходу изложения, употребляя термин поле, мы, как правило, будем иметь в виду переменную экземпляра, хотя в некоторых случаях для ясности нами используется и выражение нестатическое поле.
1.7.3. Сборка мусора
Хорошо, объект создан с помощью оператора new, но каким образом он мо жет быть уничтожен, если необходимость в его использовании отпала? Ответ прост - достаточно перестать на него ссылаться. Объекты, ссылки на которые отсутствуют, становятся предметом заботы специального инструмента сборки му сора - тот запускается в виде фонового процесса программы, автоматически от слеживает степень актуальности данных и уничтожает объекты, лишенные ссы лок. Когда на объект более не ссылаются, сборщик мусора может тотчас удалить его из области динамически распределяемой памяти (кучи) либо отложить эту операцию до более благоприятного момента.
1.8. Методы и параметры
Объекты ранее созданного класса Роint открыты для использования в любом коде, где имеются ссылки на них, поскольку поля Роint объявлены как public.point, - это пример простейшей разновидности классов. Некоторые ре альные классы и в самом деле могут быть настолько же просты, если они проек тируются, скажем, для сугубо внутренних целей пакета (набора взаимосвязан ных классов) или в тех случаях, когда подобного тривиального контейнера данных вполне достаточно для решения какой-либо частной задачи.
Подлинные преимущества объектной модели программирования обусловлены, однако, возможностями определения в составе класса набора функций, выпол няющих обработку данных, которые принадлежат этому классу. Функции клас са реализуются в виде методов (methods) - наборов программных инструкций. Методы обладают возможностью обращения к внутренним элементам класса, доступ к которым извне запрещен. Сокрытие данных посредством методов, обес печивающее защиту "внутренностей" класса от несанкционированного доступа, служит основой важнейшей концепции инкапсуляции (encapsulation) данных.
Давайте пополним класс Роint простым методом сlеаг, объявление которого могло бы выглядеть следующим образом:
public void clear() {
x = 0;
y = 0;
}
метод clеаг не имеет параметров, поэтому список таковых, ограниченный круглыми скобками ( и ), пуст. Метод объявлен как void, а это значит, что он I'P возвращает каких бы то ни было значений. В теле метода разрешено непосредственно обращаться к любым другим методам и полям того же класса - на пример, мы просто напишем x и y, ну указывая явно полного имени класса.
1.8.1. Вызов метода
В общем случае объекты не оперируют с данными, принадлежащими другим объектам, напрямую, хотя, как было показано на примере класса Роint, возможности полного доступа к полям класса извне могут быть легко обеспечены.
Чтобы осуществить вызов (invocation) метода, следует указать имена соответ ствующего целевого (target) объекта и самого метода, разделяя их символом точки. Аргументы (arguments) передаются методу в виде списка значений, перечис ленных через запятую и заключенных в круглые скобки. При вызове методов, не предусматривающих задания параметров, круглые скобки все еще обязатель ны, хотя в промежутке между ними ничего не вводится.
Метод способен возвращать в качестве результата своей работы единственное значение. Если необходимо обеспечить возможность возврата нескольких значе ний, следует создать объект, предназначенный для хранения требуемых полей данных, и возвращать его из метода.
В момент вызова метода выполнение текущего блока кода приостанавливает ся и управление передается первой инструкции тела вызываемого метода. По за вершении кода метода управление возвращается инструкции, следующей за ко мандой вызова метода. После передачи управления коду метода целевой объект, Владеющий методом и указанный при вызове, получает статус текущего (current), или объекта-приемника (receiver), - с точки зрения самого метода. Доступ к аргументам, переданным методу, осуществляется посредством парамет ров, задаваемых в конструкции объявления метода.
Рассмотрим метод distance, который должен войти в состав класса Роint, объявленного ранее. Метод distance в качестве параметра принимает другой объект Роint, вычисляет евклидово расстояние между точками, данные о которых хранятся в текущем объекте и объекте-параметре, и возвращает это рас стояние в виде числа двойной точности с плавающей запятой.
public double distance(point that) {
double xdiff = х - that.x;
double ydiff = у - that.y;
return Math.sqrt(xdiff * xdiff + ydiff * ydiff);
}
Команда return завершает выполнение метода и передает управление тому блоку программы, откуда метод был вызван. В тексте метода distance мы воспользовались методом sqrt из состава класса Math стандартной библиотеки Java, ко-
1.8. МЕТОДЫ И ПАРАМЕТРЫ 37
торый вычисляет квадратный корень аргумента - в данном случае суммы квадратов разностей одноименных координат, х и у, двух точек плоскости.
Чтобы продемонстрировать прием вызова метода distance, мы обратимся ~ созданным ранее объектам lowerLeft и upperRight класса Point:
double d = lowerLeft.distance(upperRight);
Здесь объект upperRight передается методу distance объекта lowerLeft в качестве аргумента и выглядит в теле distance как параметр that. После выполнения: выражения переменной d будет присвоено числовое значение, равное расстоянию между точками, которые описаны объектами lowerLeft и upperRight.
1.8.2. Ссылка this
В некоторых случаях в теле метода текущего объекта удобно оперировать ссылкой на этот объект - например, если текущий объект должен сохранить се бя в некоем списке объектов. Методы способны обращаться к объекту, которому они принадлежат, посредством косвенной ссылки, обозначаемой служебным сло вом this, поскольку таковая всегда указывает на текущий объект.
Следующее объявление метода Clеаг равнозначно приведенному выше:
public void clear() {
this.x = 0;
this.y = 0;
}
Обычно слово this используют при необходимости вызова других методов с передачей ссылки на текущий объект в качестве параметра. Нередко ссылку this применяют и непосредственно в контексте метода для явного именования членов текущего объекта. Вот как может выглядеть еще один метод класса Роint, названный нами move, который изменяет значения координат точки, присваивая полям Х и у объекта величины, переданные в качестве аргументов:
public void move(double х, double у) {
this.x = х;
this.y = у;
}
Ссылка this в данном случае используется для уточнения того, о каких именно пе ременных Х и у идет речь в каждом отдельном случае. Употребление в объявлении метода move наименований параметров Х и у вполне оправданно, поскольку они предназначены для хранения передаваемых аргументов-координат. Но эти имена совпадают с идентификаторами полей класса и полностью перекрывают их в кон тексте метода. Если написать просто x = x, это будет означать, что значение пара метра x присваивается тому же параметру , но никак не одноименному полю класса, чего нам как раз и хотелось бы добиться. А выражение this.x позволяет сослаться на поле x текущего объекта и не имеет отношения к параметру x.
Упражнение 1.8. Пополните класс Роint методом, который присваивает значения координат точки текущего объекта полям объекта Роint, передаваемого в виде аргумента.
38 ГЛАВА 1. КРАТКИЙ ОБЗОР
1.8.3. Статические методы
Употребляя термин метод, мы будем подразумевать метод экземпляра, хотя некоторых случаях для ясности нами используется и выражение нестатиче ский метод (аналогичное замечание было сделано ранее при рассмотрении статических полей).
Задача самой фабрики (класса), не имеющая отношения к конкретным экземплярам изделий (объектам класса). Метод, возвра щающий значение очередного номера, целесообразно объявить как статический, по скольку он не предназначен для работы с отдельными объектами.
В теле метода distance, рассмотренного выше, для вычисления квадратного корня мы обращаемся к статическому методу Math. sqrt. Класс Math поддержи вает множество методов, полезных для решения общих задач математического характера. Подобные методы объявлены как статические, поскольку они не предназначены для применения по отношению к конкретным экземплярам клас са Math, - класс служит целям группирования функционально близких и взаи мосвязанных инструментов в единое целое.
Статическому методу запрещено непосредственно адресоваться к нестатическим членам класса. При вызове статического метода подразумевается отсутствие опреде ленного частного экземпляра класса и поэтому метод не обладает возможностью об ращения к ссылке this. Впрочем, вовсе не возбраняется передавать статическому Методу аргумент в виде явной ссылки на объект. Вообще говоря, статические методы предназначены для решения задач уровня класса, а нестатические позволяют учиты вать особенности конкретных объектов. Вызывать статический метод для обращения к Полям частного объекта - это все равно, что требовать от компании Sony измене ния серийного номера плеера, болтающегося на ремне у праздного подростка, который снует на своем скейтборде где-нибудь в районе Елисейских полей, Андреевского Спуска или ЦПКиО им. Горького.
1.9. Массивы
Простые переменные, позволяющие хранить единственное значение, безусловно, Полезны, но их возможностей для решения большинства практических задач явно не :остаточно. Например, программируя карточную игру, вы наверняка захотите одновременно хранить несколько объектов типа card (карта) и оперировать ими как единым целым. Вот здесь вам на выручку поспешат массивы (aгrays).
Массив – это набор переменных одного типа. Доступ к элементам массива возможен с помощью простых целочисленных индексов. Если продолжить
1.9. МАССИВЫ 39
пример программы, моделирующей игру в карты, объявление класса Deck (колода) могло бы выглядеть так:
public class Deck {
public static final DECK_SIZE = 52;
private card[] cards = new card[DECK_SIZE];
public void print() {
for (int i = 0; i < cards.length; i++)
system.out.println(cards[i]);
}
// ...
}
Первым делом мы объявляем константу DECK_SIZE, задающую количество карт в колоде. Константа снабжена модификатором public - теперь осведомиться об объеме колоды сможет каждый заинтересованный субъект. Далее следует определение поля cards, предназначенного для хранения ссылок на каждую из карт колоды. Поле объявлено как private - это означает, что доступ к нему получают только методы текущего класса и никому извне не дано право манипулировать данными напрямую. Признаки public и private называют модификаторами доступа (access modifiers) - они регламентируют, какие части программы и каким образом могут обращаться к классу, интерфейсу, полю или методу.
Поле cards объявлено в виде массива объектов типа Card посредством ука зания имени типа и следующей за ним пары квадратных скобок, [ и ]. С помо щью операторов присваивания и new переменная cards инициализируется мас сивом ссылок на объекты типа card, число которых равно значению DECK_SIZE. Каждой ссылке на объект card массива неявно присваивается значение null. Длина массива задается при его создании и далее никогда не изменяется.
Вызов метода println показывает, каким образом можно обращаться к эле ментам массива, задавая его имя и требуемое значение индекса, заключенное в квадратные скобки.
Изучая код класса Deck, вы могли обратить внимание, что объект массива как такового обладает полем length, которое содержит данные о длине массива. Интервал изменения индекса, обозначающий границы массива, - это диапазон целых чисел от 0 до length-l включительно. Одна из частых ошибок програм мирования связана с попытками доступа к элементам массива за пределами его границ. Для предотвращения ошибок такого рода компилятор Java снабжает каждое обращение к элементу массива инструкциями по проверке границ - если индекс элемента выходит за пределы допустимого диапазона, исполняющая сис тема регистрирует этот факт и генерирует исключение типа IndexOutOfBoundsException. Более подробную информацию по вопросам обра ботки исключительных ситуаций вы найдете в этой главе чуть ниже.
Массив нулевой длины называют пустым (empty). В теле метода, которому массив передается в качестве аргумента, обычно полезно предусмотреть проверку длины массива, чтобы убедиться, что тот действительно не пуст. Однако, прежде чем анализировать длину массива, следует удостовериться, что ссылка на массИВ реальна, Т.е. отлична от значения null. Если результат проверки любого из эти:){ условий ложен, метод может зафиксировать наличие проблемы, генерируя исключение типа IllegalArgumentException. Ниже рассмотрен пример метода, который вычисляет среднее значение элементов целочисленного массива.
40 ГЛАВА 1. КРАТКИЙ ОБЗОР
static double average(int[] values) {
if (values == null)
throw new IllegalArgumentException();
else
if (values.length == 0)
throw new IllegalArgumentException();
else {
double sum = 0.0;
for (int i =0; i < values.length; i++)
sum += values[i];
return sum / values.length;
}
}
Код вполне работоспособен, но внутренняя логика метода с трудом поддается осмыслению из-за нагромождения вложенных одна в другую конструкций if … else. Чтобы избежать необходимости применения двух выражений if, мы попытаемся, использовав булев оператор включающего ИЛИ ( | ) свести конст рукцию к единому выражению, проверяющему, равен ли аргумент значению null либо равна ли нулю его длина:
if (values = = null I values.length = = 0)
throw new IllegalArgumentException();
Увы, этот код неверен. Даже в том случае, когда значение values действительно равно null, программа все еще будет пытаться получить доступ к полю length, поскольку обычные булевы операторы всегда проверяют оба операнда. Подобная ситуация, возникающая при выполнении логических операций, настолько рас пространена, что для ее преодоления разработаны специальные операторы язы ка. Условные булевы операторы обращаются к правому операнду только в тех случаях, когда не могут вычислить результат всего выражения на основе значе ния левостороннего операнда. Код примера легко исправить, если прибегнуть к оператору условного ИЛИ С 11):
if (values = = null || values.length = = 0)
throw new IllegalArgumentException();
Теперь в случае, когда values равно null, значение всего логического выражения становится равным true и программа более не предпринимает попыток об ращения к полю length.
Бинарные булевы операторы - И ( & ), включающее ИЛИ ( 1) и исключающее ИЛИ ( || ) - существуют в двух ипостасях: они выполняют функцию логических опе раторов, когда их операнды представляют собой булевы значения.
Упражнение 1.9. Исправьте текст приложения Fibonacci, предусмотрев возможности предварительного сохранения вычисленных значений в массиве и их последующего вывода на экран.
Упражнение 1.10. Измените код программы ImprovedFibonacci таким образом, чтобы последовательность чисел заносилась в массив. Решите задачу, создав новый класс, позволяющий сохранять не только числа Фибоначчи, но и при-
1.9. МАССИВЫ 41
знак типа bооlеаn для каждого из них, который фиксирует факт четности чис ла, а затем создайте массив объектов этого класса
1.10. Объекты String
Класс String предназначен для работы с символьными последовательностями (строками), обеспечивает высокоуровневую поддержку функций их инициализа ции и предоставляет в распоряжение программиста множество методов обработ ки строковых объектов.
Со строковыми литералами вы познакомились буквально на первых стра ницах нашей книги. Когда вы пишете выражение, подобное sуstеm.оut.ргintln("Здравствуй, мир!");, компилятор на самом деле создает объект типа String, инициализирует его значением заданного стро кового литерала и затем передает методу println в качестве аргумента.
При создании строкового объекта от вас не требуется явно указывать его длину. Операции создания объекта String и его инициализации легко объеди нить в одном выражении, как показано в следующем примере:
class StringsDemo {
public static void main(String[] args) {
string myName = "Вася";
myName = myName + " Сидорчук";
sуstеm.оut.ргintln("имя = " + myName);
}
}
Мы объявляем переменную myName класса String и инициализируем ее значе нием строкового литерала. Далее, пользуясь оператором сцепления строк (+), или конкатенации, создаем новый объект String (да, именно новый - на этом аспекте более подробно мы остановимся чуть ниже) и сохраняем ссылку на него в той же переменной. Наконец, передаем методу ргintln еще один вновь соз данный объект String, содержимое которого помещается в стандартный поток вывода. Вот как выглядит на экране результат работы программы:
Имя = Вася Сидорчук
Оператор конкатенации позволено использовать и в краткой форме, +=, которая предусматривает сцепление содержимого исходного объекта, указанного в левой час ти, и переменной или литерала правой части с
последующим присваиванием резуль тата исходной ссылке. Ниже приведен измененный вариант программы.
class BetterStringsDemo {
public static void main(String[] args) {
String myName = "Вася";
String occupation = "специалист по Java";
myName += " сидорчук";
myName += " ";
myName += "(" + occupation + ")";
System.оut.рrintln("имя = " + myName);
}
}
Сейчас на экран будет выведено следующее:
42 ГЛАВА 1. КРАТКИЙ ОБЗОР
имя = Вася Cидорчук (специалист по Java)
Объект string обладает методом length, который возвращает количество символов, содержащихся в строке. Символы нумеруются индексными значения от 0 до length()-1. Символ, расположенный на определенной позиции, может быть найден с помощью метода charAt, который в качестве параметра принимает значение индекса и возвращает соответствующий индексу символ. Нетрудно выполнить и обратную операцию, связанную с получением массива таких же символов, какие хранятся в переменной String, - для этой цели применяется метод toCharArray класса String.
Объекты класса String доступны только для чтения: их содержимое после
инициализации остается неизменным. Рассмотрим следующий фрагмент кода:
str = "Вася";
// .,. здесь что-то с Васей происходит ...
str = "Сидорчук";
Второй оператор присваивания помещает новое значение в переменную str, ко торая становится ссылкой на совершенно иной строковый объект с содержимым "Сидорчук". Каждый раз при выполнении операции с объектом String (такой как, например, += в программе BetterStringsDemo) вам может показаться, что меняется только содержимое этого объекта, хотя в действительности вы полу чаете совершенно новый объект String, а "старый" остается нетронутым. В гла ве 9, где приведены более подробные сведения о классе String, рассмотрен и класс StringBuffer, который позволяет оперировать строковыми объектами, допускающими непосредственное изменение.
Метод equals обеспечивает самый простой способ сопоставления содержимо го двух объектов String и выявления факта его тождественности:
if (onestr.equals(twoStr))
// В объектах хранятся одинаковые строки
Другие методы, позволяющие сравнивать части строк или игнорировать различия в регистре отдельных символов, рассмотрены в главе 9. Оператор == (равно), Применяемый по отношению к объектам string, позволяет определить, ссылаются ли две переменные, скажем, oneStr и twoStr, на один и тот же объект, оператор не проверяет, совпадает ли их содержимое.
Упражнение 1.11. Измените код программы StringsDemo, предполагая использование различных строковых объектов.
Упражнение 1.12. Исправьте текст приложения ImprovedFibonacci таким Образом, чтобы вычисленные значения совместно с признаками четности предварительно сохранялись в массиве объектов String.
1.10. ОБЪЕКТЫ STRING 43
1.11. Наследование
Одно из основных преимуществ объектного подхода к программированию со стоит в возможности наследования (inheritance), или расширения (extending), функционального потенциала базового (родительского - superclass) класса при построении на его основе производного (дочернего - subclass) класса. Предостав ляя в распоряжение программиста новые инструменты, производный класс со храняет способность обращения ко всем элементам исходного класса. При созда нии дочернего класса тот наследует поля и методы базового класса.
Если дочерний класс не переопределяет характеристики базового класса, он ведет себя таким же образом, как и базовый, поскольку наследует всю структуру последнего. При добавлении в дочерний класс новых полей и методов тот приоб ретает дополнительные функциональные возможности.
Продолжим рассмотрение примера, касающегося производства компактных кассетных проигрывателей. Предположим, что ранее существовала базовая мо дель проигрывателя с одним гнездом для подключения наушников. В более поздних моделях предусмотрены два гнезда, которые позволяют пользоваться кассетой одновременно двум слушателям. Применяя термины объектно-ориентированного программирования, можно сказать, что модель с двумя гнез дами расширяет функциональные возможности исходной модели, обладавшей одним гнездом. Новая модель наследует характеристики базовой и обладает до полнительными свойствами.
Покупатели продукции компании Sony все еще не удовлетворены, поскольку они хотят, чтобы плеер с двумя гнездами предоставлял паре слушателей некую техническую возможность быстрого обмена мнениями. Компания внесла в мо дель с двумя гнездами конструктивные изменения и снабдила ее блоком под держки двусторонней коммуникации - теперь поклонники одного музыкально го стиля, слушая кассету, могут еще и поболтать. Модель, обеспечивающая сред ства двусторонней коммуникации, служит производным классом модели с двумя гнездами, наследует все свойства последней и обладает собственными дополни тельными характеристиками.
Sony, не останавливаясь на достигнутом, создает множество новейших моде лей - все они основаны на базовой модели, но расширяют ее функциональные возможности в том или ином направлении.
Рассмотрим при мер наследования класса. Мы расширим ранее созданный класс Роint таким образом, чтобы обеспечить возможность представления дан ных об экранном пикселе. Новый класс рiхеl, помимо хранения координат х и у пикселя, предусматривает средства описания его цвета.
class Pixel extends Point {
Color color;
public void Clear() {
super.clear();
color = null;
}
}
44 ГЛАВА 1. КРАТКИЙ ОБЗОР
Производный класс рiхеl расширяет как набор данных, так и характеристики поведения базового класса point он вводит новое поле со1ог типа Color и пе реопределяет метод с1еаг класса Роint.
Объекты класса рiхеl могут быть использованы в любом коде, предназна ченном для работы с объектами класса Роint. Например, если в списке параметров метода предусмотрен объект типа point, ничто не запрещает передать вместо него объект рiхеl - программа по-прежнему будет работать. Если в ва шем распоряжении имеется объект типа рiхеl, вы вольны пользоваться любым кодом, оперирующим объектами Роint. Подобный механизм языка носит назва ние полиморфизма (роlуmогрhism): скажем, один и тот же объект рiхе1 допускает интерпретацию в нескольких (poly-) формах (-morph) - он способен высту пать в роли собственно объекта рiхеl и принимать облик объекта Роint.
Класс рiхеl расширяет (extends) набор функций класса Роint. Расширен ные функции могут быть совершенно новыми (как, например, средства хранения информации о цвете точки); в других случаях они способны накладывать допол нительные ограничения в рамках исходной модели. Примером класса, реали зующего ограничения, может послужить тот же рiхеl, в котором предполагает ся, что соответствующие объекты пикселей должны "обитать" в пределах экра на, Т.е. значения их координат х и у обязаны удовлетворять условиям, накладываемым объектом некоего типа Screen. Если базовый класс Роint сам по себе гипотетически допускает задание координат из ограниченного диапазона, производный класс рiхеl, вводящий подобное ограничение на практике, нико им образом не нарушит правила поведения, установленные базовым классом.
Производный класс часто переопределяет функциональные характеристики базового, предлагая новые версии одного или нескольких унаследованных мето дов. С этой целью в тексте производного класса объявляются методы с теми же сигнатурами и типами возвращаемых значений, что и в базовом. В примере класса Рiхеl мы переопределили метод с1еаг, чтобы реализовать функции, ко торые требуются для решения новой задачи. Унаследованный метод с1еаг базо вого класса Роint, который в данном случае может быть вызван командой super.clear() (подробнее об этой конструкции рассказано в следующем разде ле), способен обращаться только к членам "родного" класса Роint и, что вполне очевидно, не "осведомлен" о "новшествах", таких как поле соlor, класса рiхеl.
1.11.1. Вызов методов базового класса
Чтобы снабдить объект рiхеl требуемыми функциями "очистки" своего внутреннего состояния, в классе Рiхе1 мы реализовали новую версию метода с1еаг, в теле которого посредством ссылки 5uper первым делом вызывается одноименный метод базового класса Роint. Ссылка 5uper во многом напоминает ссылку this, о которой МЫ говорили выше, за тем исключением, что 5uper позволяет адресовать элементы базового класса, а this ссылается на текущий объект.
Вызов super.clear() с точки зрения базового класса point выглядит как обычное обращение к методу сlеаг объекта Роint. После выполнения команды suрег.с1еаг()для очистки той части объекта Рiхеl, которая определена в Классе Роint, мы осуществляем дополнительную операцию присваивания ссыл ке сolог заведомо пустого и безопасного значения null.
Резонно спросить, что произойдет, не будь вызова super.сlеаr()? В этом Случае метод сlear класса рixel, разумеется, выполнит свою часть работы,
1.11. НАСЛЕДОВАНИЕ 45
присвоив переменной соlor значение null о поля х и у, которые Рiхеl унас ледовал от класса Роint, не получат каких бы то ни было "Чистых" значений. Если поля объекта - в том числе и те, которые объявлены в базовом Классе, остаются в состоянии, не отвечающем ситуации, это трудно не назвать явной ошибкой программиста.
При вызове super.тethod() Исполняющая система Java осуществляет просмотр иерархии классов в направлении от производных к базовым и пытается отыскать базовый класс, содержащий требуемый метод тethod. Если, например, класс Роint не содержал бы метода сlеаг, система перешла бы к классу, базовому по отношению к Роint, и т.д.
При вызове метода во внимание принимается класс объекта, но не тип ссыл ки на объект. Ниже приведен пример, иллюстрирующий сказанное.
Point point = new Рiхеl ();
point.clear(); // Вызывается метод сlеаг класса Рiхеl
Здесь программа обращается к методу Сlеаr класса Рiхеl, хотя переменная, содержащая объект Рiхеl, объявлена в Виде ссылки на объект класса Роint. Но если осуществить вызов super.сlеаг() из тела любого метода объекта Рiхеl, будет востребован метод сlеаг класса Роint.
1.11.2. Класс Object
Все классы - даже те из них, которые явно не расширяют какого бы то ни было базового Класса, - косвенным образом наследуют класс Object. Все объ екты Java полиморфным образом относятся к классу Object, общему (родовому) типу, и переменные этого типа могут ссылаться на объекты любого класса:
Object objRef = new Piхед();
objRef = "Какая-то строка";
Пример демонстрирует, что переменная objRef способна содержать ссылки на объекты типов Piхеl и Stгing, хотя эти классы никак между собой не связаны, за исключением того, что оба неявным образом унаследованы от класса Object. В составе класса Object объявлено несколько весьма важных методов, более подробные сведения о которых приведены в главе 3.
1.11.3. Преобразованиl Типов
Следующий фрагмент Кода, на первый взгляд, вполне приемлем (хотя и не
особенно полезен), но порождает ошибку компиляции:
String name = "Вася";
Object obj = name;
name = obj; // НЕВЕРНО: ошибка компиляции!
Мы объявляем и инициализируем ссылку на объект Stгing, присваиваем ее Пе ременной типа Object, а затем пытаемся выполнить обратное присваивание, чтобы вернуться к исходному положению вещей, сохранив в неприкосновенности дорогое сердцу имя. Что ж тут плохого? Проблема состоит в том, что хотя String - это всегда Object, Object, - это вовсе не обязательно String, и даже если в данном случае мы видим, что obj и в самом деле указывает на объ ект Stгing, компилятор не столь разумен и дальновиден. Чтобы помочь компи лятору разобраться в ситуации, следует внятно подчеркнуть, что объект, адре-
46 ГЛАВА 1.КРАТКИЙ ОБЗОР
суемый переменной obj, действительно относится к классу String и поэтому ссылку на него разрешается присвоить переменной name:
name = (String)obj; // вот так-то лучше!
Указывая компилятору на то, что выражение одного типа в действительности относится к другому типу, вы выполняете явное преобразование типов, предваряя выражение наименованием требуемого типа, заключенным в скобки. При мите к сведению, что и в этом случае компилятор не поверит вам на слово и все равно усомнится в том, говорите ли вы правду. Достаточно "образованный" компилятор может быть наделен способностью проверки правомочности предлагаемого вами преобразования еще на этапе компиляции; в противном случае он снабдит код дополнительными инструкциями, выявляющими возможность пре образования в момент выполнения про граммы. Если вы попытаетесь "обмануть" компилятор и инструкции про верки в период работы про граммы укажут на не допустимость преобразования, исполняющая система Java зарегистрирует этот факт и сгенерирует исключение типа ClassCastException. Java относится к разновидности строго типизированных языков программирования и поэтому ус танавливает весьма жесткие правила в отношении возможности взаимного при сваивания объектов различных типов.
Упражнение 1.13. Набросайте эскиз иерархии классов, отображающий зави симости между различными моделями компактных кассетных проигрывателей компании Sony, о которых мы говорили ранее. Обеспечьте сокрытие данных, объявив все поля классов как private, а методы как publiс. Какие методы следовало бы предусмотреть в базовом классе (назовем его Wa1kman), а какие це лесообразно вынести в производные классы?
1.12. Интерфейсы
Иногда в ходе проектирования возникает потребность в том, чтобы объявить Методы, которые должны поддерживаться объектами класса, не предлагая кон кретной реализации этих методов: в такой ситуации важно просто обеспечить гарантии того, что поведение объектов класса удовлетворяет совокупности некоторых критериев (ее принято называть контрактом), - детали реализации методов до определенного момента не важны. В каждом подобном объявлении Должна быть оговорена сигнатура метода и тип возвращаемого им значения, Чтобы любой класс, реализующий этот метод, подчинялся предложенному вами Контракту. Например, метод предназначен для поиска заданного объекта в некотором множестве объектов определенного типа - вас пока не интересует, каким именно образом организовано множество, к которому должен обращаться этот метод. Ваша настоящая цель состоит в том, чтобы будущие реальные версии метода одинаково успешно справлялись со связанным списком, хеш-таблицей либо любой другой структурой данных.
Для практического воплощения подобной модели действий язык программирования Java предусматривает средства определения интерфейсов. Интерфейсы подобны Классам, но содержат только заголовки (не полные объявления!) методов. Разработчик интерфейса предусматривает методы, которые должны поддерживаться классами, реализующими интерфейс, и оговаривает назначение каждого из методов. Ниже
1.12. ИНТЕРФЕЙСЫ 47
приведен пример интерфейса Lookup, содержащего метод, который Должен обеспе чить функции поиска строкового значения в массиве объектов.
interface Lookup {
/** возвращает значение, соответствующее содержимому name, либо null,
* если значение не найдено */
object find(string name);
}
В интерфейсе Lookup определен единственный метод, find, который принимает в качестве параметра объект типа String и возвращает значение, соответствую щее содержимому переданной строки, либо null, если значение не найдено. Ме тод, объявленный в интерфейсе, лишен блока тела - ответственность за его практическую реализацию возлагается на производный класс - и поэтому вме сто тела метода вводится просто символ точки с запятой. Код, в котором исполь зуются ссылки типа Lookup (ссылки на объекты классов, реализующих интер фейс Lookup), способен вызывать метод find и получать конкретные результаты независимо от действительного типа объектов:
void processvalues(String[] names, Lookup table) {
for (int i = 0; i < names.length; i++) {
object va1ue = table.find(names[i]);
if (value != null)
processvalue(names[i], value);
}
}
Класс может одновременно реализовать столько интерфейсов, сколько необ ходимо. Класс, рассмотренный в следующем примере, реализует (implements) интерфейс Lookup, используя простые массивы (для краткости мы опустили описания методов, ответственных за ввод и удаление данных).
class SimpleLookup implements Lookup {
private String[] names;
private Object[] values;
public Object find(String name) {
for (int i = 0; i < names.length; i++) {
if (names[i].equals(name))
return values[i];
}
return null; // Значение не найдено
}
// ...
}
В интерфейсе могут присутствовать объявления именованных констант, снабженные модификаторами statiс и final. Кроме того, в теле интерфейса допустимо объявлять другие, вложенные, интерфейсы и даже классы. Более подробные сведения о вложенных типах приведены в главе 5. Все члены интер фейса обладают признаком publiс, задаваемым явно или устанавливаемым кос венно, поэтому свободное обращение к ним разрешено во всех случаях, когда от крыт для доступа сам интерфейс.
48 ГЛАВА 1. КРАТКИЙ ОБЗОР
Интерфейсы позволено наследовать, или расширять, пользуясь служебным cловом extends. Интерфейс способен наследовать один или несколько базовых интерфейсов, добавляя новые константы или объявления методов, которые должны быть наполнены конкретным содержанием в некотором классе, реали зующем этот расширенный интерфейс.
Базовыми типами (supertypes) класса называют все классы, которые тот расширяет, и интерфейсы, которые реализует, включая и базовые классы и ин терфейсы более высоких уровней. В этом смысле объект следует рассматривать как экземпляр определенного класса, а также всех базовых классов, в том числе и интерфейсов. Объект может быть использован полиморфным образом по отно шению к любым его базовым классам и интерфейсам всех возможных уровней.
Упражнение 1.14. Разработайте интерфейс, который расширяет интерфейс Lookup посредством объявления методов add и remove, предусматривающих возможность ввода и удаления данных соответственно. Реализуйте расширенный интерфейс в новом производном классе.
1.13. Исключения
Что следует предпринять, если в программе возникает ошибка? Во многих языках программирования факт возникновения ошибочной ситуации фиксирует ся каким-нибудь необычным значением (скажем, -1), которое возвращается функцией, виновной в происшедшем. Программисты зачастую всецело пренебре гают средствами проверки корректности работы функций, полагая, что "вот сей час-то ошибки быть не может". Существует и другая крайность - если пытаться выявить и обработать абсолютно все ситуации, чреватые ошибками, с помощью нагромождения условных выражений, код, доселе простой и понятный, приобре тет настолько запутанный и угрожающий вид, что внешняя логика программно го текста будет совершенно утрачена. Некая заведомо простая задача, связанная, например, с пересылкой данных из файла в память, может потребовать, скажем, семи строк кода. Снабдив программу исчерпывающими инструкциями обработки ошибок, вы наверняка увеличите объем кода раз, этак, в пять или шесть. Разу меется, недопустимо, чтобы основные функции программы, ответственные за решение задачи как таковой, терялись в дебрях вспомогательных конструкций подобно иголке в стоге сена.
Справиться с проблемой обработки ошибочных ситуаций помогают средства поддержки объявляемых исключений. Применяя аппарат объявляемых исключе ний, вы как автор программы вынуждены задумываться о том, что делать с ошибками, которые, возможно, возникнут в том или ином месте кода. Если ис ключение, объявленное вами, никак не обрабатывается, об этом вы будете поставлены в известность уже на этапе компиляции, а не в момент выполнения Программы, когда не замеченные вовремя проблемы, наслаиваясь одна на другую, затрудняют поиск первичного источника ошибки.
Метод, обнаруживший неожиданную ошибочную ситуацию, генерирует, или, как принято выражаться, выбрасывает (throw), исключение. Исключения могут быть обработаны, или, попросту говоря, отловлены (catch), кодом, который, Возможно, расположен в стеке вызовов несколько ранее, - подобный код спосо бен справиться с ситуацией таким образом, как это предусмотрено программи стом, и позволить приложению продолжить работу. Исключения, не подверг-
1.13. ИСКЛЮЧЕНИЯ 49
шиеся обработке, приводят к завершению потока вычислений, но прежде Соответствующему объекту класса ThreadGroup все-таки предоставляется последний шанс каким-то наиболее приемлемым в конкретной ситуации способом "поладить" с исключением - вполне вероятно, не предложив ничего другого, кроме печальной констатации происшедшего. Классы Thread и ThreadGroup, имеющие непосредственное отношение к потокам вычислений, подробно рас смотрены в главе 10.
Исключение - это объект определенного типа, обладающий собственными полями и методами. Подход, связанный с реализацией исключений в Виде объектов, весьма плодотворен, поскольку объект исключения может содержать дан ные, методы либо то и другое одновременно, и это облегчает задачи идентифи кации конкретной ошибки и устранения ее последствий. Классы исключений обычно наследуются от базового класса Exception, в котором предусмотрено строковое поле для хранения текстовой информации об ошибке и способах ее исправления. Exception, в свою очередь, унаследован от класса Throwablе, ба зового по отношению ко всем возможным классам исключений.
Обработка исключений реализуется в рамках следующей общей конструкции: try ... catch ... finally. Программа пытается (try) выполнить определенные операции; если в результате работы возникает или Принудительно выбрасывает ся (throw) исключение, оно отлавливается (catch) и обрабатывается; и, нако нец (finallу), программа получает возможность осуществить дополнительные действия по приведению своего внутреннего состояния в порядок, необходимые либо в случае нормального протекания процесса, либо после обработки исключи тельной ситуации, независимо от того, что произошло на самом деле.
Ниже приведен пример метода getDataSet, который возвращает набор данных, считанных из файла. Если файл не может быть найден или проис ходит любая другая ошибка ввода-вывода, метод генерирует соответствующее исключение. Прежде всего мы определяем новый тип исключения BadDataSetExcepti оп, отвечающий природе вероятных ошибок. Затем в те ле некоторого класса MyUtilities объявляем метод getDataSet и с помо щью предложения throws этого объявления оговариваем, что метод способен выбрасывать исключение определенного нами типа.
class BadDataSetException extends Exception {}
class Myutilities {
public double[] getDataSet(String setName) throws
BadDataSetException
{
Ыtring file = setName + ".dset";
FilelnputStream in = null;
try {
in = new FilelnputStream(file);
return readDataSet(in);
} catch (IoException е) {
throw new BadDataSetException();
} finally {
try {
if (in != null) in.closeO;
} catch (IoException е) {
50 ГЛАВА 1. КРАТКИЙ ОБЗОР
; // Можно не обращать внимания
// данные уже получены!
}
}
}
// ... объявление метода readDataSet ...
}
Сначала, используя содержимое параметра setName, мы формируем имя файла, а затем в блоке try пытаемся открыть этот файл и прочесть данные из него с помощью метода readDataSet. При благополучном исходе readDataSet воз вращает массив значений типа doub1е, который, в свою очередь, служит ре зультатом работы метода getDataSet. Если операции открытия или Чтения файла приводят к Возникновению Исключительной ситуации, управление Переедается блоку catch. В последнем создается и выбрасывается объект Исключения BadDataSetException, подменяющий собою объект Исключения стандартного типа IOException. Некоторый код, содержащий вызов метода getDataSet, позже Сможет отловить объект Исключения созданного нами типа и отреагиро вать на обстоятельства должным образом. Далее в любой ситуации - либо После успешного открытия и чтения файла, либо вслед за инструкциями блока catch - Выполняется предложение finally, Позволяющее произвести необхо димые завершающие операции (в нашем примере - закрыть файл, если Предва рительно тот был успешно открыт). Если иключение генерируется при попытке закрытия файла, оно отлавливается, но игнорируется - в тексте вы видите от дельный символ точки с запятой, обозначающий пустое выражение. Вообще го воря, пренебрегать Исключениями, возникающими в процессе работы програм мы, не стоит, но в данном случае предполагается, что ошибка проявляется уже после успешного Извлечения данных из файла, и поэтому можно считать, что оговоренный контракт удовлетворен и миссия, возложенная на метод, Выполнена. Если ошибка повторится, она будет зафиксирована при следующей попытке работы с файлом, и тогда, вероятно, программа сможет предпринять более эффективные меры для разрешения проблемы.
Еще раз подчеркнем, что блок finally предоставляет возможность задать все необходимые инструкции восстановительного характера, Которые должны выполняться в любой ситуации. Вообще говоря, ничто не запрещает применять и такую конструкцию try ... finallу, в которой Вовсе отсутствует блок catch. Это позволит гарантировать, что код finallу будет Выполнен всегда, даже в том Случае, когда выбрасывается Исключение, для которого соответствующее предложение catch не предусмотрено.
Если метод способен генерировать Исключения, типы этих исключений должны быть перечислены в секции throws объявления метода (как в Примере, приведенном Выше). Конкретному методу Позволено выбрасывать только те Исключения, которые указаны в его объявлении, - вот почему их называют объявляемыми. В теле метода исключения могут выбрасываться либо Принудительно, посредством Выражения throw, либо косвенно, при вызове другого метода, который способен иx генерировать. Исключения классов RuntimeException, Еrror и производных от них типов относятся к категории необьявляемых исключений и могут генерироваться при любых обстоятельствах без предварительного уведомления.
Объявляемые исключения служат для описания ситуаций, которые, несмотря на их непредсказуемый и "исключительный" характер, вполне вероятны, и по-
1.18. ИСКЛЮЧЕНИЯ 51
сколыку они могут произойти, С ними приходится считаться - как, например, исключением типа IOException, которое возникает, в частности, при выполне нии файловых операций. Список генерируемых исключений, заданный в объяв лении метода, позволяет компилятору проверить код и убедиться, действительно ли метод выбрасывает только те исключения, которые им объявлены. Подобная проверка способна предотвратить ошибки в тех ситуациях, когда, например, рассматриваемый метод должен обрабатывать исключения, генерируемые другим методом, но не выполняет этого требования. С другой стороны, если наш метод вызывается другим методом, последний должен быть "уверен" в том, что первый не выбросит какого-либо исключения, которое предварительно не объявлено.
Необъявляемые исключения, возникающие в процессе работы программы, вообще говоря, служат признаком ошибочности ее логики, и вызвавшие их про блемы обычно не могут быть преодолены на этапе выполнения приложения. На пример, исключение типа IndexoutOfBoundsException, генерируемое при по пытке доступа к элементу массива, свидетельствует о том, что программа вы числяет значение индекса элемента неверно либо не проверяет корректность выражения, употребляемого в качестве индекса. Ошибки такого рода должны исправляться в исходном коде. Хотя, разумеется, любое выражение программы чревато ошибками, будет совершенно неразумно полагать, что мы обязаны пред варительно объявлять и пытаться "поймать" буквально все исключения, - этой цели и служат необъявляемые исключения.
Упражнение 1.15. Добавьте в состав класса BadDataSetException поля для хранения имени файла и объекта исключения IOException, который фиксирует проблему, чтобы код, вызывающий метод getDataSet, получил в свое распоря жение более полную информацию о природе ошибки.
1.14. Пакеты
При разработке программного кода, который, как предполагается, будет ис пользоваться повторно, возникает проблема конфликтов имен. Совершенно не важно, насколько тщательно вы подошли к задаче выбора идентификаторов соб ственных классов, - возможно, кто-то еще из числа будущих пользователей вашего кода употребит аналогичные имена для других целей. Если вы приме няете тривиальные, легко предсказуемые имена, проблема еще более усугубляет ся - те же идентификаторы почти наверняка будут использованы и другим про граммистом, который, как и вы, исповедует принцип просто ты и стремится обеспечить удобочитаемость собственного кода. Слова, подобные list (список), event (событие), component (компонент) и Т.Д., употребляются настолько часто, что их взаимное "пересечение" можно гарантировать с полной уверенностью.
Традиционное решение проблемы конфликтов имен во многих языках про граммирования состоит в использовании в идентификаторах классов (а также ти пов, глобальных функций и т.п.) префиксов, соответствующих именам пакетов. Такое соглашение позволяет создавать контексты имен, препятствующие возник новению подобных конфликтов. Префиксы обычно представляют собой аббревиа туры из нескольких символов, соответствующие наименованиям библиотек (примером может служить префикс Xt, отвечающий продукту X-Windows Toolkit).
Если код предусматривает использование всего нескольких пакетов, вероят ность возникновения конфликтов имен, очевидно, снижается. Но поскольку
52 ГЛАВА 1. КРАТКИЙ ОБЗОР
длина префиксов, как правило, невелика, возможность совпадения имен напря мую зависит от числа применяемых пакетов.
Язык Java трактует понятие пакета в виде набора объявлений классов и соответствующих производных типов. Пакетам присваиваются имена. Предполагается, что пакеты могут быть импортированы. Имя пакета оформляется в Виде иерархии Наименований типов, разделенных символом точки. При обращении к объекту па кета в тексте программы необходимо задавать его полное имя, включая и префикс самого пакета, либо воспользоваться возможностью импорта всего пакета или требуемой его части. Инструкция импорта просто предписывает компилятору об ращаться к указанному пакету за объявлениями типов, которые не описаны в тек сте прикладной программы. Задавая имена пакетов, вы препятствуете Возникновению конфликтов имен. Если два пакета содержат объявления классов с одним и тем же именем, вам достаточно полностью задать имя хотя бы одного из них.
Ниже приведен текст примера, в котором создается объект класса Date стандартного пакета uti1, позволяющий получить системные дату и время. При об ращении к классу указывается его полное имя. Как и во всех других классах, оперирующих временными данными, время отсчитывается в миллисекундах, на чиная с 00:00:00 часов 1 января 1970 года по Гринвичу.
class Date1 {
public static void main(string[] args) {
java.util.Date now = new java.util.Date();
System.out.println(now);
}
}
А теперь рассмотрим другую версию примера, в которой предусмотрена инст рукция предварительного импорта класса Date:
import java.util.Date;
class Date2 {
public static void main(String[] args) {
Date now = new Date();
System.out.println(now);
}
}
Когда компилятор, анализируя текст программы, встречает объявление объекта now, он воспринимает Date именно как тип Java.util.Date, Поскольку последний - это единственный из всех мыслимых типов Date, Который в данном Случае известен компилятору. Инструкция импорта просто предоставляет компилятору дополнительные сведения и никоим образом не означает, что в теку щий файл будут "включены" какие-то дополнительные данные.
Строго говоря, соглашение, касающееся правил именования пакетов, все еще Окончательно не разрешает проблемы конфликтов идентификаторов. Два наудачу Взятых проекта вполне могут быть реализованы в виде пакетов с одинаковыми названиями. Поэтому соглашение требует развития. Уточненные рекоменда ции Выглядят так: следует предварять наименование пакета обратным доменным Intrnеt-адресом той организации, которая создала пакет. Например, если компания АВС Corporation обладает доменным именем abc. сот, при обращении к
1.14. ПАКЕТЫ 53
разработанным ею пакетам Java необходимо предварительно задавать строку соm.abc, как, скажем, в случае com.abc.tools.
Употребление в именах пакетов разделительного символа точки иногда способно при водить к недоразумениям, поскольку тот же символ применяется и при обращении к методам и полям объектов, заданных посредством ссылок. Подоб ный синтаксис в контексте инструкции не позволяет получить вполне точный ответ на вопрос, что именно может быть импортировано. Новички часто пытаются выполнить команду в надежде избежать непри ятной повинности, связанной с вводом соответствующего префикса при каждом обращении к методу ргintln. Такой подход ошибочен, поскольку system - это класс, а out - статический объект в составе класса system, поддерживающий, в частности, и метод ргintln.
С другой стороны, java.util.Date - это класс, который может быть импортирован (часто в инструкции import применяют аргумент, подобный java. uti1 . *, если необходимо импортировать все содержимое указанного паке та). Если при попытке импорта вы сталкиваетесь с проблемой, убедитесь, что в качестве аргумента инструкции указан именно тип.
Классы всегда "обитают" в пределах пакетов. Имя пакета задается посредством соответствующего объявления, которое располагают в верхней части исходного текста:
package com.sun.games;
class Card {
//…
}
Если объявление package явно не задано, предполагается, что класс служит частью анонимного пакета (unnamed package). Способ оформления кода в виде анонимного пакета вполне приемлем, если речь идет об исполняемом приложе нии (или аплете), которое заведомо не предназначено для вызова из какой бы то ни было сторонней программы. Тексты классов, которые ориентированы на со вместное использование, должны быть размещены в именованных пакетах.
1.15. Платформа Java
Язык программирования Java спроектирован таким образом, чтобы обес печить наивысший уровень переносимости кода. Многие элементы внутрен ней структуры намеренно определены совершенно одинаковыми для всех реализаций языка. Например, тип doublе служит для представления 64 битового числа с плавающей запятой, соответствующего спецификации IEEE 754-1985. Создатели многих других языков программирования возложили обязанность по уточнению деталей на разработчиков конкретных разновид ностей систем, предназначенных для той или иной аппаратной платформы, оговорив только общие параметры, такие, например, как допустимый диапа зон изменения значений определенного числового типа, либо предоставив встроенные в язык средства обращения к операционной системе за сведения ми о подобных параметрах.
Универсальные определения, лежащие в основе языка Java как такового,
реализуются на уровне машинного языка, байт-кода, в который транслируется
54 ГЛАВА 1. КРАТКИЙ ОБЗОР
исходный текст программы. Байт-код предназначен для выполнения под управ лением виртуальной машины Java. Набор байт-кодов - это предложение языка абстрактной машины, выполняемое виртуальной машиной Java на любой плат форме, которая провозглашает поддержку языка Java.1 Программы, написанные на других языках, так же могут транслироваться в байт-код Java.
Виртуальная машина обеспечивает среду исполнения, которая позволяет при клад ной программе обращаться к самой виртуальной машине (например, принуди тельно запускать процесс сборки мусора) и взаимодействовать с окружающим миром (скажем, с помощью потоков ввода-вывода, таких как System.out). Среда исполне ния, или исполняющая система (runtime system), содержит в своем составе менеджер безопасности (security manager) или контроллер доступа (access controller), ко торый способен, например, запретить приложению обращаться к локальному диску для чтения/записи или регламентировать возможность подключения к конкретным компьютерам сети. Совокупность операций, которые разрешено выполнять, опреде ляется политикой безопасности (security policy), вступающей в силу в момент стар та приложения.
После загрузки классов в память виртуальной машины они первым делом подвергаются проверке, которая призвана гарантировать, что байт-код сформи рован надлежащим образом и удовлетворяет требованиям безопасности (например, байт-коду запрещено обращаться по абсолютным адресам памяти).
Сочетание всех названных свойств обеспечивает меру независимости системы от особенностей конкретной платформы, достаточную для реализации модели безопас ности, которая гарантирует возможность выполнения кода, загруженного из сетевых источников различных степеней надежности. Исходный программный текст, ском пилированный в байт-код Java, способен выполняться на любом компьютере, обла дающем виртуальной машиной Java. Код может быть выполнен с соблюдением тре бований соответствующего уровня защиты, что позволяет предохранить систему от вредоносных последствий выполнения программ, которые написаны неаккуратно или злонамеренно. Уровень надежности (безопасности) источника байт-кода может быть задан явно - про грамма, хранящаяся на локальном диске или в защищенной сети, заслуживает, как правило, большего доверия, нежели код неизвестного проис хождения, загруженный из Internet.
1.16. Краткие сведения о других темах
Существует ряд заслуживающих внимания вопросов, которые мы вкратце осветим ниже и более полно - далее, в соответствующих главах книги.
Потоки вычислений. Язык предлагает встроенную поддержку модели многопоточных приложений, предусматривающей, в частности, возможность использования механизмов отслеживаемых блокировок на уровне объектов и классов для синхронизации одновременного доступа к принадлежащим им данным. Более подробные сведения приведены в главе 10.
1 Вполне допустима, разумеется, и аппаратная реализация виртуальной машины Java, Предполагающая использование полупроводниковых микросхем специального назначения. По добный подход никоим образом не воздействует на степень переносимости байт-кода; речь идет Просто об альтернативном способе практического воплощения виртуальной машины.
1.16. КРАТКИЕ СВЕДЕНИЯ О ДРУГИХ ТЕМАХ 55
Типы и метаклассы. В языке предусмотрены специальные классы- оболочки (wrapper classes) для представления простых типов (такие как Integer, doublе или boolean) и реализован механизм рефлексии (ref1ection), позволяющий получать информацию об объектах программы и создавать их динамически. За деталями обращайтесь к главе 11.
Ввод-вывод. Стандартный пакет java.io содержит множество различных инструментальных средств программирования операций ввода-вывода (input/output _ I/0) данных. Информация об особенностях реализации в Java процедур ввода-вывода приведена в главе 15.
Коллекции. Пакет java.util предлагает немало полезных типов коллекций (collections) - в их числе можно назвать, например, List и HashMap. Вопросы применения классов коллекций освещены в главе 16.
Прикладные Интерфейсы u классы. Пакет java.util содержит массу любопытных классов прикладного назначения, таких как BitSet и Date. За подробностями мы отсылаем вас к главе 17.
Не так быстро, п-п-пожалуйста!
Я записываю ...
Реплика из кинофильма
56 ГЛАВА 1. КРАТКИЙ ОБЗОР