Сухов С. А.

Основы программирования на Java

Основы программирования на Java

учебное пособие

Ульяновск: УлГТУ

2006

ВВЕДЕНИЕ

Java - это язык программирования для Internet. Java - это язык для создания безопасных, переносимых, надежных, объектно-ориентированных интерактивных программ с параллельно выполняющимися подпроцессами.

Создание языка Java — это действительно один из самых значительных шагов вперед в области разработки сред программирования за последние 20 лет. Язык HTML (Hypertext Markup Language — язык разметки гипертекста) был необходим для статического размещения страниц во «Всемирной паутине» WWW (World Wide Web). Язык Java потребовался для качественного скачка в создании интерактивных продуктов для сети Internet.

Три ключевых элемента объединились в технологии языка Java и сделали ее в корне отличной от всего, существующего на сегодняшний день:

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

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

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

Программирование на Java очень привлекательно. Можно очень быстро начать писать программы, получая удовлетворительные результаты. Это пособие дает основы объектно-ориентированного программирования, необходимого для успешной работы на Java. Кроме этого, пособие знакомит с базовыми конструкциями этого языка.

ОСНОВНЫЕ ПОНЯТИЯ

1. ПЕРЕМЕННЫЕ

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

1.1. Объявление переменных

Все переменные должны быть объявлены до первого их использования в программе. Основная форма объявления переменной такова:

тип идентификатор [ = значение] [, идентификатор [ = значение ]...];

Тип — это либо один из встроенных типов, либо имя класса или интерфейса. Ниже приведено несколько примеров объявления переменных различных типов. Обратите внимание на то, что некоторые примеры включают в себя инициализацию начального значения. Переменные, для которых начальные значения не указаны, автоматически инициализируются нулем.

Таблица 1.1. Объявление переменных различных типов

№

Тип

Вид переменной

1

int а, b, с;

Объявляет три целых переменных а, b, с

2

int d = 3, е, f = 5;

Объявляет еще три целых переменных, инициализирует d и f

3

byte z = 22;

Объявляет переменную z типа byte и инициализирует ее

4

double pi = 3.14159;

Объявляет переменную pi типа double и инициализирует ее числом пи

5

char x = V;

Символьная переменная х получает значение 'х'

Идентификатор – это наименование переменной. В качестве идентификатора может использоваться любая последовательность строчных и прописных букв, цифр и символов _ (подчеркивание) и $ (доллар). Идентификаторы не должны начинаться с цифры.

Значение - это любой литерал или выражение, результатом которого является значение того же (или совместимого с указанным в объявлении переменной) типа. В приведенном ниже примере создаются три переменные, соответствующие сторонам прямоугольного треугольника, а затем с помощью теоремы Пифагора вычисляется длина гипотенузы, в данном случае числа 5, величины гипотенузы классического прямоугольного треугольника со сторонами 3-4-5.

class Variables {

public static void main (String args []){

double a = 3;

double b = 4;

double c;

с = Math.sqrt (a* a + b* b);

System.out.println ("c = "+ c);

}

1.2. Область видимости переменной

Блоки составных операторов в Java отмечаются парой фигурных скобок {}. Переменные в Java начинают действовать с того места в программе, где они объявлены до конца содержащего их блока. Блоки могут быть вложены друг в друга, и у каждого может быть свой собственный набор локальных переменных.

2. ТИПЫ

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

2.1. Простые типы

Простые типы в Java не являются объектно-ориентированными, они аналогичны простым типам большинства традиционных языков программирования. Простые типы служат для представления элементарных, содержащих единственные значения сущностей - целых и вещественных чисел, символов и логических значений. В Java имеется восемь простых типов: byte, short, int, long, char, float, double и boolean. Их можно разделить на четыре группы:

1. Целые. К ним относятся типы byte, short, int и long. Эти типы предназначены для целых чисел со знаком.

2. Типы с плавающей точкой — float и double. Они служат для представления чисел, имеющих дробную часть.

3. Символьный тип char. Этот тип предназначен для представления элементов из таблицы символов, например, букв или цифр.

4. Логический тип boolean. Это специальный тип, используемый для представления логических величин.

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

2.1.1. Числовые типы

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

В языке Java понятие беззнаковых чисел отсутствует. Все числовые типы этого языка — знаковые. Например, если значение переменной типа byte равно в шестнадцатиричном виде 0x80, то это число -1.

2.1.1.1. Целые типы

Отсутствие в Java беззнаковых чисел вдвое сокращает количество целых типов. В языке имеется 4 целых типа, занимающих 1, 2, 4 и 8 байтов в памяти. Для каждого типа — byte, short, int и long - есть свои естественные области применения.

Тип byte

Тип byte — это знаковый 8-битовый тип. Его диапазон — от -128 до 127. Он лучше всего подходит для хранения произвольного потока байтов, загружаемого из сети или из файла,

byte b;

byte с = 11;

Если речь не идет о манипуляциях с битами, использования типа byte, как правило, следует избегать. Для нормальных целых чисел, используемых в качестве счетчиков и в арифметических выражениях, гораздо лучше подходит тип int.

Тип short

Short — это знаковый 16-битовый тип. Его диапазон — от -32768 до 32767. Это, вероятно, наиболее редко используемый в Java тип, поскольку он определен как тип, в котором старший байт стоит первым,

short s;

short t= 129;

Тип int

Тип int служит для представления 32-битных целых чисел со знаком. Диапазон допустимых для этого типа значений — от -2147483648 до 2147483647. Чаще всего этот тип данных используется для хранения обычных целых чисел со значениями, достигающими двух миллиардов. Этот тип прекрасно подходит для использования при обработке массивов и для счетчиков. В ближайшие годы этот тип будет прекрасно соответствовать машинным словам не только 32-битовых процессоров, но и 64-битовых с поддержкой быстрой конвейеризации для выполнения 32-битного кода в режиме совместимости. Всякий раз, когда в одном выражении фигурируют переменные типов byte, short, int и целые литералы, тип всего выражения перед завершением вычислений приводится к int.

int i;

int j = 1000;

Тип long

Тип long предназначен для представления 64-битовых чисел со знаком. Его диапазон допустимых значений достаточно велик даже для таких задач, как подсчет числа атомов во вселенной,

long m;

long n = 123;

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

Таблица 2.1. Таблица разрядностей и допустимых диапазонов для различных типов целых чисел

№

Имя

Разрядность

Диапазон

1

long

64

-9, 223, 372,036, 854, 775, 808 ... 9, 223, 372, 036, 854, 775, 807

2

int

32

-2, 147, 483, 648 .... 2, 147, 483, 647

3

short

16

-32,768 .... 32, 767

4

byte

8

-128 ... 127

2.1.1.2. Числа с плавающей точкой

Числа с плавающей точкой, часто называемые в других языках вещественными числами, используются при вычислениях, в которых требуется использование дробной части. В Java реализован стандартный (IEEE-754) набор типов для чисел с плавающей точкой — float и double и операторов для работы с ними.

Таблица 2.2. Характеристики типов чисел с плавающей точкой

№

Имя

Разрядность

Диапазон

1

double

64

1.7e-308 .... 1.7e+ 308

2

float

32

3.4e-038 .... 3.4e+ 038

Тип float

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

float f;

float f2 = 3.14;

Тип double

В случае двойной точности, задаваемой с помощью ключевого слова double, для хранения значений используется 64 бита. Все трансцендентные математические функции, такие как sin, cos, sqrt, возвращают результат типа double,

double d;

double pi = 3.14159265358979323846;

2.1.2. Символы

Поскольку в Java для представления символов в строках используется кодировка Unicode, разрядность типа char в этом языке — 16 бит. В нем можно хранить десятки тысяч символов интернационального набора символов Unicode. Диапазон типа char — 0..65536. Unicode — это объединение десятков кодировок символов, он включает в себя латинский, греческий, арабский алфавиты, кириллицу и многие другие наборы символов,

char с;

char с2 = 0xf132;

char с3 =’а’;

char с4 = ‘\n’;

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

int  three = 3;

char one = ‘1’;

char four = (char) (three+ one);

В результате выполнения этого кода в переменную four заносится символьное представление нужной нам цифры — '4'. Обратите внимание — тип переменной one в приведенном выше выражении повышается до типа int, так что перед занесением результата в переменную four приходится использовать оператор явного приведения типа.

2.1.3. Тип boolean

В языке Java имеется простой тип boolean, используемый для хранения логических значений. Переменные этого типа могут принимать всего два значения — true (истина) и false (ложь). Значения типа boolean возвращаются в качестве результата всеми операторами сравнения, например (а < b) — об этом разговор пойдет в следующей главе. Кроме того, вы узнаете, что boolean — это тип, требуемый всеми условными операторами управления — такими, как if, while, do,

2.2. Приведение типов

Иногда возникают ситуации, когда у вас есть величина какого-то определенного типа, а вам нужно ее присвоить переменной другого типа. Для некоторых типов это можно проделать и без приведения типа, в таких случаях говорят об автоматическом преобразовании типов. В Java автоматическое преобразование возможно только в том случае, когда точности представления чисел переменной-приемника достаточно для хранения исходного значения. Такое преобразование происходит, например, при занесении литеральной константы или значения переменной типа byte или short в переменную типа int. Это называется расширением (widening) или повышением (promotion), поскольку тип меньшей разрядности расширяется (повышается) до большего совместимого типа. Размера типа int всегда достаточно для хранения чисел из диапазона, допустимого для типа byte, поэтому в подобных ситуациях оператора явного приведения типа не требуется. Обратное в большинстве случаев неверно, поэтому для занесения значения типа int в переменную типа byte необходимо использовать оператор приведения типа. Эту процедуру иногда называют сужением (narrowing), поскольку вы явно сообщаете транслятору, что величину необходимо преобразовать, чтобы она уместилась в переменную нужного вам типа. Для приведения величины к определенному типу перед ней нужно указать этот тип, заключенный в круглые скобки. В приведенном ниже фрагменте кода демонстрируется приведение типа источника (переменной типа int) к типу приемника (переменной типа byte). Если бы при такой операции целое значение выходило за границы допустимого для типа byte диапазона, оно было бы уменьшено путем деления по модулю на допустимый для byte диапазон (результат деления по модулю на число — это остаток от деления на это число),

int а = 100;

byte b = (byte) а;

2.2.1. Автоматическое преобразование типов в выражениях

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

byte а = 40;

byte b = 50;

byte с = 100;

int d = a* b / с;

Результат промежуточного выражения (а*b) вполне может выйти за диапазон допустимых для типа byte значений. Именно поэтому Java автоматически повышает тип каждой части выражения до типа int, так что для промежуточного результата (а* b) хватает места.

Автоматическое преобразование типа иногда может оказаться причиной неожиданных сообщений транслятора об ошибках. Например, показанный ниже код, хотя и выглядит вполне корректным, приводит к сообщению об ошибке на фазе трансляции. В нем мы пытаемся записать значение 50*2, которое должно прекрасно уместиться в тип byte, в байтовую переменную. Но из-за автоматического преобразования типа результата в int мы получаем сообщение об ошибке от транслятора — ведь при занесении int в byte может произойти потеря точности.

byte b = 50;

b = b* 2:

^Incompatible type for =. Explicit cast needed to convert int to byte.

(Несовместимый тип для =. Необходимо явное преобразование int в byte)

Исправленный текст:

byte b = 50;

b = (byte) (b* 2);

что приводит к занесению в b правильного значения 100.

Если в выражении используются переменные типов byte, short и int, то во избежание переполнения тип всего выражения автоматически повышается до int. Если же в выражении тип хотя бы одной переменной — long, то и тип всего выражения тоже повышается до long. Не забывайте, что все целые литералы, в конце которых не стоит символ L (или 1), имеют тип int.

Если выражение содержит операнды типа float, то и тип всего выражения автоматически повышается до float. Если же хотя бы один из операндов имеет тип double, то тип всего выражения повышается до double. По умолчанию Java рассматривает все литералы с плавающей точкой как имеющие тип double. Приведенная ниже про1рамма показывает, как повышается тип каждой величины в выражении для достижения соответствия со вторым операндом каждого бинарного оператора.

class Promote {

public static void main (String args []) {

byte b= 42;

char с = 'a’;

shorts = 1024;

int i = 50000;

float f = 5.67f;

doubled =.1234;

double result = (f*b) + (i/ c) - (d* s);

System, out. println ((f* b)+ "+ "+ (i / c)+ " -" + (d* s));

System, out. println ("result = "+ result); }

}

Подвыражение f*b — это число типа float, умноженное на число типа byte, поэтому его тип автоматически повышается до float. Тип следующего подвыражения i / с (int, деленный на char) повышается до int. Аналогично этому тип подвыражения d*s (double, умноженный на short) повышается до double. На следующем шаге вычислений мы имеем дело с тремя промежуточными результатами типов float, int и double. Сначала при сложении первых двух тип int повышается до float и получается результат типа float. При вычитании из него значения типа double тип результата повышается до double. Окончательный результат всего выражения — значение типа double.

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

class SimpleTypes {

public static void main(String args []) {

byte b = 0x55;

short s = 0x55ff;

int i = 1000000;

long l = 0xffffffffL;

char с = ’a’;

float f= .25f;

double d = .00001234;

boolean bool = true;

System.out.println("byte b = " + b);

System.out.println("short s = " +s);

System.out.println("int i =” + i);

System.out.println("long 1 = " + l);

System.out.println("char с =” + с);

System.out.println("float f = " + f);

System.out.println("double d = " + d);

System.out.println("boolean bool =” + bool); }

}

Запустив эту программу, вы должны получить результат, показанный ниже:

byte b = 85

shorts = 22015

int i = 1000000

long 1 = 4294967295

char с = a

float f = 0.25

double d=1.234e-005

boolean bool = true

Обратите внимание на то, что целые числа печатаются в десятичном представлении, хотя мы задавали значения некоторых из них в шестнадцатиричном формате.

3. МАССИВЫ

Массив - это группа переменных одного типа, доступ к которым осуществляется с помощью общего имени. Для объявления типа массива используются квадратные скобки. В приведенной ниже строке объявляется переменная month_days, тип которой — «массив целых чисел типа int».

int month_days [];

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

month_days = new int [12];

Итак, теперь month_days — это ссылка на двенадцать целых чисел. Ниже приведен пример, в котором создается массив, элементы которого содержат число дней в месяцах года (невисокосного).

class Array {

public static void main (String args []) {

int month_days[];

month_days = new int[12];

month_days[0] = 31;

month_days[l] = 28;

month_days[2] =31;

month_days[3] = 30;

month_days[4] =31;

month_days[5] = 30;

month_days[6] = 31;

month_days[7] = 31;

month_days[8] = 30;

month_days[9] = 31;

month_days[10] = 30;

month_days[ 11 ] = 31;

System.out.println("Апрель содержит” + month_days[3] +” дней.");} }

При запуске эта программа печатает количество дней в апреле. Нумерация элементов массива в Java начинается с нуля, так что число дней в апреле — это month_days [3].

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

class AutoArray {

public static void main(String args[]) {

intmonth_days[] = { 31,28,31,30,31,30, 31, 31,30,31, 30, 31 };

System.out.println("Апрель содержит " + month_days[3] + " дней."); }

}

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

3.1. Многомерные массивы

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

double matrix [][] = new double [5][2];

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

double matrix [][] = new double [5][];

matrix [0] = new double[2];

matrix[l] =new double[2];

matrix[2] = new double[2];

matrix[3] = { 0,1};

matrix[4] = { 2,3};

В следующем примере создается матрица размером 4 на 4 с элементами типа double, причем ее диагональные элементы (те, для которых х==у) заполняются единицами, а все остальные элементы остаются равными нулю.

class Matrix {

public static void main(String args[]) {

double m[][]; m = new double[4][4];

m[0][0]=l;

m[l][l] = l;

m[2][2] = l;

m[3][3] = l;

System.out.println(m[0][0] +" "+ m[0][l] +" "+ m[0][2] +" "+ m[0][3]);

System.out.println(m[1][0] +" "+ m[l][l] +" "+ m[l][2] +" "+ m[l][3]);

System.out.println(m[2][0] +" "+ m[2][l] +" "+ m[2][2] +" "+ m[2][3]);

System.out.println(m[3][0] +" "+ m[3][l] +" "+ m[3][2] +" "+ m[3][3]);

}

}

Запустив эту программу, вы получите следующий результат:

1000

0100

0010

0001

Обратите внимание — если вы хотите, чтобы значение элемента было нулевым, вам не нужно его инициализировать, это делается автоматически. Для задания начальных значений массивов существует специальная форма инициализатора, пригодная и в многомерном случае. В про1рамме, приведенной ниже, создается матрица, каждый элемент которой содержит произведение номера строки на номер столбца. Обратите внимание на тот факт, что внутри инициализатора массива можно использовать не только литералы, но и выражения.

class AutoMatrix {

public static void main(String args[]) {

double m[][]={

{ 0*0,1*0,2*0,3*0 }, { 0*1,1*1,2*1,3*1 }, { 0*2.1*2,2*2,3*2 },

{0*3,1*3.2*3,3*3 } };

System.out.println(m[0][0] +" "+ m[0][l] +" "+ m[0][2] +" "+ m[0][3]);

System.out.println(m[ 1 ][0] +" "+m[l][l] +" "+m[l][2] +" "+m[l][3]);

System.out.println(m[2][0] +" "+m[2][l] +" "+m[2][2] +" "+ m[2][3]);

System.out.println(m[3][0] +" "+m[3][l] +" "+ m[3][2] +" "+ m[3][3]);

}

}

Запустив эту программу, вы получите следующий результат:

0000

0123

0246

0369

4. ОПЕРАТОРЫ

Операторы в языке Java — это специальные символы, которые сообщают транслятору о том, что вы хотите выполнить операцию с некоторыми операндами. Типы операций указываются с помощью операторов, а операнды - это переменные, выражения или литералы. Некоторые операторы требуют одного операнда, их называют унарными. Одни операторы ставятся перед операндами и называются префиксными, другие — после, их называют постфиксными операторами. Большинство же операторов ставят между двумя операндами, такие операторы называются инфиксными бинарными операторами. Существует тернарный оператор, работающий с тремя операндами. В Java имеется 44 встроенных оператора. Их можно разбить на 4 класса — арифметические, битовые, операторы сравнения и логические.

4.1. Арифметические операторы

Арифметические операторы используются для вычислений так же как в алгебре (см. таблицу со сводкой арифметических операторов ниже). Допустимые операнды должны иметь числовые типы. Например, использовать эти операторы для работы с логическими типами нельзя, а для работы с типом char можно, поскольку в Java тип char — это подмножество типа int.

Таблица 4.1. Таблица арифметических операторов

№

Оператор

Результат

Оператор

Результат

1

+

Сложение

+ =

Сложение с присваиванием

2

-

Вычитание (также унарный минус)

- =

Вычитание с присваиванием

3

*

Умножение

* =

Умножение с присваиванием

4

/

Деление

/ =

Деление с присваиванием

5

%

Деление по модулю

% =

Деление по модулю с присваиванием

6

++

Инкремент

--

Декремент

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

class BasicMath {

public static void int a = 1 + 1;

int b = a* 3;

main(String args[]) {

int с = b / 4;

int d = b - a;

int e = -d;

System.out.print("a = " + a);

System.out.print("b = " + b);

System.out.print("c = " + c);

System.out.print("d = " + d);

System.out.println("e =” + e);

}

}

Исполнив эту программу, вы должны получить приведенный ниже результат:

a = 2

b = 6

c = 1

d = 4

e = -4

4.1.1. Оператор деления по модулю

Оператор деления по модулю - оператор mod, обозначается символом %. Этот оператор возвращает остаток от деления первого операнда на второй. Функция mod в Java работает не только с целыми, но и с вещественными типами. Приведенная ниже программа иллюстрирует работу этого оператора.

class Modulus {

public static void main (String args []) {

int x = 42;

double у = 42.3;

System.out.print("x mod 10 = " + x % 10);

System.out.println("y mod 10 = " + у % 10);

}

}

Выполнив эту программу, вы получите следующий результат:

х mod 10 = 2 у mod 10 = 2.3

4.1.2. Арифметические операторы присваивания

Для каждого из арифметических операторов есть форма, в которой одновременно с заданной операцией выполняется присваивание. Если требуется написать а += 4, то с таким же успехом можно использовать а = а +4.

Такой способ пригоден для всех бинарных операторов, которые используются в выражениях вида:

переменная = переменная оператор выражение;

Любой такой оператор можно записать в короткой форме:

переменная оператор = выражение;

4.1.3. Инкремент и декремент

В Java существует два оператора, называемых операторами инкремента и декремента (++ и --) и являющихся сокращенным вариантом записи для сложения или вычитания из операнда единицы. Эти операторы уникальны в том плане, что могут использоваться как в префиксной, так и в постфиксной форме. При использовании префиксной формы операнд модифицируется перед выполнением операции. В постфиксной форме сначала используется содержимое операнда, а лишь после этого операнд инкрементируется или декрементируется. Следующий пример иллюстрирует использование операторов инкремента и декремента.

class IncDec {

public static void main(String args[]){

int a = 1;

int b = 2;

int с = ++b;

int d = a++;

c++;

System.out.print("a = " + a);

System.out.print("b = " + b);

System.out.print("c = " + c);

System.out.println("d = " + d);

}

}

Результат выполнения данной программы будет таким:

a=2b=3c=4d=1

4.2. Целочисленные битовые операторы

Для целых числовых типов данных — long, int, short, char и byte - определен дополнительный набор операторов, с помощью которых можно проверять и модифицировать состояние отдельных битов соответствующих значений. В таблице 4.2 приведена сводка таких операторов. Операторы битовой арифметики работают с каждым битом как с самостоятельной величиной.

Таблица 4.2. Операторы битовой арифметики

№

Оператор

Результат

№

Оператор

Результат

1

&

побитовое И (AND)

8

&=

Побитовое И (AND) с присваиванием

2

1

побитовое ИЛИ (OR)

9

|=

побитовое ИЛИ (OR) с присваиванием

3

^

побитовое исключающее ИЛИ (XOR)

10

^=

побитовое исключающее ИЛИ (XOR) с присваиванием

4

>>

сдвиг вправо

11

>>=

сдвиг вправо с присваиванием

5

>>>

сдвиг вправо с заполнением нулями

12

>>>=

сдвиг вправо с заполнением нулями с присваиванием

6

<<

сдвиг влево

13

<<=

сдвиг влево с присваиванием

7

~

побитовое унарное отрицание (NOT)

В таблице 4.3 показано, как каждый из операторов битовой арифметики воздействует на возможные комбинации битов своих операндов.

Таблица 4.3

А

В

OR

AND

XOR

NOT А

0

0

0

0

0

1

1

0

1

0

1

0

0

1

1

0

1

1

1

1

1

1

0

0

Сдвиг влево

Оператор << выполняет сдвиг влево всех битов своего левого операнда на число позиций, заданное правым операндом. При этом часть битов в левых разрядах выходит за границы и теряется, а соответствующие правые позиции заполняются нулями.

Сдвиг вправо

Оператор >> означает в языке Java сдвиг вправо. Он перемещает все биты своего левого операнда вправо на число позиций, заданное правым операндом. Когда биты левого операнда выдвигаются за самую правую позицию слова, они теряются. При сдвиге вправо освобождающиеся старшие (левые) разряды сдвигаемого числа заполняются предыдущим содержимым знакового разряда. Сделано это для того, чтобы при сдвиге вправо числа сохраняли свой знак.

Беззнаковый сдвиг вправо

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

4.3. Операторы отношений

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

Таблица 4.4

№

Оператор

Результат

1

= =

равно

2

!=

не равно

3

>

больше

4

<

меньше

5

>=

больше или равно

6

<=

меньше или равно

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

Операторы отношения могут применяться только к операндам числовых типов. С их помощью можно работать с целыми, вещественными и символьными типами. Каждый из операторов отношения возвращает результат типа boolean, т.е. либо true, либо false.

4.4. Булевы логические операторы

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

Таблица 4.5. Таблица булевых логических операторов

№

Оператор

Результат

№

Оператор

Результат

1

&

логическое И (AND)

7

&=

И (AND) с присваиванием

2

|

логическое ИЛИ (OR)

8

=

ИЛИ (OR) с присваиванием

3

^

логическое исключающее ИЛИ (XOR)

9

^=

исключающее ИЛИ (XOR) с присваиванием

4

||

оператор OR быстрой оценки выражений (short circuit OR)

10

==

равно

5

&&

оператор AND быстрой оценки выражений (short circuit AND)

11

!=

не равно

6

!

логическое унарное отрицание (NOT)

12

? :

тернарный оператор if-then-else

Логические булевы операторы AND (И), OR (ИЛИ) и XOR (исключающее ИЛИ) выполняют над логическими величинами те же операции, что и их аналоги из семейства битовой логики. Унарный оператор NOT (НЕ) инвертирует логическое значение. В таблице 4.6 показаны результаты воздействия логических операторов на различные комбинации значений операндов.

Таблица 4.6

A

В

OR

AND

XOR

NOT A

false

false

false

false

false

true

true

false

true

false

true

false

false

true

true

false

true

true

true

true

true

true

false

false

Существуют два дополнения к набору логических операторов. Это альтернативные версии операторов AND и OR, служащие для быстрой оценки логических выражений. Если первый операнд оператора OR имеет значение true, то независимо от значения второго операнда результатом операции будет величина true. Аналогично в случае оператора AND, если первый операнд — false, то значение второго операнда на результат не влияет — он всегда будет равен false. Если вы используете операторы & & и || вместо обычных форм & и |, то Java не производит оценку правого операнда логического выражения, если ответ ясен из значения левого операнда. Общепринятой практикой является использование операторов && и || практически во всех случаях оценки булевых логических выражений. Версии этих операторов & и | применяются только в битовой арифметике.

4.5. Тернарный оператор if-then-else

Общая форма оператора if-then-else такова:

Выражение1 ? Выражение2 : выражениеЗ

В качестве первого операнда — «выражение 1» — может быть использовано любое выражение, результатом которого является значение типа boolean. Если результат равен true, то выполняется оператор, заданный вторым операндом, то есть «выражение2». Если же первый операнд равен false, то выполняется третий операнд — «выражениеЗ». Второй и третий операнды, то есть «выра- жение2» и «выражениеЗ», должны возвращать значения одного типа и не должны иметь тип void. В приведенной ниже программе этот оператор используется для проверки делителя перед выполнением операции деления. В случае нулевого делителя возвращается значение 0.

class Ternary {

public static void main(String args[]) {

int a = 42;

int b = 2;

int с = 99;

int d = 0;

int e = (b == 0) ? 0 : (a / b);

int f = (d == 0) ? 0 : (c / d);

System.out.print("a = " + a);

System.out.print("b = " + b);

System.out.print("c = " + c);

System.out.print("d = " + d);

System.out.print("a / b = " + e);

System.out.println("c / d = " + f);

}

}

При выполнении этой программы исключительной ситуации деления на нуль не возникает, и выводятся следующие результаты:

a = 42

b = 2

c = 99

d = 0

a/b = 21

c/d = 0

4.6. Приоритеты операторов

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

Таблица 4.7. Таблица приоритетов всех операций

№

Высший

1

( ) [] •

2

~ !

3

* / %

4

+ -

5

>> >>> <<

6

> >= < <=

7

== !=

8

&

9

^

10

|

11

&&

12

||

13

? :

14

= op=

Низший

В первой строке таблицы приведены три необычных оператора, о которых мы пока не говорили. Круглые скобки () используются для явной установки приоритета. Квадратные скобки [] используются для индексирования переменной-массива. Оператор . (точка) используется для выделения элементов из ссылки на объект.

5. УПРАВЛЕНИЕ ВЫПОЛНЕНИЕМ ПРОГРАММЫ

Управление выполнением (flow control) позволяет изменять последовательность выполнения фрагментов программы, выбирая в зависимости от состояния данных ту или иную ветвь кода. Ветвление, циклы и вызовы подпрограмм - это разновидности управления выполнением программы. Все наши программы до сих пор были полностью линейны - операторы выполнялись строго по порядку, один за другим. В более сложных программах часто требуется, чтобы в зависимости от условий выполнялись одни операторы, а другие при этом пропускались. Для управления выполнением программного кода в Java имеется несколько возможностей, основанных на использовании условных операторов.

5.1. Условный оператор if-else

Конструкция if-else позволяет в зависимости от некоторого логического значения выполнять различные части программного кода. В обобщенной форме этот оператор записывается следующим образом:

if (логическое выражение) оператор 1; [else оператор2;]

Раздел else необязателен. На месте любого из операторов может стоять составной оператор, заключенный в фигурные скобки. Логическое выражение это любое выражение, возвращающее значение типа boolean. Это может быть и простая переменная типа boolean.

int bytesAvailable;

//...

if (bytesAvailable > 0) {

ProcessData();          //Обработка данных

bytesAvailable  -=  n;

}

else

waitForMoreData();       //Ждать данные

В качестве логического выражения можно использовать выражение с операторами отношения. Это позволяет выбирать ту или иную ветвь кода в зависимости от результатов сравнения. А вот полная программа, в которой для определения, к какому времени года относится тот или иной месяц, используются операторы if-else.

class IfElse {

public static void main(String args[]) {

int month = 4;

String season;

if (month == 12 || month == 1 || month == 2)

{

season = "Winter";

}

else if (month ==3 || month == 4 || month == 5)

{

season = "Spring";

}

else if (month == 6 || month == 7 || month == 8)

{

season = "Summer";

}

else if (month == 9 || month == 10 || month == 11)

{

season = "Autumn";

}

else

{

season = "Bogus Month";

}

System.out.println( "April is in the " + season + ".");

}

}

После выполнения программы вы должны получить следующий результат:

April is in the Spring.

5.2. Опреатор break

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

Например, в следующей программе имеется три вложенных блока, и у каждого своя уникальная метка. Оператор break, стоящий во внутреннем блоке, вызывает переход на оператор, следующий за блоком Ь. При этом пропускаются два оператора println.

class Break {

public static void main(String args[]) {

boolean t = true;

a: {

b:    {

c:       {

System.out.println("ITepefl break");

if(t) break b;

System.out.println("He будет выполнено ");     }

System.out.println("He будет выполнено ");     }

System.out.println("noane b");

}

} }

В результате исполнения программы вы получите следующий результат:

До break

После b

5.3. Оператор switch

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

switch ( выражение )

{

case значение1: break;

case значение2: break;

case значениеN: break;

default:

}

Результатом вычисления выражения может быть значение любого простого типа, при этом каждое из значений, указанных в операторах case, должно быть совместимо по типу с выражением в операторе switch. Все эти значения должны быть уникальными литералами. Если же вы укажете в двух операторах case одинаковые значения, транслятор выдаст сообщение об ошибке.

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

Внутри оператора switch (а также внутри циклических конструкций) break без метки приводит к передаче управления на код, стоящий после оператора switch. Если break отсутствует, после текущего раздела case будет выполняться следующий. Иногда бывает удобно иметь в операторе switch несколько смежных разделов case, не разделенных оператором break.

class SwitchSeason {

public static void main(String args[]) {

int month = 4; String season;

switch (month)

{

case 12:

case 1:

case 2:

season = "зима";

break;

case 3:

case 4:

case 5:

season = "весна";

break;

case 6:

case 7:

case 8:

season = "лето";

break;

case 9:

case 10:

case 11:

season = "осень";

break;

default:

season = "Нет такого месяца";

}

System.out.println("Апрель - это "+ season + ".");

}

}

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

class WordCount {

static String text = "Сейчас мы изучаем\n" +

"основы программирования\n" +

"на языке Java\n";

static int len = text.length();

public static void main(String args[]) {

boolean inWord = false;

int numChars = 0;

int numWords = 0;

int numLines = 0;

for (int i=0; i < len; i++) {

char с = text.charAt(i);

numChars++;

switch (c) {

case ‘\n’: numLines++;  // Увеличиваем счетчик строк

case '\t':              // Подсчитываем количество символов

case ‘’ : if (inWord) {

numWords++;

inWord = false;

}

break;

default: inWord = true;

}

}

System.out.println("\t" + numLines +"\t" + numWords + "\t" + numChars);

}

}

5.4. Оператор return

В Java для реализации процедурного интерфейса к объектам классов используется разновидность подпрограмм, называемых методами. Подпрограмма main, которую мы использовали до сих пор — это статический метод соответствующего класса-примера. В любом месте программного кода метода можно поставить оператор return, который приведет к немедленному завершению работы и передаче управления коду, вызвавшему этот метод. Ниже приведен пример, иллюстрирующий использование оператора return для немедленного возврата управления, в данном случае — исполняющей среде Java.

class ReturnDemo {

public static void main(String args[]) {

boolean t = true;

System.out.println("До return");

if (t) return;

System.out.println("Этo не будет выполнено ");

}

}

ЗАМЕЧАНИЕ: Зачем в этом примере использован оператор if (t)? Дело в том, что не будь этого оператора, транслятор Java догадался бы, что последний оператор println никогда не будет выполнен. Такие случаи в Java считаются ошибками, поэтому без оператора if оттранслировать этот пример нам бы не удалось.

6. ЦИКЛЫ

Циклами называются конструкции, в которых один и тот же блок программного кода многократно выполняется до тех пор, пока не будет выполнено условие окончания цикла. Любой цикл можно разделить на 4 части: инициализацию, тело, итерацию и условие завершения. Инициализация — это код, определяющий начальные условия цикла. Тело - это оператор, выполнение которого необходимо повторить несколько раз. Итерация - код, который требуется выполнить сразу после очередного выполнения тела. Код итерации часто используется для увеличения (уменьшения) значений счетчиков и индексов. Завершение - это логическое выражение, которое вычисляется на каждом проходе цикла. В зависимости от его значения цикл или завершается или продолжает выполняться. В Java есть три циклические конструкции: while, do-while и  for.

6.1. Цикл while

Цикл while - это основная циклическая конструкция в Java. Этот цикл многократно выполняется до тех пор, пока значение логического выражения равно true. Ниже приведена общая форма оператора while:

[ инициализация; ]

while ( завершение) {

тело;

[итерация;]

}

Инициализация и итерация необязательны. Пока значение логического выражения равно true, продолжается выполнение тела цикла. Ниже приведен пример цикла while для печати пяти строк «while».

class WhileDemo {

public static void main(String args[]) {

int n = 5;

while (n > 0) {

System.out.println("while " + n);

n--;

}

}

}

В результате исполнения программы вы получите следующий результат:

while 5

while 4

while 3

while 2

while 1

6.2. Цикл do-while

Иногда возникает потребность выполнить тело цикла по крайней мере один раз, даже в том случае, когда логическое выражение с самого начала принимает значение false. Для таких случаев в Java используется циклическая конструкция do-while. Ее общая форма записи такова:

[ инициализация; ]

do {тело; [итерация;] } while ( завершение);

В следующем примере тело цикла выполняется до первой проверки условия завершения. Это позволяет совместить код итерации с условием завершения:

class Do While {

public static void main(String args[]) {

int n = 5;

do {

System.out.println("do-while " + n);

}  while (--n>0);

}

}

6.3. Цикл for

Опреатор for предназначен для компактной записи циклов. В этом операторе предусмотрены места для всех четырех частей цикла. Ниже приведена общая форма оператора записи for:

for (инициализация; завершение; итерация ) тело;

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

class ForDemo {

public static void main(String args[]) {

for (int i = 1; i <= 10; i++)

System.out.println("i = " + i);

}

}

Следующий пример — вариант программы, ведущей обратный отсчет.

class ForTick {

public static void main(String args[]) {

for (int n = 10; n > 0; n—)

System.out.println("n= " + n);

}

}

Обратите внимание — переменные можно объявлять внутри раздела инициализации оператора for. Переменная, объявленная внутри оператора for, действует в пределах этого оператора.

6.3.1. Оператор запятая

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

class Comma {

public static void main(String args[]) {

int a, b;

for (a = 1, b = 4; a < b; a++, b--) {

System.out.println("a = " + a);

System.out.println("b = " + b);

}

}

}

Вывод этой программы показывает, что цикл выполняется всего два раза,

а= 1

b = 4

а = 2

b = 3

6.4. Оператор continue

В некоторых ситуациях возникает потребность досрочно перейти к выполнению следующей итерации, проигнорировав часть операторов тела цикла, еще не выполненных в текущей итерации. В этом случае необходимо сделать переход из текущей точки в конец цикла, т.е. в точку после последнего оператора тела цикла. Для этой цели в Java предусмотрен оператор continue. В случае циклов while и do-while оператор continue приводит к пропуску операторов тела цикла, не выполненных на данной итерации, и к передаче управления на код, проверяющий условие завершения цикла. Оператор continue, стоящий в цикле for, приводит к тому, что управление немедленно передается третьей части заголовка цикла, т.е. коду, который, выполняется на каждой итерации после операторов тела цикла. Ниже приведен пример, в котором оператор continue используется для того, чтобы в каждой строке печатались два числа,

class ContinueDemo {

public static void main(String args[]) {

for (int i=0; i < 10; i++) {

System.out.print(i + " ");

if (i % 2 = 0) continue;

System.out.println("");

}

}

}

Если индекс четный, цикл продолжается без вывода символа новой строки. Результат выполнения этой программы таков:

0 1

2 3

5 7

8 9

Как и в случае оператора break, в операторе continue можно задавать метку, указывающую, в каком из вложенных циклов вы хотите досрочно прекратить выполнение текущей итерации. Для иллюстрации служит программа, использующая оператор continue с меткой для вывода треугольной таблицы умножения для чисел от 0 до 9:

class ContinueLabel {

public static void main(String args[]) {

outer: for (int i=0; i < 10; i++) {

for (int j = 0; j < 10; j++) {

if(j>i){

System.out.println("");

continue outer;

}

System.out.print(" " + (i * j));

}

}

} }

Оператор continue в этой программе приводит к завершению внутреннего цикла со счетчиком j и переходу к очередной итерации внешнего цикла со счетчиком i. В процессе работы эта программа выводит следующие строки:

0

0 1

0 2 4

0 3 6 9

0 4 8 12 16

0 5 10 15 20 25

0 6 12 18 24 30 36

0 7 14 21 28 35 42 49

0 8 16 24 32 40 48 56 64

0 9 18 27 36 45 54 63 72 81

ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ НА JAVA

7. КЛАССЫ

Базовым элементом объектно-ориентированного программирования в языке Java является класс. В этой главе Вы научитесь создавать и расширять свои собственные классы, работать с экземплярами этих классов. Напомним, что классы в Java не обязательно должны содержать метод main. Единственное назначение этого метода — указать интерпретатору Java, откуда надо начинать выполнение программы. Для того чтобы создать класс, достаточно иметь исходный файл, в котором будет присутствовать ключевое слово class, и вслед за ним — допустимый идентификатор и пара фигурных скобок для его тела.

class Point { }

ЗАМЕЧАНИЕ: Имя исходного файла Java должно соответствовать имени хранящегося в нем класса. Регистр букв важен и в имени класса, и в имени файла.

Класс — это шаблон для создания объекта. Класс определяет структуру объекта и его методы, образующие функциональный интерфейс. В процессе выполнения Java-программы система использует определения классов для создания представителей классов. Представители являются реальными объектами. Термины «представитель», «экземпляр» и «объект» взаимозаменяемы. Ниже приведена общая форма определения класса.

class имя_класса extends имя_суперкласса {

type переменная1_объекта:

type переменная2_объекта:

type переменнаяN_объекта:

type имяметода1(список_параметров) {

тело метода;

}

type имяметода2(список_параметров) {

тело метода;

}

type имя методаM(список_параметров) {

тело метода;

}

}

Ключевое слово extends указывает на то, что «имя класса» — это подкласс класса «имя_суперкласса». Во главе классовой иерархии Java стоит единственный ее встроенный класс — Object. Если вы хотите создать подкласс непосредственно этого класса, ключевое слово extends и следующее за ним имя суперкласса можно опустить — транслятор включит их в ваше определение автоматически. Примером может служить класс Point, приведенный выше.

7.1. Переменные класса

Данные инкапсулируются в класс путем объявления переменных между открывающей и закрывающей фигурными скобками, выделяющими в определении класса его тело. Эти переменные объявляются точно так же, как объявлялись локальные переменные в предыдущих примерах. Единственное отличие состоит в том, что их надо объявлять вне методов, в том числе вне метода main. Ниже приведен фрагмент кода, в котором объявлен класс Point с двумя переменными типа int.

class Point {

int x, у;

}

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

7.2. Оператор new

Оператор new создает экземпляр указанного класса и возвращает ссылку на вновь созданный объект. Ниже приведен пример создания и присваивание переменной р экземпляра класса Point,

Point р = new Point();

Вы можете создать несколько ссылок на один и тот же объект. Приведенная ниже программа создает два различных объекта класса Point и в каждый из них заносит свои собственные значения. Оператор «точка» используется для доступа к переменным и методам объекта.

class TwoPoints {

public static void main(String args[]) {

Point p1 = new Point();

Point p2 = new Point();

p1.x= 10;

p1.у = 20;

p2.x = 42;

p2.y = 99;

System.out.println("x = " + p1.x + " у = " + p1.у);

System.out.println("x = " + p2.x + "y = " + p2.y); }

}

В этом примере использовался класс Point. Было создано два объекта этого класса. Переменным х и у объектов p1 и р2 присвоены различные значения. Таким образом, мы продемонстрировали, что переменные различных объектов независимы на самом деле. Ниже приведен результат, полученный при выполнении этой программы,

С:\> Java TwoPoints

х = 10 у = 20

х = 42 у = 99

7.3. Объявление методов

Методы - это подпрограммы, присоединенные к конкретным определениям классов. Они описываются внутри определения класса на том же уровне, что и переменные объектов. При объявлении метода задаются тип возвращаемого им результата и список параметров. Общая форма объявления метода такова:

тип имя_метода (список формальных параметров) {

тело метода;

}

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

class Point {

int x,y;

void init(int a, int b) {

x = a;

y = b;

}

}

7.4. Вызов метода

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

7.5. Скрытие переменных

В языке Java не допускается использование в одной или во вложенных областях видимости двух локальных переменных с одинаковыми именами. Интересно отметить, что при этом не запрещается объявлять формальные параметры методов, чьи имена совпадают с именами переменных представителей. Давайте рассмотрим в качестве примера иную версию метода init, в которой формальным параметрам даны имена х и у, а для доступа к одноименным переменным текущего объекта используется ссылка this.

class Point {

int x, у;

void init(int x, int y) {

this.x = x;

this.y = у

}

}

class TwoPointsInit {

public static void main(String args[]) {

Point p1 = new Point();

Point p2 = new Point();

p1.init(10, 20);

p2.init(42, 99);

System.out.println("x = " + p1.x + " у = " + p1.y);

System.out.println(“x = " + p2.x + " у = " + p2.y);

}

}

7.6. Конструкторы

Инициализировать все переменные класса всякий раз, когда создается его очередной представитель, — довольно утомительное дело даже в том случае, когда в классе имеются функции, подобные методу init. Для этого в Java предусмотрены специальные методы, называемые конструкторами. Конструктор — это метод класса, который инициализирует новый объект после его создания. Имя конструктора всегда совпадает с именем класса, в котором он расположен. У конструкторов нет типа возвращаемого результата - никакого, даже void. Заменим метод init из предыдущего примера конструктором.

class Point {

int х, у;

Point(int х, int у) {

this.x = x;

this.y = y;

}

}

class PointCreate {

public static void main(String args[]) {

Point p = new Point(10,20);

System.out.println("x = " + p.x + " у = " + p.y);

}

}

7.7. Совмещение методов

Язык Java позволяет создавать несколько методов с одинаковыми именами, но с разными списками параметров. Такая техника называется совмещением методов (method overloading). В качестве примера приведена версия класса Point, в которой совмещение методов использовано для определения альтернативного конструктора, который инициализирует координаты х и у значениями по умолчанию (-1).

class Point {

int х, у;

Point(int х, int у) {

this.x = х;

this.y = у;

}

Point() {

х=-1;

y=-1;

}

}

class PointCreateAlt {

public static void main(String args[]) {

Point p = new Point();

System.out.println("x = " + p.x + " у = " + p.y);

}

}

В этом примере объект класса Point создается не при вызове первого конструктора, как это было раньше, а с помощью второго конструктора без параметров. Результат работы этой программы:

х = -1

у = -1

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

7.8. Ссылка this

Очередной вариант класса Point показывает, как, используя this и совмещение методов, можно строить одни конструкторы на основе других.

class Point {

int х, у;

Point(int х, int у) {

this.x = x;

this.y = y;

}

Point() {

this(-l,-l);

}

}

В этом примере второй конструктор для завершения инициализации объекта обращается к первому конструктору.

Методы, использующие совмещение имен, не обязательно должны быть конструкторами. В следующем примере в класс Point добавлены два метода distance. Функция distance возвращает расстояние между двумя точками. Одному из совмещенных методов в качестве параметров передаются координаты точки х и у, другому же эта информация передается в виде параметра-объекта Point.

class Point {

int x, у;

Point(int x, int у) {

this.x = x;

this. y = y;

}

double distance(int x, int y) {

int dx = this.x - x;

int dy = this.y - y;

return Math.sqrt(dx*dx + dy*dy);

}

double distance(Point p) {

return distance(p.x, p.y);

} }

class PointDist {

public static void main(String args[]) {

Point p1 = new Point(0,0);

Point p2 = new Point(30,40);

System.out.println("p1 = " + p1.x + ", " + p1.y);

System.out.println("p2 = " + p2.x + " + p2.y);

System.out.println("p1.distance(p2) =” + p1.distance(p2));

System.out.println("p1.distance(60, 80) = " + pl.distance(60, 80));

}}

Обратите внимание на то, как во второй форме метода distance для получения результата вызывается его первая форма. Ниже приведен результат работы этой программы:

p1 = 0,0

р2 = 30,40

p1.distance(p2) = 50.0

pl.distance(60, 80) = 100.0

7.9. Наследование

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

class Point3D extends Point {

int z;

Point3D(int x, int y, int z) {

this.x = x;

this.y = y;

this.z = z;

}

Point3D() {

this(-1,-1,-1);

}

}

В этом примере ключевое слово extends используется для того, чтобы сообщить транслятору о намерении создать подкласс класса Point. Как видите, в этом классе не понадобилось объявлять переменные х и у, поскольку Point3D унаследовал их от своего суперкласса Point.

7.10. Ссылка super

В примере с классом Point3D частично повторялся код, уже имевшийся в суперклассе. Вспомните, как во втором конструкторе мы использовали this для вызова первого конструктора того же класса. Аналогичным образом ключевое слово super позволяет обратиться непосредственно к конструктору суперкласса.

class Point3D extends Point {

int z;

Point3D(int x, int y, int z) {

super(x, у);           // Здесь мы вызываем конструктор суперкласса

this.z=z;

public static void main(String args[]) {

Point3D p = new Point3D(10, 20, 30);

System.out.println(“ x =” + p.x + ” у =” + p.y + " z =” + p.z);

}

}

Вот результат работы этой программы:

x = 10

y = 20

z = 30

7.11. Замещение методов

Новый подкласс Point3D класса Point наследует реализацию метода distance своего суперкласса. Проблема заключается в том, что в классе Point уже определена версия метода distance(int х, int у), которая возвращает обычное расстояние между точками на плоскости. Мы должны заместить (override) это определение метода новым, пригодным для случая трехмерного пространства. В следующем примере проиллюстрировано и совмещение (overloading), и замещение (overriding) метода distance.

class Point {

int x, у;

Point(int x, int у) {

this.x = x;

this.y = y;

}

double distance(int x, int y) {

int dx = this.x – x;

int dy = this.y - y:

return Math,sqrt(dx*dx + dy*dy);

}

double distance(Point p) {

return distance(p.x, p.y);

}

}

class Point3D extends Point {

int z;

Point3D(int x, int y, int z) {

super(x, y);

this.z = z;

}

double distance(int x, int y, int z) {

int dx = this.x - x;

int dy = this.y - y;

int dz = this.z - z;

return Math.sqrt(dx*dx + dy*dy + dz*dz);

}

double distance(Point3D other) {

return distance(other.x, other.y, other.z);

}

double distance(int x, int y) {

double dx = (this.x / z) - x; double dy = (this.y / z) - y;

return Math.sqrt(dx*dx + dy*dy);

}

}

class Point3DDist {

public static void main(String args[]) {

Point3D p1 = new Point3D(30,40,10);

Point3D p2 = new Point3D(0,0,0);

Point p = new Point(4,6);

System.out.println("p1 = " + p1.x + "," + p1.y + " + p1.z);

System.out.println("p2 = " + p2.x + ", " + p2.y + " + p2.z);

System.out.println("p = " + p.x + " + p.y);

System.out.println("p1.distance(p2) =” +p1.distance(p2));

System.out.println("p1.distance(4,6) = " + p1.distance(4,6));

System.out.println("p1.distance(p) =” + p1.distance(p));

}

}

Результат работы этой программы:

p1 =30,40,10

р2 = 0,0,0

р = 4,6

p1.distance(p2) = 50.9902

pl.distance(4,6) = 2.23607

p1.distance(p) = 2.23607

7.12. Динамическое назначение методов

Давайте в качестве примера рассмотрим два класса, у которых имеют простое родство подкласс/суперкласс, причем единственный метод суперкласса замещен в подклассе.

class А {

void callme() {

System.out.println("Вызван callme метод класса А");

}

}

class В extends А {

void callme() {

System.out.println("Вызван callme метод класса В");

}

}

class Dispatch {

public static void main(String args[]) {

A a = new B();

a.callme();

}

}

Обратите внимание — внутри метода main мы объявили переменную «а» класса А и проинициализировали ее ссылкой на объект класса В. В следующей строке мы вызвали метод callme. При этом транслятор проверил наличие метода callme у класса А, а исполняющая система, увидев, что на самом деле в переменной хранится представитель класса В, вызвала не метод класса A, a callme класса В. Ниже приведен результат работы этой программы:

Вызван callme метод класса В

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

7.13. Директива final

Все методы и переменные объектов могут быть замещены по умолчанию. Если же вы хотите объявить, что подклассы не имеют права замещать какие- либо переменные и методы вашего класса, вам нужно объявить их как final: final int FILE NEW = 1;

По общепринятому соглашению при выборе имен переменных типа final используются только символы верхнего регистра. Использование final-методов порой приводит к выигрышу в скорости выполнения кода — поскольку они не могут быть замещены, транслятору ничто не мешает заменять их вызовы встроенным (in-line) кодом (байт-код копируется непосредственно в код вызывающего метода).

7.14. Деструкторы

В Java существует возможность объявлять методы с именем finalize. Методы finalize - это деструкторы - методы, которые уничтожают объект. Исполняющая среда Java будет вызывать его каждый раз, когда сборщик мусора соберется уничтожить объект этого класса.

7.15. Статические методы

Иногда требуется создать метод, который можно было бы использовать вне контекста какого-либо объекта его класса. Так же, как в случае main, все, что требуется для создания такого метода — указать при его объявлении модификатор типа static. Статические методы могут непосредственно обращаться только к другим статическим методам, в них ни в каком виде не допускается использование ссылок this и super. Переменные также могут иметь тип static, они подобны глобальным переменным, то есть доступны из любого места кода. Внутри статических методов недопустимы ссылки на переменные представителей. Ниже приведен пример класса, у которого есть статические переменные, статический метод и статический блок инициализации.

class Static {

static int а = 3;

static int  b;

static void method(int x) {

System.out.println("x =” + x);

System.out.println("a =” + a);

System.out.println("b = " + b);

}

static {

System.out.println("Статический блок инициализации");

b = а * 4;

}

public static void main(String args[]) {

method(42);

}

}

Результат запуска этой программы:

х = 42

а = 3

b = 12

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

class StaticClass {

static int a = 42;

static int b = 99;

static void callme() {

System.out.println("a =” + a);

}

}

class StaticByName {

public static void main(String args[]) {

StaticClass.callme();

System.out.println("b =” + StaticClass.b);

}

}

А вот и результат запуска этой программы:

а = 42

b = 99

7.16. Абстрактные классы

Бывают ситуации, когда нужно определить класс, в котором задана структура какой-либо абстракции, но полная реализация всех методов отсутствует. В таких случаях вы можете с помощью модификатора типа abstract объявить, что некоторые из методов обязательно должны быть замещены в подклассах. Любой класс, содержащий методы abstract, также должен быть объявлен как abstract. Поскольку у таких классов отсутствует полная реализация, их представителей нельзя создавать с помощью оператора new. Кроме того, нельзя объявлять абстрактными конструкторы и статические методы. Любой подкласс абстрактного класса либо обязан предоставить реализацию всех абстрактных методов своего суперкласса, либо сам должен быть объявлен абстрактным,

abstract class А

{

abstract void callme();

void metoo() {

System.out.println("Вызван metoo метод класса A");

}

}

class В extends A {

void callme() {

System.out.println("Вызван callme метод класса В");

}

}

class Abstract {

public static void main(String args[]) {

A a = new B();

a.callme();

a.metoo();

}

}

В нашем примере для вызова реализованного в подклассе класса А метода callme и реализованного в классе А метода metoo используется динамическое назначение методов, которое мы обсуждали раньше,

Вызван callme метод класса В

Вызван metoo метод класса А

8. ПАКЕТЫ И ИНТЕРФЕЙСЫ

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

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

8.1. Пакеты

Все идентификаторы, которые мы до сих пор использовали в наших примерах, располагались в одном и том же пространстве имен (name space). Это означает, что нам во избежание конфликтных ситуаций приходилось заботиться о том, чтобы у каждого класса было свое уникальное имя. Пакеты — это механизм, который служит как для работы с пространством имен, так и для ограничения видимости. У каждого файла java есть 4 внутренних части, из которых мы до сих пор в наших примерах использовали только одну. Ниже приведена общая форма исходного файла Java.

* одиночный оператор package (необязателен)

* любое количество операторов import (необязательны)

* одиночное объявление открытого (public) класса

* любое количество закрытых (private) классов пакета (необязательны)

8.1.1. Оператор package

Первое, что может появиться в исходном файле Java — это оператор package, который сообщает транслятору, в каком пакете должны определяться содержащиеся в данном файле классы. Пакеты задают набор раздельных пространств имен, в которых хранятся имена классов. Если оператор package не указан, классы попадают в безымянное пространство имен, используемое по умолчанию. Если вы объявляете класс как принадлежащий определенному пакету, например, package java.awt.image; то и исходный код этого класса должен храниться в каталоге java/awt/image.

При попытке поместить класс в пакет вы сразу натолкнетесь на жесткое требование точного совпадения иерархии каталогов с иерархией пакетов. Вы не можете переименовать пакет, не переименовав каталог, в котором хранятся его классы. Эта трудность видна сразу, но есть и менее очевидная проблема. Представьте себе, что вы написали класс с именем PackTest в пакете test. Вы создаете каталог test, помещаете в этот каталог файл PackTest.java и транслируете. Пока — все в порядке. Однако при попытке запустить его вы получаете от интерпретатора сообщение «can't find class PackTest» («Не могу найти класс PackTest»). Ваш новый класс теперь хранится в пакете с именем test, так что теперь надо указывать всю иерархию пакетов, разделяя их имена точками - test.PackTest. Кроме того, Вам надо либо подняться на уровень выше в иерархии каталогов и снова набрать «java test.PackTest», либо внести в переменную CLASSPATH каталог, который является вершиной иерархии разрабатываемых вами классов.

8.1.2. Трансляция классов в пакетах

8.1.3. Оператор import

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

import пакет1 [.пакет2].(имякласса|*);

Здесь пакет1 — имя пакета верхнего уровня, пакет2 — это необязательное имя пакета, вложенного в первый пакет и отделенного точкой. После указания пути в иерархии пакетов указывается либо имя класса, либо метасимвол «звездочка». Звездочка означает, что, если Java-транслятору потребуется какой-либо класс, для которого пакет не указан явно, он должен просмотреть все содержимое пакета со звездочкой вместо имени класса. В приведенном ниже фрагменте кода показаны обе формы использования оператора import:

import javautil.Date

import javaio.*;

Все встроенные в Java классы, которые входят в комплект поставки, хранятся в пакете с именем java. Базовые функции языка хранятся во вложенном пакете java.lang. Весь этот пакет автоматически импортируется транслятором во все программы. Это эквивалентно размещению в начале каждой программы оператора import java.lang.*;

Если в двух пакетах, подключаемых с помощью формы оператора import со звездочкой, есть классы с одинаковыми именами, однако вы их не используете, транслятор не отреагирует. А вот при попытке использовать такой класс вы сразу получите сообщение об ошибке, и вам придется переписать операторы import, чтобы явно указать, класс какого пакета вы имеете в виду, class MyDate extends Java.util.Date {}

8.1.4. Ограничение доступа

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

1. подклассы в том же пакете;

2. не подклассы в том же пакете;

3. подклассы в различных пакетах;

4. классы, которые не являются подклассами и не входят в тот же пакет.

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

Есть несколько правил, которые помогут вам разобраться. Элемент, объявленный public, доступен из любого места. Все, что объявлено private, доступно только внутри класса и нигде больше. Если у элемента вообще не указан модификатор уровня доступа, то такой элемент будет виден из подклассов и классов того же пакета. Именно такой уровень доступа используется в языке Java по умолчанию. Если необходимо, чтобы элемент был доступен только подклассам, причем независимо от того, находятся ли они в данном пакете или нет — используйте protected.

Таблица 8.1 Таблица ограничения доступа

private

модификатор отсутствует

protected

public

тот же класс

да

да

да

да

подкласс в том же пакете

нет

да

да

да

независимый класс в том же пакете

нет

да

да

да

подкласс в другом пакете

нёт

нет

да

да

независимый класс в другом пакете

нет

нет

нет

да

8.2. Интерфейсы

Интерфейсы Java созданы для поддержки динамического выбора (resolution) методов во время выполнения программы. Интерфейсы похожи на классы, но в отличие от последних у интерфейсов нет переменных представителей, а в объявлениях методов отсутствует реализация. Класс может иметь любое количество интерфейсов. Все, что нужно сделать — это реализовать в классе полный набор методов всех интерфейсов. Сигнатуры таких методов класса должны точно совпадать с сигнатурами методов реализуемого в этом классе интерфейса. Интерфейсы обладают своей собственной иерархией, не пересекающейся с классовой иерархией наследования. Это дает возможность реализовать один и тот же интерфейс в различных классах, никак не связанных по линии иерархии классового наследования. Именно в этом и проявляется главная сила интерфейсов.

8.2.1. Оператор interface

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

interface имя {

тип_результата имя_метода1 (список параметров);

тип имя_finall_переменной = значение;

}

Обратите внимание — у объявляемых в интерфейсе методов отсутствуют операторы тела. Объявление методов завершается символом «;» (точка с запятой). В интерфейсе можно объявлять и переменные, при этом они неявно объявляются переменными типа final. Это означает, что класс реализации не может изменять их значения. Кроме того, при объявлении переменных в интерфейсе их обязательно нужно инициализировать константными значениями. Ниже приведен пример определения интерфейса, содержащего единственный метод с именем callback и одним параметром типа int.

interface Callback {

void callback(int param); }

8.2.2. Оператор implements

Оператор implements — это дополнение к определению класса, реализующего некоторый интерфейс.

class имякласса [extends суперкласс]

[implements интерфейс0 [, интерфейс 1...]]

{тело класса}

Если в классе реализуется несколько интерфейсов, то их имена разделяются запятыми. Ниже приведен пример класса, в котором реализуется определенный нами интерфейс:

class Client implements Callback {

void callback(int p) {

System.out.println("callback вызван с " + p);

}

}

В очередном примере метод callback интерфейса, определенного ранее, вызывается через переменную-ссылку на интерфейс:

class Testlface {

public static void main(String args[])

{

switch(result) {

case NO:

System.out.println("Heт");

break;

case YES:

System.out.println("Дa");

break;

case MAYBE:

System.out.println("Moжeт быть");

break;

case LATER:

System.out.println("Позже");

break;

case SOON:

System.out.priniln("Cкopo");

break;

case NEVER:

System.out.println("Никогда");

break;

}

}

public static void main(String args[]) {

Question q = new Question();

answer(q.ask());

answer(q.ask());

answer(q.ask());

answer(q.ask());

}

}

Обратите внимание на то, что результаты при разных запусках программы отличаются, поскольку в ней используется класс генерации случайных чисел Random пакета java.util.

Позже

Скоро

Нет

Да

9. ОБРАБОТКА ИСКЛЮЧЕНИЙ

Исключение в Java — это объект, который описывает исключительное состояние, возникшее в каком-либо участке программного кода. Когда возникает исключительное состояние, создается объект класса Exception. Этот объект пересылается в метод, обрабатывающий данный тип исключительной ситуации. Исключения могут возбуждаться и «вручную» для того, чтобы сообщить о некоторых нештатных ситуациях.

9.1. Основы механизма исключений

К механизму обработки исключений в Java имеют отношение 5 ключевых слов: — try, catch, throw, throws и finally. Схема работы этого механизма следующая. Вы пытаетесь (try) выполнить блок кода, и, если при этом возникает ошибка, система возбуждает (throw) исключение, которое в зависимости от его типа вы можете перехватить (catch) или передать умалчиваемому (finally) обработчику.

Ниже приведена общая форма блока обработки исключений.

try {

// блок кода}

catch (ТипИсключения1 е) {

// обработчик исключений типа ТипИсключения1 }

catch (ТипИсюпочения2 е) {

// обработчик исключений типа ТипИсключения2

throw(e) // повторное возбуждение исключения }

finally { }

9.2. Типы исключений

В вершине иерархии исключений стоит класс Throwable. Каждый из типов исключений является подклассом класса Throwable. Два непосредственных наследника класса Throwable делят иерархию подклассов исключений на две различные ветви. Один из них — класс Exception — используется для описания исключительных ситуаций, которые должны перехватываться программным кодом пользователя. Другая ветвь дерева подклассов Throwable — класс Error, который предназначен для описания исключительных ситуаций, которые при обычных условиях не должны перехватываться в пользовательской программе.

9.3. Неперехваченные исключения

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

class Ехс0 {

public static void main(string args[]) {

int d = 0;

int a = 42 / d;

}

}

Вот вывод, полученный при запуске нашего примера.

C:\>javaExc0

java.lang. ArithmeticException: / деление на ноль

at Exc0.main(Exc0.java:4)

Обратите внимание на тот факт, что типом возбужденного исключения был не Exception и не Throwable. Это подкласс класса Exception, а именно: ArithmeticException, поясняющий, какая ошибка возникла при выполнении программы. Вот другая версия того же класса, в которой возникает та же исключительная ситуация, но на этот раз не в программном коде метода main.

class Exc1 {

static void subroutine() {

int d = 0;

int a= 10 / d;

}

public static void main(String args[]) {

Exc1 .subroutine();

}

}

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

С:\> java Excl

java.lang.ArithmeticException: / деление на ноль

at Excl.subroutine(Excl.java:4)

at Excl.main(Excl.java:7)

9.4. Операторы try и catch

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

class Ехс2 {

public static void main(String args[]) {

try {

int d = 0;

int a = 42 / d;

}

catch (ArithmeticException e) {

System.out.println("деление на ноль");

}

}

}

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

9.5. Несколько разделов catch

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

class MultiCatch {

public static void main(String args[]) {

try {

int a = args.length;

System.out.println("a = " + a);

int b = 42 / a;

int c[] = { 1 };

c[42] = 99;

}

catch (ArithmeticException e) {

System.out.println("деление на ноль: " + e);

}

catch(ArrayIndexOutOfBoundsException e) {

System.out.println("неправильный индекс массива: " + e);

}

}

Этот пример, запущенный без параметров, вызывает возбуждение исключительной ситуации деления на ноль. Если же мы зададим в командной строке один или несколько параметров, тем самым установив переменную «а» в значение больше нуля, наш пример выполнит оператор деления, но в следующем операторе будет возбуждено исключение выхода индекса за границы массива ArraylndexOutOfBounds. Ниже приведены результаты работы этой программы, запущенной и тем и другим способом.

C:\> java MultiCatch

a = 0

div by 0: java.lang. ArithmeticException: / деление на ноль

C:\> java MultiCatch 1

a= 1

неправильный индекс массива: java.lang.ArrayIndexOutOffloundsException: 42

9.6. Вложенные операторы try

Операторы try можно вкладывать друг в друга аналогично тому, как можно создавать вложенные области видимости переменных. Если у оператора try низкого уровня нет раздела catch, соответствующего возбужденному исключению, то в поисках подходящего обработчика будут проверены разделы catch внешнего оператора try. Вот пример, в котором два оператора try вложены друг в друга посредством вызова метода.

class MultiNest {

static void procedure() {

try {

int c[] = { 1 };

c[42] = 99;

}

catch(ArrayIndexOutOfboundsException e)  {

System.out.println("неправильный индекс массива: " + e);

}

}

public static void main(String args[]) {

try {

int a = args.length();

System.out.println("a = " + a);

int b = 42 / a;

procedure();

}

catch (ArithmeticException e) {

System.out.println("деление на ноль: " + e);

}

}

}

9.7. Оператор throw

Оператор throw используется для возбуждения исключения «вручную». Для того чтобы сделать это, нужно иметь объект подкласса класса Throwable, который можно либо получить как параметр оператора catch, либо создать с помощью оператора new. Ниже приведена общая форма оператора throw,

throw ОбъектТипа Throwable;

При достижении этого оператора нормальное выполнение кода немедленно прекращается, так что следующий за ним оператор не выполняется. Ближайший окружающий блок try проверяется на наличие соответствующего возбужденному исключению обработчика catch. Если такой отыщется, управление передается ему. Если нет, то проверяется следующий из вложенных операторов try и так до тех пор, пока либо не будет найден подходящий раздел catch, либо обработчик исключений исполняющей системы Java не остановит программу, выведя при этом состояние стека вызовов. Ниже приведен пример, в котором сначала создается объект-исключение, затем оператор throw возбуждает исключительную ситуацию, после чего то же исключение возбуждается повторно — на этот раз уже кодом перехватившего его в первый раз раздела catch.

class ThrowDemo {

static void demoproc() {

{

throw new NullPointerException("demo");

}

catch (NullPointerException e) {

System.out.println("caught inside demoproc");

throw e;

}

}

public static void main(String args[]) {

try {

demoproc();

}

catch(NulPointerException e) {

System.out.println("recaught:" + e);

}

}

}

В этом примере обработка исключения проводится в два приема. Метод main создает контекст для исключения и вызывает demoproc. Метод demoproc также устанавливает контекст для обработки исключения, создает новый объект класса NullPointerException и с помощью оператора throw возбуждает это исключение. Исключение перехватывается в следующей строке внутри метода demoproc, причем объект-исключение доступен коду обработчика через параметр «е». Код обработчика выводит сообщение о том, что возбуждено исключение, а затем снова возбуждает его с помощью оператора throw, в результате чего оно передается обработчику исключений в методе main. Ниже приведен результат, полученный при запуске этого примера.

С:\> java ThrowDemo

caught inside demoproc

recaught: java.lang.NullPointerException: demo

9.8. Оператор throws

Если метод способен возбуждать исключения, которые он сам не обрабатывает, он должен объявить о таком поведении, чтобы вызывающие методы могли защитить себя от этих исключений. Для задания списка исключений, которые могут возбуждаться методом, используется оператор throws. Если метод в явном виде (т.е. с помощью оператора throw) возбуждает исключение соответствующего класса, тип класса исключений должен быть указан в операторе throws в объявлении этого метода. С учетом этого наш прежний синтаксис определения метода должен быть расширен следующим образом:

тип имя_метода(список аргументов) throws список исюпочений {}

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

class ThrowsDemo1 {

static void procedure()

{

System.out.println("inside procedure");

throw new IllegalAccessException("demo");

}

public static void main(String args[]) {

procedure();

}

}

Для того чтобы мы смогли оттранслировать этот пример, нам придется сообщить транслятору, что procedure может возбуждать исключения типа IllegalAccessException и в методе main добавить код для обработки этого типа исключений:

class ThrowsDemo {

static void procedure() throws IllegalAccessException

{

System.out.println(" inside procedure");

throw new IllegalAccessException("demo");

}

public static void main(String aigs[]) {

try {

procedure();

}

catch (IllegalAccessException e) {

System.out.println("caught" + e);

}

}

}

Ниже приведен результат выполнения этой программы.

С:\> java ThrowsDemo

inside procedure

caught javaJangIllegalAccessException: demo

9.9. Оператор finally

Иногда требуется гарантировать, что определенный участок кода будет выполняться независимо от того, какие исключения были возбуждены и перехвачены. Для создания такого участка кода используется оператор finally. Даже в тех случаях, когда в методе нет соответствующего возбужденному исключению раздела catch, блок finally будет выполнен до того, как управление перейдет к операторам, следующим за разделом try. У каждого раздела try должен быть, по крайней мере, или один раздел catch, или блок finally. Блок finally очень удобен для закрытия файлов и освобождения любых других ресурсов, захваченных для временного использования в начале выполнения метода. Ниже приведен пример класса с двумя методами, завершение которых происходит по разным причинам, но в обоих перед выходом выполняется код раздела finally.

class FinallyDemo {

static void procA() {

try {

System.out.println("insideprocA");

throw new RuntimeException("demo");

}

finally {

System.out.println("procA's finally");

}

}

static void procB() {

try {

System.out.println("insideprocB");

return;

}

finally {

System.out.println("procB's finally");

}

}

public static void main(String args[]) {

try {

procA();

}

catch (Exception e) {}

procB();

}

}

В этом примере в методе procA из-за возбуждения исключения происходит преждевременный выход из блока try, но при выходе выполняется раздел finally. Другой метод ргосВ завершает работу выполнением стоящего в try- блоке оператора return, но и при этом перед выходом из метода выполняется программный код блока finally. Ниже приведен результат, полученный при выполнении этой программы.

С:\> java FinallyDemo

inside procA procA's finally

inside procB procB's finally

10. МНОГОПОТОЧНОЕ ПРОГРАММИРОВАНИЕ

Параллельное программирование, связанное с использованием легковесных процессов, или подпроцессов (multithreading, light-weight processes) — концептуальная парадигма, в которой вы разделяете свою программу на два или несколько процессов, которые могут исполняться одновременно.

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

10.1. Модель легковесных процессов в Java

Java использует подпроцессы для того, чтобы сделать среду программирования асинхронной. После того, как подпроцесс запущен, его выполнение можно временно приостановить (suspend). Если подпроцесс остановлен (stop), возобновить его выполнение невозможно. У подпроцессов имеются приоритеты. Приоритеты подпроцессов — это просто целые числа в диапазоне от 1 до 10 и имеет смысл только соотношения приоритетов различных подпроцессов. Приоритеты же используются для того, чтобы решить, когда нужно остановить один подпроцесс и начать выполнение другого. Это называется переключением контекста. Правила просты. Подпроцесс может добровольно отдать управление — с помощью явного системного вызова или при блокировании на операциях ввода-вывода, либо он может быть приостановлен принудительно. В первом случае проверяются все остальные подпроцессы, и управление передается тому из них, который готов к выполнению и имеет самый высокий приоритет. Во втором случае низкоприоритетный подпроцесс независимо от того, чем он занят, приостанавливается принудительно для того, чтобы начал выполняться подпроцесс с более высоким приоритетом. Поскольку подпроцессы вносят в ваши программы асинхронное поведение, должен существовать способ их синхронизации. Для этой цели в Java реализовано развитие старой модели синхронизации процессов с помощью монитора. Если вы разделили свою программу на логические части - подпроцессы, вам нужно определить, как эти части будут общаться друг с другом. Java предоставляет для этого удобное средство — два подпроцесса могут «общаться» друг с другом, используя методы wait и notify. Работать с параллельными подпроцессами в Java несложно. Язык предоставляет явный, тонко настраиваемый механизм управления созданием подпроцессов, переключения контекстов, приоритетов, синхронизации и обмена сообщениями между подпроцессами.

10.2. Подпроцесс

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

class CurrentThreadDemo {

public static void main(String args[]) {

Thread t = Thread.currentThread();

t.setName("Moй подпроцесс");

System.out. println("текущий подпроцесс: " +1);

try {

for (int n = 5; n > 0; n--) {

System.out.println(" " + n);

Thread.sleep(1000);

}

}

catch (InterruptedException e) {

System.out.println("interrupted");

}

}

В этом примере текущий подпроцесс хранится в локальной переменной t. Затем мы используем эту переменную для вызова метода setName, который изменяет внутреннее имя подпроцесса на «My Thread» с тем, чтобы вывод программы был удобочитаемым. На следующем шаге мы входим в цикл, в котором ведется обратный отсчет от 5, причем на каждой итерации с помощью вызова метода Thread.sleep() делается пауза длительностью в 1 секунду. Аргументом для этого метода является значение временного интервала в миллисекундах. Обратите внимание — цикл заключен в try/catch блок. Дело в том, что метод Thread.sleep() может возбуждать исключение InterruptedException. Это исключение возбуждается в том случае, если какому-либо другому подпроцессу понадобится прервать данный подпроцесс. В данном примере мы в такой ситуации просто выводим сообщение о перехвате исключения. Ниже приведен вывод этой программы:

С:\> java CurrentThreadDemo

текущий подпроцесс: Thread[Moй подпроцесс,5,main]

5

4

3

2

1

Обратите внимание на то, что в текстовом представлении объекта Thread содержится заданное нами имя легковесного процесса — Мой подпроцесс. Число 5 — это приоритет подпроцесса, оно соответствует приоритету по умолчанию, «main» — имя группы подпроцессов, к которой принадлежит данный подпроцесс.

10.3. Интерфейс Runnable

Как можно создать еще один подпроцесс? Для этого нам понадобится другой экземпляр класса Thread. При создании нового объекта Thread ему нужно указать, какой программный код он должен выполнять. Вы можете запустить подпроцесс с помощью любого объекта, реализующего интерфейс Runnable. Для того чтобы реализовать этот интерфейс, класс должен предоставить определение метода run. Ниже приведен пример, в котором создается новый подпроцесс.

class ThreadDemo implements Runnable {

ThreadDemo() {

Thread ct = Thread.currentThread();

System.out.println("currentThread: " + ct);

Thread t = new Thread(this, "Demo Thread");

System.out.println("Thread created: " +1);

t.start();

try {

Thread.sleep(3000);

}

catch (InterruptedException e) {

System.out.println("прерывание");

}

System.out.println("Выход из main подпроцесса");

}

public void run() {

try {

for (int i = 5; i > 0; i--) {

System.out.println("" + i);

Thread.sleep(l000);

}

}

catch (InterruptedException e) {

System.out.println("child прерван");

}

System.out.println("Выход из child подпроцесса ");

}

public static void main(String args[]) {

new ThreadDemo();

}

}

Обратите внимание на то, что цикл внутри метода run выглядит точно так же, как и в предыдущем примере, только на этот раз он выполняется в другом подпроцессе. Подпроцесс main с помощью оператора new Thread(this, "Demo Thread") создает новый объект класса Thread, причем первый параметр конструктора — this — указывает, что мы хотим вызвать метод run текущего объекта. Затем мы вызываем метод start, который запускает подпроцесс, выполняющий метод run. После этого основной подпроцесс (main) переводится в состояние ожидания на три секунды, затем выводит сообщение и завершает работу. Второй подпроцесс — «Demo Thread» — при этом по-прежнему выполняет итерации в цикле метода run до тех пор, пока значение счетчика цикла не уменьшится до нуля. Ниже показано, как выглядит результат работы этой программы после того, как она отработает 5 секунд.

С:\> java ThreadDemo

Thread created: Thread[Demo Thread,5,main]

5

4

3

Выход из main подпроцесса

2

1

Выход из child подпроцесса

10.4. Приоритеты подпроцессов

Если вы хотите добиться от Java предсказуемого, независимого от платформы поведения, вам следует проектировать свои подпроцессы таким образом, чтобы они по своей воле освобождали процессор. Ниже приведен пример с двумя подпроцессами с различными приоритетами, которые не ведут себя одинаково на различных платформах. Приоритет одного из подпроцессов с помощью вызова setPriority устанавливается на два уровня выше Thread. NORM_PRIORITY, то есть умалчиваемого приоритета. У другого подпроцесса приоритет, наоборот, на два уровня ниже. Оба этих подпроцесса запускаются и работают в течение 10 секунд. Каждый из них выполняет цикл, в котором увеличивается значение переменной-счетчика. Через десять секунд после их запуска основной подпроцесс останавливает их работу, присваивая условию завершения цикла while значение «true», и выводит значения счетчиков, показывающих, сколько итераций цикла успел выполнить каждый из подпроцессов.

class Clicker implements Runnable {

int click = 0;

private Thread t;

private boolean running = true;

public clicker(int p) {

t = new Thread(this);

t.setPriority(p);

}

public void run() {

while (running) {

click++;

}

}

public void stop() {

running = false;

}

public void start() {

t.start();

}

}

class HiLoPri {

public static void main(String args[]) {

Thread. currentThread(). setPriority(Thread.M AX_PRIORIT Y);

clicker hi = new clicker(Thread.NORM_PRIORITY + 2);

clicker lo = new clicker(Thread.NORM_PRIORITY - 2);

lo.start();

hi.start();

try {

Thread.sleep(l0000)

}

catch (Exception e) {}

lo.stop(); hi.stop();

System.out.println(lo.click +” vs.” + hi.click);

}

}

По значениям, фигурирующим в итоге, можно заключить, что подпроцессу с низким приоритетом достается меньше на 25 процентов времени процессора:

C:\>java HiLoPri

304300 vs. 4066666

10.5. Синхронизация

Когда двум или более подпроцессам требуется параллельный доступ к одним и тем же данным (иначе говоря, к совместно используемому ресурсу), нужно позаботиться о том, чтобы в каждый конкретный момент времени доступ к этим данным предоставлялся только одному из подпроцессов. Java для такой синхронизации предоставляет уникальную, встроенную в язык программирования поддержку. У каждого Java-объекта есть связанный с ним неявный монитор, а для того чтобы войти в него, надо вызвать метод этого объекта, отмеченный ключевым словом synchronized. Для того чтобы выйти из монитора и тем самым передать управление объектом другому подпроцессу, владелец монитора должен всего лишь вернуться из синхронизованного метода. Если у вас есть метод (или целая группа методов), который манипулирует внутренним состоянием объекта, используемого в программе с параллельными подпроцессами, во избежание состояния гонки вам следует использовать в его заголовке ключевое слово synchronized.

В Java имеется элегантный механизм общения между подпроцессами, основанный на методах wait, notify и notifyAll. Эти методы реализованы как final- методы класса Object, так что они имеются в любом Java-Knacce. Все эти методы должны вызываться только из синхронизованных методов. Правила использования этих методов очень просты:

1. wait — приводит к тому, что текущий подпроцесс отдает управление и переходит в режим ожидания до тех пор пока другой подпроцесс не вызовет метод notify с тем же объектом;

2. notify — выводит из состояния ожидания первый из подпроцессов, вызвавших wait с данным объектом;

3. notifyAll — выводит из состояния ожидания все подпроцессы, вызвавшие wait с данным объектом.

10.6. Методы программного интерфейса легковесных процессов

Ниже приведена сводка всех методов класса Thread.

10.6.1. Методы класса

Методы класса — это статические методы, которые можно вызывать непосредственно с именем класса Thread.

1. currentThread - этот статический метод возвращает объект Thread, выполняющийся в данный момент;

2. yield - вызов метода приводит к тому, что исполняющая система переключает контекст с текущего на следующий доступный подпроцесс. Это один из способов гарантировать, что низкоприоритетные подпроцессы

3. когда-нибудь получат управление;

4. sleep(int n) - при вызове метода исполняющая система блокирует текущий подпроцесс на n миллисекунд. После того, как этот интервал времени закончится, подпроцесс снова будет способен выполняться. В большинстве исполняющих систем Java системные часы не позволяют точно выдерживать паузы короче, чем 10 миллисекунд. 10.6.2. Методы объекта

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

2. run - этот метод содержит тело выполняющегося подпроцесса. Это единственный метод интерфейса Runnable. Он вызывается из метода start после того, как исполняющая среда выполнит необходимые операции по инициализации нового подпроцесса. Если происходит возврат из метода run, текущий подпроцесс останавливается;

3. stop - вызов метода приводит к немедленной остановке подпроцесса. Это способ мгновенно прекратить выполнение текущего подпроцесса, особенно если метод выполняется в текущем подпроцессе. В таком случае строка, следующая за вызовом метода stop, никогда не выполняется, поскольку контекст подпроцесса «умирает» до того, как метод stop возвратит управление. Более аккуратный способ остановить выполнение подпроцесса — установить значение какой-либо переменной-флага, предусмотрев в методе run код, который, проверив состояние флага, завершил бы выполнение подпроцесса;

4. setPriority(int р) - метод устанавливает приоритет подпроцесса, задаваемый целым значением, передаваемого методу параметра. В классе Thread есть несколько предопределенных приоритетов-констант: MINJPRIORITY, NORMPRIORITY и MAX PRIORITY, соответствующих значениям 1, 5 и 10. Большинство пользовательских приложений должно выполняться на уровне NORM PRIORITY плюс-минус 1. Приоритет фоновых заданий, например, сетевого ввода-вывода или перерисовки экрана следует устанавливать в MIN_PRIORITY. Запуск подпроцессов на уровне MAX_PRIORITY требует осторожности. Если в подпроцессах с таким уровнем приоритета отсутствуют вызовы sleep или yield, может оказаться, что вся исполняющая система Java перестанет реагировать на внешние раздражители;

5. getPriority - этот метод возвращает текущий приоритет подпроцесса — целое значение в диапазоне от 1 до 10;

setName(String name) - метод присваивает подпроцессу указанное в параметре имя. Это помогает при отладке программ с параллельными подпроцессами. Присвоенное с помощью setName имя будет появляться во всех трассировках стека, которые выводятся при получении интерпретатором неперехваченного исключения;

6. getName - метод возвращает строку с именем подпроцесса, установленным с помощью вызова setName.

11. ввод/вывод

Обобщенное понятие источника ввода относится к различным способам получения информации: к чтению дискового файла, символов с клавиатуры либо получению данных из сети. Аналогично под обобщенным понятием вывода также могут пониматься дисковые файлы, сетевое соединение и т. п. Эти абстракции дают удобную возможность для работы с вводом-выводом (I/O), не требуя при этом, чтобы каждая часть вашего кода понимала разницу между, скажем, клавиатурой и сетью. В Java эта абстракция называется потоком (stream) и реализована в нескольких классах пакета java.io. Ввод инкапсулирован в классе InputStream, вывод — в OutputStream. В Java есть несколько специализаций этих абстрактных классов, учитывающих различия при работе с дисковыми файлами, сетевыми соединениями и даже с буферами в памяти.

11.1. Работа с файлами

File — единственный класс в java.io, который работает непосредственно с дисковыми файлами. Хотя на использование файлов в апплетах наложены жесткие ограничения, файлы по-прежнему остаются основными ресурсами для постоянного хранения и совместного использования информации. Каталог в Java трактуется как обычный файл, но с дополнительным свойством — списком имен файлов, который можно просмотреть с помощью метода list.

Для определения стандартных свойств файла в классе File есть много разных методов. Однако класс File несимметричен. Есть много методов, позволяющих узнать свойства объекта, но соответствующие функции для изменения этих свойств отсутствуют. В очередном примере используются различные методы, позволяющие получить характеристики файла:

import java.io.File;

class FileTest {

static void p(String s) {

System.out.println(s);

}

public static void main(String args[]) {

File fl = new File("/java/COP YRIGHT");

р("Имя файла:" + fl .getName());

р("Путь:" + fl.getPath());

р("Полный путь:" + fl.getAbsolutePath());

р("Родительский каталог:" + fl.getParent());

p(fl.exists() ? "существует" : "не существует");

p(fl.canWrite() ? "можно записывать" : "нельзя записывать");

p(fl.canRead() ? "можно читать" : "нельзя читать");

p("is" + ("Директория? "+fl ,isDirectory() ? "да": " нет");

p(fl.isFile() ? "обычный файл" : "не обычный файл");

р("Последняя модификация файла:" + fl. lastModified());

р("Размер файла:" + fl.length() + " Bytes");

}

}

При запуске этой программы вы получите:

Имя файла: COPYRIGHT

Путь: /java/COPYRIGHT

Полный путь:/Java/COPYRIGHT

Родительский каталог:/java

существует

можно записывать

можно читать

Директория? нет

обычный файл

is absolute

Последняя модификация файла:812465204000

Размер файла:695 Bytes

Существует также несколько сервисных методов, использование которых ограничено обычными файлами (их нельзя применять к каталогам). Метод renameTo(File dest) переименовывает файл (нельзя переместить файл в другой каталог). Метод delete уничтожает дисковый файл. Этот метод может удалять только обычные файлы, каталог, даже пустой, с его помощью удалить не удаётся.

11.2. Каталоги

Каталоги — это объекты класса File, в которых содержится список других файлов и каталогов. Если File ссылается на каталог, его метод isDirectoiy возвращает значение true. В этом случае вы можете вызвать метод list и извлечь содержащиеся в объекте имена файлов и каталогов. В очередном примере показано, как с помощью метода list можно просмотреть содержимое каталога.

import j ava.io.File;

class DirList {

public static void main(String args[]) {

String dirname = "/java"; // имя каталога

File fl = new File(dirname);

if (fLisDirectory()) {

// является ли fl каталогом

System.out.println("Directory of' + dirname);

String s[]=fl.list();

for (int i=0; i < s.length; i++) {

File f = new File(dirname + "/" + s[i]);

if(fisDiiectory())

{

// является ли f каталогом

System.out.println(s[i] +” is a directory"):

}

else {

System.out.println(s[i] + " is a file");

}

}

}

else {

System.out.println(dirname + " is not a directory");

}

}

}

В процессе работы эта программа вывела содержимое каталога /java моего персонального компьютера в следующем виде:

С:\> java DirList

Directory of /java

bin is a directory COPYRIGHT is a file

README is a file

11.3. Класс InputStream

InputStream — абстрактный класс, задающий используемую в Java модель входных потоков. Все методы этого класса при возникновении ошибки возбуждают исключение IOException. Ниже приведен краткий обзор методов класса InputStream.

1. read() - возвращает представление очередного доступного символа во входном потоке в виде целого;

2. read(byte b[]) - пытается прочесть максимум b.length байтов из входного потока в массив b. Возвращает количество байтов, в действительности прочитанных из потока;

3. read(byte b[], int off, int len) - пытается прочесть максимум len байтов, расположив их в массиве Ь, начиная с элемента off. Возвращает количество реально прочитанных байтов;

4. skip(long n) - пытается пропустить во входном потоке n байтов. Возвращает количество пропущенных байтов;

5. available() - возвращает количество байтов, доступных для чтения в настоящий момент;

6. close() - закрывает источник ввода. Последующие попытки чтения из этого потока приводят к возбуждению IOException. 11.4. Класс OutputStream

Как и InputStream, OutputStream — абстрактный класс. Он задает модель выходных потоков Java. Все методы этого класса имеют тип void и возбуждают исключение IOException в случае ошибки. Ниже приведен список методов этого класса:

1. write(int b) записывает один байт в выходной поток. Обратите внимание, что аргумент этого метода имеет тип int, что позволяет вызывать write, передавая ему выражение, при этом не нужно выполнять приведение его типа к byte;

2. write(byte b[]) записывает в выходной поток весь указанный массив байтов;

3. write(byte b[], int off, int len) записывает в поток часть массива — len байтов, начиная с элемента b[off];

4. flush() очищает любые выходные буферы, завершая операцию вывода;

5. close() закрывает выходной поток. Последующие попытки записи в этот поток будут возбуждать IOException.

11.5. Файловый поток FilelnputStream

Класс FilelnputStream используется для ввода данных из файлов. В приведенном ниже примере создается два объекта этого класса, использующие один и тот же дисковый файл.

InputStream f0 = new FileInputStream(“/autoexec.bat");

File f = new File("/autoexec.bat"):

InputStream f1 = new FilelnputStream(f);

Когда создается объект класса FilelnputStream, он одновременно с этим открывается для чтения. FilelnputStream замещает шесть методов абстрактного класса InputStream. В приведенном ниже примере показано, как можно читать одиночные байты, массив байтов и поддиапазон массива байтов. В этом примере также показано, как методом available можно узнать, сколько еще осталось непрочитанных байтов и как с помощью метода skip можно пропустить те байты, которые вы не хотите читать,

import java.io.*;

import java.util.*;

class FilelnputStreamS {

public static void main(String args[]) throws Exception {

int size;

InputStream f1 = new FileInputStream(“/wwwroot/default.htm");

size = f1.available();

System.out.println("Total Available Bytes: " + size);

System.out.println("First 1/4 of the file: read()");

for (int i=0; i < size/4; i++) {

System.out.print((char) f1.read());

}

System.out.println("Total Still Available: " + f1.available());

System.out.println("Reading the next 1/8: read(b[])");

byte b[] = new byte[size/8];

if(fl.read(b) !=b.length) {

System.err.println("Something bad happened");

}

String tmpstr = new String(b, 0,0, b.length);

System.out.println(tmpstr);

System.out.println("Still Available: " + f1.available());

System.out.println("Skipping another 1/4: skip()");

f1.skip(size/4);

System.out.println( "Still Available: " + f1.available());

System.out.println("Reading 1/16 into the end of array");

if (f1.read(b, b.length-size/16, size/16) != size/16) {

System.err.println("Something bad happened");

}

System.out.println("Still Available: " + f1.available());

f1.close();

}

}

11.6. Файловый поток FileOutputStream

У класса FileOutputStream — два таких же конструктора, что и у FileInputStream Однако создавать объекты этого класса можно независимо от того, существует файл или нет. При создании нового объекта класс FileOutputStream перед тем, как открыть файл для вывода, сначала создает его. В очередном нашем примере символы, введенные с клавиатуры, считываются из потока System.in - по одному символу за вызов до тех пор, пока не заполнится 12-байтовый буфер. После этого создаются три файла. В первый из них, filel.txt, записываются символы из буфера, но не все, а через один — нулевой, второй и так далее. Во второй, file2.txt, записывается весь ввод, попавший в буфер. И, наконец, в третий файл записывается половина буфера, расположенная в середине, а первая и последняя четверти буфера не выводятся.

import java.io.*;

class FileOutputStreamS {

public static byte getlnput()[] throws Exception {

byte buffer[] = new byte[12];

for (int i=0; i<l 2; i++) {

buffer[i] = (byte) System.in.read();

}

return buffer;

}

public static void main(String args[]) throws Exception {

byte buf[] = getlnput();

OutputStream f() = new FileOutputStream("filel.txt");

OutputStream f1 = new FileOutputStream("file2.txt");

OutputStream f2 = new FileOutputStream("file3.txt");

for (int i=0; i < 12; i += 2) {

f0.write(buf[i]);

}

f0.close();

f1.write(buf);

f1.close();

f2.write(buf, 12/4,12/2);

f2.close();

}

}

12. ПРОГРАММИРОВНИЕ ГРАФИЧЕСКИХ ПОЛЬЗОВАТЕЛЬСКИХ ИНТЕРФЕЙСОВ

12.1. Компоненты

Component — это абстрактный класс, который инкапсулирует все атрибуты визуального интерфейса - обработка ввода с клавиатуры, управление фокусом, взаимодействие с мышью, уведомление о входе/выходе из окна, изменения размеров и положения окон, прорисовка своего собственного графического представления, сохранение текущего текстового шрифта, цветов фона и переднего плана (более 10 методов). Перейдем к некоторым конкретным подклассам класса Component.

12.2. Класс Container

Container — это абстрактный подкласс класса Component, определяющий дополнительные методы, которые дают возможность помещать в него другие компоненты, что дает возможность построения иерархической системы визуальных объектов. Container отвечает за расположение содержащихся в нем компонентов с помощью интерфейса LayoutManager.

12.3. Класс Canvas

Основная идея использования объектов Canvas в том, что они являются семантически свободными компонентами. Вы можете придать объекту Canvas любое поведение и любой желаемый внешний вид. Его имя подразумевает, что этот класс является пустым холстом, на котором вы можете «нарисовать» любой компонент — такой, каким вы его себе представляете.

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

import java.awt.*;

import java.applet. *;

class GrayCanvas extends Canvas {

Color gray;

public GrayCanvas(float g) {

gray = new Color(g, g, g);

}

public void paint(Graphics g) {

Dimension size = size();

g.setColor(gray);

g.fillRect(0,0, size.width, size.height);

g.setColor(Color.black);

g.drawRect(0, 0, size.width-1, size.height-1);

}

}

public class PanelDemo extends Applet {

static final int n = 4;

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

for (int i = 0; i < n; i++) {

for (int j = 0; j < ri; j++) {

float g = (i * n + j) / (float) (n * n);

Canvas с = new GrayCanvas(g);

add(c);

c.resize(width / n, height / n);

c.move(i * width / n, j * height / n);

}

}

Мы устанавливаем размер каждого из объектов Canvas на основе значения, полученного с помощью метода size, который возвращает объект класса Dimension. Обратите внимание на то, что для размещения объектов Canvas в нужные места используются методы resize и move. Такой способ станет очень утомительным, когда мы перейдем к более сложным компонентам и более интересным вариантам расположения. А пока для выключения упомянутого механизма использован вызов метода setLayout(null).

12.4. Класс Label

Функциональность класса Label сводится к тому, что он знает, как нарисовать объект String — текстовую строку, выровнив ее нужным образом. Шрифт и цвет, которыми отрисовывается строка метки, являются частью базового определения класса Component. Для работы с этими атрибутами предусмотрены пары методов getFont/setFont и getForeground/setForeground. Задать или изменить текст строки после создания объекта с помощью метода setText. Для задания режимов выравнивания в классе Label определены три константы — LEFT, RIGHT и CENTER. Ниже приведен пример, в котором создаются три метки, каждая — со своим режимом выравнивания.

import java.awt.*;

import java.applet. *;

public class LabelDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

Label left = new LabelC'Left", LabeLLEFT);

Label right = new Label("Right", LabeLRIGHT);

Label center = new Label("Center", Label.CENTER);

add(left);

add(right);

add(center);

left.reshape(0, 0, width, height / 3);

right.reshape(0, height / 3, width, height / 3);

center.reshape(0,2 * height / 3, width, height / 3);

}

}

На этот раз, чтобы одновременно переместить и изменить размер объектов Label, мы использовали метод reshape. Ширина каждой из меток равна полной ширине апплета, высота— 1/3 высоты апплета.

12.5. Класс Button

Объекты-кнопки помечаются строками, причем эти строки нельзя выравнивать подобно строкам объектов Label (они всегда центрируются внутри кнопки). Позднее в данной главе речь пойдет о том, как нужно обрабатывать события, возникающие при нажатии и отпускании пользователем кнопки. Ниже приведен пример, в котором создаются три расположенные по вертикали кнопки.

import java.awt.*;

import j ava.applet. *;

public class ButtonDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = biteger.parseInt(getParameter("height"));

Button yes = new Button("Yes");

Button no = new Button("No");

Button maybe = new Button("Undecided");

add(yes);

add(no);

add(maybe);

yes.reshape(0,0, width, height / 3);

no.reshape(0, height / 3, width, height / 3);

maybe.reshape(0,2 * height / 3, width, height / 3);

}

}

12.6. Класс Checkbox

Класс Checkbox часто используется для выбора одной из двух возможностей. При создании объекта Checkbox ему передается текст метки и логическое значение, чтобы задать исходное состояние окошка с отметкой. Программно можно получать и устанавливать состояние окошка с отметкой с помощью методов getState и setState. Ниже приведен пример с тремя объектами Checkbox, задаваемое в этом примере исходное состояние соответствует отметке в первом объекте.

import java.awt.*;

import j ava.applet. *;

public class CheckboxDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

Checkbox win1 = new Checkbox("Windows XP", null, true);

Checkbox win2 = new Checkbox("Windows 2000");

Checkbox win3 = new CheckboxfWindows 98");

add(win1);

add(win2);

add(win3);

win1.reshape(0,0, width, height / 3);

win2.reshape(0, height / 3, width, height / 3);

win3.reshape(0,2 * height / 3, width, height / 3);

}

}

12.7. Класс CheckboxGroup

Второй параметр конструктора Checkbox (в предыдущем примере мы ставили там null) используется для группирования нескольких объектов Checkbox. Для этого сначала создается объект CheckboxGroup, затем он передается в качестве параметра любому количеству конструкторов Checkbox, при этом предоставляемые этой группой варианты выбора становятся взаимоисключающими (только один может быть задействован). Предусмотрены и методы, которые позволяют получить и установить группу, к которой принадлежит конкретный объект Checkbox — getCheckboxGroup и setCheckboxGroup. Вы можете пользоваться методами getCurrent и setCurrent для получения и установки состояния выбранного в данный момент объекта Checkbox. Ниже приведен пример, отличающийся от предыдущего тем, что теперь различные варианты выбора в нем взаимно исключают друг друга.

import java.awt.*;

import java.applet.*;

public class CheckboxGroupDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

CheckboxGroup g = new CheckboxGroup();

Checkbox winl = new Checkbox("Windows XP", g, true);

Checkbox win2 = new Checkbox("Windows 2000", g, false);

Checkbox win3 = new Checkbox("Windows 98", g, false);

add(winl);

add(win2);

add(win3);

winl.reshape(0,0, width, height / 3);

win2. reshape(0, height / 3, width, height / 3);

win3.reshape(0,2 * height / 3, width, height / 3);

}

}

12.8. Класс Choice

Класс Choice (выбор) используется при создании раскрывающихся списочных меню (выпадающих списков типа ComboBox в Windows). Компонент Choice занимает ровно столько места, сколько требуется для отображения выбранного в данный момент элемента, когда пользователь щелкает мышью на нем, раскрывается меню со всеми элементами, в котором можно сделать выбор. Каждый элемент меню — это строка, которая выводится, выровненная по левой границе. Элементы меню выводятся в том порядке, в котором они были добавлены в объект Choice. Метод countItems возвращает количество пунктов в меню выбора. Вы можете задать пункт, который выбран в данный момент, с помощью метода select, передав ему либо целый индекс (пункты меню перечисляются с нуля), либо строку, которая совпадает с меткой нужного пункта меню. Аналогично с помощью методов getSelectedItem и getSelectedIndex можно получить, соответственно, строку-метку и индекс выбранного в данный момент пункта меню. Вот очередной простой пример, в котором создается два объекта Choice.

import java.awt.*;

import java.applet.*;

public class ChoiceDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

Choice os = new Choice();

Choice browser = new Choice();

os.addItem("Windows XP");

os.addItem("Windows 2000");

os.addItem("Windows 98");

browser. addItem("Netscape Navigator");

browser.addItem("Mozula");

browser.addItem("Internet Explorer ");

browser.addItem("Mosaic ");

browser.addItem("Lynx ");

browser.select("Netscape Navigator");

add(os);

add(browser);

os.reshape(0,0, width, height / 2);

browser.reshape(0, height / 2, width, height / 2);

}

}

12.9. Класс List

Класс List представляет собой компактный список с возможностью выбора нескольких вариантов и с прокруткой (аналог ListBox в Windows). Ниже приведен пример с двумя списками выбора, один из которых допускает выбор нескольких элементов, а второй — выбор единственного элемента,

import java.awt.*;

import java.applet.*;

public class ListDemo extends Applet {

public void initQ { setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter(“height"));

List os = new List(0, true);

List browser = new List(0, false);

os.addItem("Windows XP");

os.addItem("Windows 2000");

os.addItem("Windows 98");

browser.addItem("Netscape Navigator ");

browser.addItem("Netscape Communicator ");

browser.addItem("lnternet Explorer ");

browser.addItem("Mosaic ");

browser.addItem("Lynx ");

browser.select(1);

add(os);

add(browser);

os.reshape(0, 0, width, height / 2);

browser.reshape(0, height / 2, width, height / 2);

}

}

12.10. Класс Scrollbar

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

Конструктор класса Scrollbar позволяет задавать ориентацию линейки прокрутки — для этого предусмотрены константы VERTICAL и HORIZONTAL. С помощью конструктора можно задать начальное положение и размер движка, а также минимальное и максимальное значения, в пределах которых линейка прокрутки может изменять параметр. Для получения и установки текущего состояния линейки прокрутки используются методы getValue и setValue. Воспользовавшись методами getMinimum и getMaximum, вы можете получить рабочий диапазон объекта. Ниже приведен пример, в котором создается и вертикальная, и горизонтальная линейки прокрутки.

import java.awt.*;

import java.applet.*;

public class ScrollbarDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter(“width”));

int height = Integer. parseInt(getParameter(“height"));

Scrollbar hs = new Scrollbar(Scrollbar.HORIZONTAL, 50, width / 10, 0,100);

Scrollbar vs = new Scrollbar(Scrollbar.VERTICAL, 50, height / 2,0,100);

add(hs);

add(vs);

int thickness =16;

hs.reshape(0, height - thickness, width - thickness, thickness);

vs.reshape(width - thickness, 0, thickness, height - thickness);

}

}

12.11. Класс TextField

Класс TextField представляет собой реализацию однострочной области для ввода текста. Такие области часто используются в формах для пользовательского ввода. Вы можете «заморозить» содержимое объекта TextField с помощью метода setEditable, а метод isEditable сообщит вам, можно ли редактировать текст в данном объекте. Текущее значение объекта можно получить методом getText и установить методом setText. С помощью метода select можно выбрать фрагмент строки, задавая его начало и конец, отсчитываемые с нуля. Для выбора всей строки используется метод selectAll.

Метод setEchoChar задает символ, который будет выводиться вместо любых вводимых символов. Вы можете проверить, находится ли объект TextField в этом режиме, с помощью метода echoCharlsSet и узнать, какой именно символ задан для эхо-печати, с помощью метода getEchoChar. Вот пример, в котором создаются классические поля для имени пользователя и пароля.

import java.awt.*;

import java.applet.*;

public class TextFieldDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter(“height"));

Label namep = new Label("Name : ", Label.RIGHT);

Label passp = new Label("Password :”, Label.RIGHT);

TextField name = new Text Field(8);

TextField pass = new TextField(8);

pass.setEchoChar('*');

add(namep);

add(name);

add(passp);

add(pass);

int space = 25;

int wl = width / 3;

namep.setBounds(0, (height - space) / 2, wl, space);

name.setBounds(wl, (height - space) / 2, wl, space);

passp.setBounds(0, (height + space) / 2, wl, space);

pass.setBounds(wl, (height + space) / 2, wl, space);

}

}

12.12. Класс TextArea

Порой одной строки текста оказывается недостаточно для конкретной задачи. AWT включает в себя очень простой многострочный редактор обычного текста, называемый TextArea. Конструктор класса TextArea воспринимает значение типа String в качестве начального текста объекта. Кроме того, в конструкторе указывается число колонок и строк текста, которые нужно выводить. Есть три метода, которые позволяют программе модифицировать содержимое объекта TextArea: appendText добавляет параметр типа String в конец буфера; insertText вставляет строку в заданное отсчитываемым от нуля индексом место в буфере; replaceText копирует строку-параметр в буфер, замещая ею текст, хранящийся в буфере между первым и вторым параметрами-смещениями. Ниже приведена программа, создающая объект TextArea и вставляющая в него строку.

import java.awt.*;

import java.applet.*;

public class TextAreaDemo extends Applet {

public void init() {

setLayout(null);

int width = Integer.parseInt(getParameter(“width"));

int height = Integer.parseInt(getParameter("height"));

String val = "Хочешь быть великим - " + "стань им.\n" +

"Только в начале\n" + "победи сам себя\n" +

"и в первую очередь\n" + "свою лень.\n\n";

TextArea text = new TextArea(val, 80,40); add(text);

text.setBounds(0,0, width, height);

}

}

12.13.  Стратегии размещения компонентов

Все компоненты, с которыми мы работали до сих пор в этой главе, размещались «вручную». И в каждом примере мы вызывали загадочный метод setLayout(null). Этот вызов запрещал использование предусмотренного по умолчанию механизма управления размещением компонентов. Для решения подобных задач в AWT предусмотрены диспетчеры размещения (layout managers).

12.13.1. Диспетчер размещения LayoutManager

Каждый класс, реализующий интерфейс LayoutManager, следит за списком компонентов, которые хранятся с именами типа String. Всякий раз, когда вы добавляете компонент в Panel, диспетчер размещения уведомляется об этом. Если требуется изменить размер объекта Panel, то идет обращение к диспетчеру посредством методов minimumLayoutSize и preferredLayoutSize. В каждом компоненте, который приходится обрабатывать диспетчеру, должны присутствовать реализации методов preferredSize и minimumSize. Эти методы должны возвращать предпочтительный и минимальный размеры для прорисовки компонента, соответственно. Диспетчер размещения по возможности будет пытаться удовлетворить эти запросы, в то же время заботясь о целостности всей картины взаимного расположения компонентов.

В Java есть несколько предопределенных классов — диспетчеров размещения, описываемых ниже.

12.13.2. Стратегия FIowLayout

Класс FIowLayout реализует простой стиль размещения, при котором компоненты располагаются, начиная с левого верхнего угла, слева направо и сверху вниз. Если в данную строку не помещается очередной компонент, он располагается в левой позиции новой строки. Справа, слева, сверху и снизу компоненты отделяются друг от друга небольшими промежутками. Ширину этого промежутка можно задать в конструкторе FIowLayout. Каждая строка с компонентами выравнивается по левому или правому краю, либо центрируется в зависимости от того, какая из констант LEFT, RIGHT или CENTER была передана конструктору. Режим выравнивания по умолчанию — CENTER, используемая по умолчанию ширина промежутка — 5 пикселей. Ниже приведен пример, в котором в Panel включается несколько компонентов Label. Объект Panel использует FIowLayout с выравниванием RIGHT.

import java.awt.*;

import j ava. applet. *;

import java.util.*;

public class FlowLayoutDemo extends Applet {

public void init() {

setLayout(new FlowLayout(FlowLayout.RIGHT, 10,3));

int width = Integer.parseInt(getParanieter(,,width"));

int height = Integer.parseInt(getParameter("height"));

String val = "Разложим это предложение по словам";

StringTokenizer st = new StringTokenizer(val);

while (st.hasMoreTokens()) {

add(new Button(st.nextToken()));

}

}

}

12.13.3. Стратегия BorderLayout

Класс BorderLayout реализует обычный стиль размещения для окон верхнего уровня, в котором предусмотрено четыре узких компонента фиксированной ширины по краям и одна большая область в центре, которая может расширяться и сужаться в двух направлениях, занимая все свободное пространство окна. У каждой из этих областей есть строки-имена: String.North, String. South, String.East и String.West соответствуют четырем краям, a Center — центральной области. Ниже приведен пример BorderLayout с компонентом в каждой из названных областей.

import java.awt.*;

import j ava.applet. *;

import java.util.*;

public class BorderLayoutDemo extends Applet

{

public void init() {

setLayout(new BorderLayout());

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

add("North", new Button("Вверху"));

add(" South", new Label("Внизу"));

add("East", new Button("Слева"));

add("West", new Button ("Справа"));

String msg = "Пример показывает " +

"как компоненты размещаются\n" +

"по сторонам света.\n\n";

add("Center", new TextArea(msg));

}}

12.13.4. Стратегия GridLayout

Класс GridLayout размещает компоненты в простой равномерной сетке. Конструктор этого класса позволяет задавать количество строк и столбцов. Ниже приведен пример, в котором GridLayout используется для создания сетки 4x4, 15 квадратов из 16 заполняются кнопками, помеченными соответствующими индексами. Как вы уже, наверное, поняли, это панель для игры в «пятнашки».

import j ava.awt. *;

import java.applet. *;

public class GridLayoutDemo extends Applet {

static final int n = 4;

public void init()

{

setLayout(new GridLayout(n, n));

setFont(new Font("Helvetica", Font.BOLD, 24));

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {

intk = i * n + j;

if (k > 0)

add(new Button("" + k));

}

}

}

12.14. Программирование окон - Window

Класс Window во многом напоминает Panel за тем исключением, что он создает свое собственное окно верхнего уровня. В основном используется не непосредственно класс Window, а его подкласс Frame. Frame — это как раз то, что обычно и считают окном на рабочей поверхности экрана. У объекта Frame есть строка с заголовком, управляющие элементы для изменения размера и линейка меню. Для того чтобы вывести (спрятать) изображение объекта Frame, нужно использовать методы show и hide. Ниже приведен пример апплета, который показывает объект Frame с содержащимся в нем компонентом TextArea.

import java.awt. *;

import java.applet.*;

public class FrameDemo extends Applet {

public void init() {

int width = lnteger.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

String val = "Это учебное пособие " + "предназначено для ознакомления\n"

+ "с основами программирования на \n"

+ "объектно-ориентированном языке Java.\n\n";

TextArea text = new TextArea(val, 80,40);

Frame f = new Frame("Demo Frame");

f.setSize(width, height);

f.add("Center", text);

f.show();

}

}

12.15. Программирование меню

С каждым окном верхнего уровня может быть связана линейка меню. Объект MenuBar может включать в себя несколько объектов Menu. Последние, в свою очередь, содержат в себе список вариантов выбора — объектов MenuItem. Menu — подкласс MenuItem, так что объекты Menu также могут включаться в этот список, что позволяет создавать иерархически вложенные подменю. Вот пример, в котором к окну добавлены несколько вложенных меню.

import java.awt.*;

import java.applet. *;

public class MenuDemo extends Applet

{

public void init()

{

int width = Integer.parseInt(getParameter("width"));

int height = Integer.parseInt(getParameter("height"));

Frame f = new Frame("Demo Frame");

f.setSize(width, height);

MenuBar mbar = new MenuBar();

f. setMenuBar(mbar);

Menu file = new Menu("Файл");

file.add(new MenuItem("Новый..."));

file.add(newMenuItem("Открыть..."));

file.add(newMenuItem(“Закрыть”));

file.add(new Menultem("-"));

file.add(new MenuItem ("Выход..."));

mbar.add(file);

Menu edit = new Menu("Правка");

edit.add(newMenuItem("Bырeзaть"));

edit. add(new MenuItem("Копировать"));

edit.add(newMenultem("Вставить"));

edit.add(new Menultem("-"));

Menu sub = new Menu("Специальное");

sub.add(new MenuItem ("Первое"));

sub.add(new MenuItem("Bтopoe"));

sub. add(new Menultem("Третье"));

edit.add(sub);

edit.add(new CheckBoxMenuItem("Отладка"));

edit.add(new CheckBoxMenuItem ("Тестирование"));

mbar.add(edit);

f.show();

}

}

12.16. Модель обработки событий от компонентов

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

Существует два различных типа событий - низкоуровневые и семантические. Низкоуровневые события связаны с физическими аспектами интерфейса пользователя - щелчками мыши, нажатиями клавиш клавиатуры и т.д. Семантические события строятся на базе низкоуровневых событий. Все низкоуровневые события являются подклассами класса ComponentEvent:

1. Containerevent. Возникает всякий раз, когда компонент добавляется или удаляется из контейнера;

2. FocusEvent. Предупреждает программу, что компонент получил или потерял фокус ввода;

3. InputEvent. Этот класс включает дополнительные подклассы KeyEvent и MouseEvent;

4. WindowEvent. Извещает программу, что пользователь воспользовался одним из системных элементов управления окна, например, кнопкой минимизации или кнопкой закрытия приложения.

К семантическим относятся следующие события:

1. ActionEvent. Уведомляет программу о выполнении специфического действия, связанного с некоторым компонентом (например, щелчка на кнопке);

2. AdjustmentEvent. Указывает, что было выполнено перемещение бегунка полосы прокрутки;

3. ItemEvent. Уведомляет программу, что пользователь измнил состояние переключателя, списка или флажка опции;

4. TextEvent. Возникает в том случае, когда пользователь изменяет текст в компонентах типа TextArea или TextField.

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

1. mouseEnter вызывается в том случае, когда мышь входит в компонент;

2. mouseExit вызывается при выходе мыши из области компонента;

3. mouseMove вызывается при перемещении мыши в области компонента;

4. mouseDown вызывается при нажатии кнопки мыши;

5. mouseDrag вызывается при перемещении мыши с нажатой кнопкой;

6. mouseUp вызывается при отпускании кнопки мыши.

Аналогично keyDown и keyUp вызываются при каждом нажатии и отпускании клавиши. Событие передается методу вместе с кодом нажатой клавиши. Событие можно проверить, чтобы посмотреть, нажаты ли в данный момент ка- кие-либо клавиши-модификаторы, для этой цели можно также пользоваться методами shiftDown, controlDown и metaDown. В классе Event определены десятки констант, позволяющих использовать символические имена, например, PGUP и НОМЕ.

Для того, чтобы создать обработчик событий от какого-либо компонента необходимо выполнить целый ряд действий. Процедура обработки условно показана на рис. 12.1. Создание обработчика события можно разделить на пять описанных ниже этапов.

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

Рис. 12.1. Взаимосвязь объектов при обработке события

1) Создайте объект-адаптер (в данном примере создается адаптер для АсtionListener)

jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButton1_actionPerformed(e);

}

});

2) Свяжите адаптер с требуемым компонентом

jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButton1_actionPerformed(e);

}

});

3) Создайте объект Event

4) Передайте объект Event адаптеру

jButtonl.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButton1_actionPerformed(e);

}

});

5) Передайте объект Event компоненту

jButtonl.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

jButton1_actionPerformed(e);

}

});

ЗАКЛЮЧЕНИЕ

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

БИБЛИОГРАФИЧЕСКИЙ СПИСОК

1. Стефен Р. Дэвис. Программирование на Microsoft Visual Java++: пер. с англ. - М.: Издательский отдел «Русская редакция», 1997.

2. Ленди М., Сиддикви С., Свишер Д., Borland JBuilder. Руководство разработчика.: пер. с англ. - М.: Издательский дом «Вильямс», 2004.

3. Нотон П. Java. Справочное руководство: пер. с англ. - М.: Восточная книжная компания, 1996.

4. Морган М. Java 2. Руководство разработчика: пер. с англ.: учеб. пособие. - М.: Издательский дом «Вильямс», 2000.

Content

Сухов С. А. Основы программирования на Java

Основы программирования на Java

ВВЕДЕНИЕ

ОСНОВНЫЕ ПОНЯТИЯ 1. ПЕРЕМЕННЫЕ

2. ТИПЫ

3. МАССИВЫ

4. ОПЕРАТОРЫ

5. УПРАВЛЕНИЕ ВЫПОЛНЕНИЕМ ПРОГРАММЫ

6. ЦИКЛЫ

ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ НА JAVA 7. КЛАССЫ

8. ПАКЕТЫ И ИНТЕРФЕЙСЫ

9. ОБРАБОТКА ИСКЛЮЧЕНИЙ

10. МНОГОПОТОЧНОЕ ПРОГРАММИРОВАНИЕ

11. ввод/вывод

12. ПРОГРАММИРОВНИЕ ГРАФИЧЕСКИХ ПОЛЬЗОВАТЕЛЬСКИХ ИНТЕРФЕЙСОВ

ЗАКЛЮЧЕНИЕ

БИБЛИОГРАФИЧЕСКИЙ СПИСОК