Программирование на языке Java

1. заполнение всего массива nameMassiv[] или его части (from…to) указанным значением value:

static void fill(type nameMassiv[], type value);

static void fill(type nameMassiv[], int from, int to, type value);

где type - один из восьми типов byte, short, int, long, char, float, double, Object.

Пример:

int myVector[]=new int[10];

System.out.println(“Исходный вектор:”);

Arrays.fill(myVector, 5);// вызов метода заполнения массива

for (int value: myVector)

System.out.printf(“%5d”, value);

В окне вывода появится:

Исходный вектор:

5 5 5 5 5 5 5 5 5 5

2. сортировка всего массива или его части по возрастанию:

static void sort(type nameMassiv[]);

static void sort(type nameMassiv[], int from, int to);

Пример:

int myVector[]=new int[10]{9,8,7,6,5,4,3,2,1,0};

System.out.println(“Исходный вектор:”);

for (int value: myVector)

System.out.printf(“%5d”, value);

Arrays.sort(myVector); // вызов метода сортировки

System.out.println(“Отсортированный вектор:”);

for (int value: myVector)

System.out.printf(“%5d”, value);

В окне вывода появится:

Исходный вектор:

9 8 7 6 5 4 3 2 1 0

Отсортированный вектор:

0 1 2 3 4 5 6 7 8 9

3. бинарный поиск заданного элемента element в предварительно отсортированном массиве или его части:

static int binarySearch(type nameMassiv[], type element);

static int binarySearch(type nameMassiv[], int from, int to, type element);

Метод возвращает индекс найденного элемента массива (индексация элементов начинается с нуля). Если элемент не найден, то возвращается отрицательное число, абсолютная величина которого означает индекс, с которым элемент был бы вставлен в массив в заданном порядке;

4. сравнение массивов:

static boolean equals(type nameMassiv_1[],type nameMassiv_2[]);

Массивы считаются равными и метод возвращает true, если они имеют одинаковую длину и равны все элементы массивов с одинаковыми индексами. Для сравнения многомерных массивов используется метод:

static boolean deepEquals(Object nameMassiv_1[],Object nameMassiv_2[]);

5. представление массива строкой:

static String toString(type nameMassiv[]);

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

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

static String deepToString(Object nameMassiv[]);

14.3 Строки

Строки в Java - это экземпляры классов, объекты. Для работы с ними используются два класса: String и StringBuffer. Поэтому с формальной точки зрения создание текста (строк) сводится к созданию объекта одного из этих классов. Основное различие между этими классами состоит в том, что объекты класса String изменять нельзя, а объекты класса StringBuffer - можно.

Оба этих класса определены в базовом пакете java.lang , который доступен по умолчанию, поэтому импорт пакета выполнять не нужно.

14.4 Класс String

Создать строку текста класса String можно оператором присваивания:

String text=”Это текстовая строка”;

При этом создается объектная переменная (ссылка) text на объект с текстом. Если изменить этот текст:

String text=”Это новая текстовая строка”;

То создается новый объект с новым текстом, на который сейчас будет указывать ссылка text. Старый объект со старым текстом остается в памяти компьютера до “уборки мусора”. При этом создается полная иллюзия того, что мы работаем с одной и той же строкой.

Создать строку текста можно также с помощью многочисленных конструкторов класса String:

1. создание пустой строки:

String text=new String();

создана пустая строка text;

2. создание копии объекта-строки:

String text=”Это текстовая строка”;

String newText=new String(text);

создан новый объект-строка newText с таким же содержанием, как и объект text;

3. создание новой строки на основе символьного массива:

char symbols[]={`J', `a', `v', `a'};

String text=new String(symbols);

создан новый объект-строка text с содержанием “Java”,

4. создание новой строки на основе массива байтов:

byte nums[]={65, 66, 67, 68};

String text=new String(nums);

создан новый объект-строка text с содержанием “ABCD” (используются ASCII -коды символов). Такая ситуация возникает при чтении ASCII-файлов, извлечении информации из базы данных или при передаче информации по сети. Если исходный кириллический ASCII-файл (ASCII-текст) был в кодировке CP-1251 (windows 1251), то JAVA-строка будет создана правильно.

14.5 Методы для работы со строками класса String

В классе String собрано много методов для работы со строками. Вот некоторые из них:

1. определение длины строки:

String str=”Это текстовая строка”;

int n=str.length(); // n=20

2. определение пустой строки:

String str=””;

boolean value=str.isEmpty(); // value=true - строка пустая

3. определение символа в строке по его индексу:

String str=”Это текстовая строка”;

char ch=str.charAt(5); // ch='е' - нумерация начинается с нуля!

4. преобразование строки в массив символов (ASCII-кодировка):

String str=”Это строка”;

char chArray[]=str.toCharArray();

создан массив символов chArray[] с содержанием {`Э',`т',`о',` ',`с',`т', `р',`о',`к',`а'};

5. преобразование строки в массив байтов по ASCII-кодировке:

String str=”ABCDE”;

byte byteArray[]=str.getBytes();

создан массив байтов byteArray[] с содержанием {65, 66, 67, 68, 69};

6. сравнение двух строк с учетом регистра:

String str_1=”Даша”;

String str_2=”даша”;

boolean result=str_1.equals(str_2); // result=true, т.к. Даша>даша

строки сравниваются посимвольно (по ASCII-кодам) слева направо до первого несовпадения,

7. сравнение двух строк без учета регистра:

String str_1=”Вася Пупкин”;

String str_2=”ВАСЯ ПУПКИН”;

boolean result=str_1.equalsIgnoreCase(str_2); // result=true

Внимание! Для сравнения строк нельзя использовать операции == и !=.

8. поиск символов и подстрок в строке с начала строки:

String str=”Наша Маша шагает в шапке”;

char chr='а';

int result=str.indexOf(chr); // result=1 (нумерация символов

// начинается с нуля)

String str_1=”ша”;

result=str.indexOf(str_1); // result=2 - первое “ша”

// начинается со второго символа

если подстрока не найдена, то результат поиска равен -1,

9. поиск символов и подстрок в строке с конца строки:

String str=”Наша Маша шагает в шапке”;

char chr='а';

int result=str.lastIndexOf(chr); // result=20 (нумерация символов

// начинается с нуля)

String str_1=”ша”;

result=str.lastIndexOf(str_1); // result=19

если в исходной строке имеются ESC-последовательности (\n) , то каждая из них считается одним символом;

10. выделение подстроки из исходной строки:

String str=”Мы программируем на Java”;

String s=str.subString(3, 16); // s=программируем

задается индекс начального символа (3) и индекс символа, который уже не будет входить в подстроку (16),

11. замена одного символа в строке другим:

String str=”Мы программируем на Java”;

String s=str.replace(` `, `_'); // заменяем все пробелы

// на символы подчеркивания

12. замена одной подстроки на другую:

String str=”Наша Маша шагает в шапке”;

String s=str.replaceAll(“ша”, “ся”); // заменяем все вхождения

// “ша” на “ся”

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

String str=”Наша Маша шагает в шапке”;

String s=str.replaceFirst(“ша”, “ся”); // заменяем первое вхождение

// “ша” на “ся”

13. удаление начальных и конечных пробелов в строке:

String str=” Мы программируем на Java ”;

String s=str.trim(); // строка s без начальных

// и конечных пробелов

14. перевод всех букв в строке в нижний регистр (строчные буквы):

String str=”Маша и Даша”;

String s=str.toLowerCase(); // s=”маша и даша”

15. перевод всех букв в строке в верхний регистр (прописные буквы):

String str=”Маша и Даша”;

String s=str.toUpperCase(); // s=”МАША И ДАША”

16. разбиение строки на подстроки (создание массива подстрок):

String str=”Маша и Даша”;

String massiv[]s=str.split(“ “);

создается массив строк, элементы которого - это подстроки (слова), разделенные символами, указанными в качестве аргумента метода (в данном случае - пробелом):

massiv[0]=”Маша”;

massiv[1]=”и”;

massiv[2]=”Даша”;

при этом сами разделители в подстроки не входят,

17. поиск совпадения начала двух строк:

String str=”Берегите природу - мать вашу”;

String val=”Берег”;

boolean result=str.startsWith(val); // result=true

в этом случае строка str начинается с символов строки val,

18. поиск совпадения окончаний двух строк:

String str=”Берегите природу - мать вашу”;

String val=”шу”;

boolean result=str.endsWith(val); // result=true

в этом случае строка str заканчивается символами строки val.

Допускается сложение строк с числовыми величинами:

String str = 1 + 2 + 3; // str=”6”

Сначала выполняется арифметическое сложение, а затем результат преобразуется в строку.

При программировании этой операции нужно быть очень внимательным:

String str=”Сумма=” + 1 + 2 + 3; // str= “сумма=123”

В этом случае сначала производится сложение двух строк “Сумма=” +1 , причем второй операнд автоматически преобразуется в строку. Таким же образом в строку добавляются третий и четвертый операнды.

String str=1 + 2 + “ не равно ” 1 + 2; // str=”3 не равно 12”

14.6 Класс StringBuffer

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

Помимо поля длины строки, у строк этого класса имеется еще поле capacity (емкость) - размер буфера под символы строки. Только что созданная строка имеет буфер, достаточный для хранения 16 символов. Как только буфер начинает переполняться, его емкость автоматически увеличивается, чтобы вместить новые символы.

Создать строку текста класса StringBuffer можно с помощью следующих конструкторов:

1. создание пустой строки:

StringBuffer text=new StringBuffer();

создана пустая строка text и автоматически зарезервирована память еще на 16 символов;

2. создание пустой строки с заданным размером буфера:

StringBuffer text=new StringBuffer(60);

создана пустая строка text и для нее зарезервирована память на 60+16 символов;

3. создание копии строки на основе существующей строки этого же класса:

StringBuffer text=new StringBuffer(StringBuffer str);

создан новый объект-строка text - копия строки str.

14.7 Методы для работы со строками класса StringBuffer

В классе StringBuffer собрано много методов для работы со строками:

1. определение текущей длины строки:

StringBuffer str = new StringBuffer(”Это текстовая строка”);

int n=str.length(); // n=20 - текущая длина строки в символах

2. определение выделенного для строки объема памяти:

StringBuffer str = new StringBuffer(”Это текстовая строка”);

int n=str.capacity(); // n=36 - текущая длина строки

// плюс 16 байтов

3. вставка подстроки в исходную строку:

StringBuffer str = new StringBuffer(”Это текстовая строка”);

str.insert(4,”новая ”); // str=”Это новая текстовая строка”

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

4. удаление подстроки из исходной строки:

StringBuffer str = new StringBuffer(”Это текстовая строка”);

str.delete(4, 14); // str=”Это строка”

первый аргумент метода - индекс начала удаляемой подстроки, второй - индекс первого после удаляемой подстроки символа,

5. добавление текста в конец строки:

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

str.append(“ и Си”); // str=”Мы изучаем Java и Си”

6. замена подстроки в строке:

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

str.replace(3, 10, “программируем на”); // str=”Мы программируем на

// Java”

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

7. переворот строки:

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

str.reverse(); // str=”avaJ меачузи ыМ”

аргументов у этого метода нет,

8. копирование строки класса StringBuffer в строку класса String:

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

String text = str.toString(); // text=”Мы изучаем Java”

9. копирование части строки класса StringBuffer в строку класса String (StringBuffer):

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

CharSequence text = str.subSequence(3, 10); // text=”изучаем”

Возвращаемое значение имеет тип CharSequence, прародительский для классов String и

StringBuffer,

10. копирование части строки класса StringBuffer в строку класса String:

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

String text= str.substring(3, 10); // text=”изучаем”

11. поиск подстроки в строке слева направо:

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

String text = ”изучаем”;

int n = str.indexOf(text); // n=3

Внимание! Искомая подстрока должна быть класса String!

Если подстрока не найдена, то возвращается значение -1,

12. поиск подстроки в строке справа налево:

StringBuffer str = new StringBuffer(”Мы изучаем языки Си и Си#”);

String text = ”Си”;

int n = str.lastIndexOf(text); // n=22

Внимание! Искомая подстрока должна быть класса String!

Если подстрока не найдена, то возвращается значение -1,

13. замена подстроки в строке:

StringBuffer str = new StringBuffer(”Мы изучаем Java”);

String text = ”Си”;

str.replace(11, 15, text); // str=”Мы изучаем Си”

Внимание! Заменяемая подстрока должна быть класса String!

В исходной строке были заменены все символы указанного диапазона (подстрока “Java”) на новую строку text. Правая граница заменяемого диапазона должна быть на единицу больше необходимой.

14.8 Файлы

Программы, написанные нами до этого, воспринимали информацию только с консоли (клавиатуры) или диалоговых окон ввода и выводили результат тоже на консоль (экран монитора) или в графические компоненты.

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

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

Считается, что в программу идет входной поток (input stream) символов Unicode или просто байтов, воспринимаемый в программе методами read().Из программы методами write(), print(), println(), printf() выводится выходной поток (output stream) символов или байтов. При этом неважно, куда направлен этот поток - на консоль, на принтер, в файл или в сеть.

Понятие потока оказалось настолько удобным и облегчающим программирование ввода/ вывода, что в Java предусмотрена возможность создания потоков, направляющих символы или байты не на внешнее устройство, а в массив или из массива, то есть связывающих программу с областью оперативной памяти. Более того, можно создать поток, связанный со строкой типа String, находящейся также в оперативной памяти. Еще один вид потока - поток байтов, составляющих объект Java. Его можно направить в файл или передать по сети, а потом восстановить в оперативной памяти. Эта операция называется сериализацией (serialization) объектов.

Методы организации потоков собраны в классы пакета java.io.

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

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

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

В современных алгоритмических языках такую структуру данных называют файлом.

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

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

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

Чтобы облегчить это преобразование, в пакет java.io введены классы FileReader и FileWriter. Они организуют преобразование потока: со стороны программы потоки символьные, со стороны файла - байтовые. Несмотря на различие потоков, использование классов файлового ввода/вывода очень похоже.

Чтобы открыть нужный файл для чтения или записи, необходимо создать объект класса FileInputStream и FileOutputStream. Аргументом конструктора класса указывается полное имя открываемого файла. Конструкторы обоих классов могут выбрасывать необрабатываемое исключение класса FileNotFoundException. Таким образом, создание объекта соответствующего класса в случае успеха означает открытие соответствующего файла для чтения/записи. После завершения работы с файлом его необходимо закрыть с использованием метода close(), который определен в каждом из классов.

Для побайтового считывания данных из файла используется метод read() класса FileInputStream. Считанный байт возвращается в виде целого числа. При считывании символа конца файла (EOF) методом read() в качестве результата возвращается значение -1.

Для записи данных в файл используется метод write() класса FileOutputStream. Записываемый в файл байт указывается аргументом метода. Метод не возвращает никакого результата. Методы close(), read(), write() могут выбрасывать необрабатываемое исключение IOException.

Пример: считать из текстового файла ishod.txt информацию, записанную в нем, и переписать ее в файл result.txt, заменяя пробелы символами подчеркивания. Исходный файл имеет вид:

Среди миров, в мерцании светил,

Одной звезды я повторяю имя,

Не потому, чтоб я ее любил,

А потому, что я томлюсь с другими.

Иннокентий Анненский

Код программы:

package javaapplicationfile;

import java.io.*;

import javax.swing.*;

public class JavaApplicationFile

{

public static void main(String[] args) throws IOException

{

String text;

try // попытка открытия файла

{

// создание файлового потока ввода из исходного файла

String fileInputPath="E:/User/ishod.txt";

FileInputStream fileIn=new FileInputStream(fileInputPath);

// создание файлового потока вывода в выходной файл

String fileOutputPath="E:/User/result.txt";

FileOutputStream fileOut=new FileOutputStream(fileOutputPath);

int n; // переменная целого типа для чтения/записи

n=fileIn.read();// чтение первого символа из исходного файла

fileOut.write(n); // запись первого символа в выходной файл

while(n!=-1) // пока не прочитан конец файла

{

n=fileIn.read(); // прочитать очередной символ из исходного файла

if (n==-1) // на всякий случай

break;

if (n==' ') // заменяем пробел на символ подчеркивания

n='_';

fileOut.write(n); // записать его в выходной файл

}

text="Программа закончила работу успешно!";

JOptionPane.showMessageDialog(null, text);

fileIn.close(); // закрытие исходного файла

fileOut.close(); // закрытие выходного файла

}

catch(FileNotFoundException e) // обработка исключительной

// ситуации

{

text="Файл не найден!";

JOptionPane.showMessageDialog(null, "Проверьте путь к файлу: " + e, text, JOptionPane.ERROR_MESSAGE);

}

}

}

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

Структура выходного файла result.txt:

Среди_миров,_в_мерцании_светил,

Одной_звезды_я_повторяю_имя,

Не_потому,_чтоб_я_ее_любил,

А_потому,_что_я_томлюсь_с_другими.

Иннокентий_Анненский

Результат работы программы в исключительной ситуации (исходный файл не найден):

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

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

Буферизированный поток позволяет считывать данные не посимвольно, а построчно. Он создается на основе символьного потока, который, в свою очередь создается на основе байтового потока с помощью классов FileInputStream и FileOutputStream. На их основе с помощью классов InputStreamReader и OutputStreamReader создаются символьные потоки. И, наконец, буферизированные потоки создаются на основе классов BufferedReader и BufferedWriter.

Пример: считать из предыдущего текстового файла ishod.txt информацию, записанную в нем, и переписать ее в файл result.txt, перевернув каждую строку. Перевернутые строки также вывести на консоль.

Код программы:

package javaapplicationbuffer;

import java.io.*;

import javax.swing.*;

public class JavaApplicationBuffer

{

public static void main(String[] args) throws IOException

{

try // попытка открытия файла

{

String text; // text - объект класса String

StringBuffer str; // str - объект класса

// StringBuffer

String fileInputPath="E:/User/ishod.txt";

// создание байтового потока ввода из исходного файла

FileInputStream fileIn=new FileInputStream(fileInputPath);

// создание буферизированного потока ввода на основе символьного

BufferedReader bufRead=new BufferedReader(new InputStreamReader(fileIn, "windows-1251"));

String fileOutputPath="E:/User/result.txt";

// создание байтового потока вывода в выходной файл

FileOutputStream fileOut=new FileOutputStream(fileOutputPath);

// создание буферизированного потока вывода на основе символьного

BufferedWriter bufWrite=new BufferedWriter(new OutputStreamWriter(fileOut));

do // цикл чтения исходного файла

{

try // попытка чтения очередной строки из файла

{

// читаем очередную строку из исходного файла

text=bufRead.readLine();

// записываем ее в объект класса StringBuffer

str=new StringBuffer(text);

// переворачиваем строку

str.reverse().toString();

// записываем ее снова в переменную text класса String

text=new String(str);

// выводим перевернутую строку на консоль

System.out.println(text);

// и записываем ее в выходной файл

bufWrite.write(text);

// переход на новую строку в выходном файле

bufWrite.newLine();

}

// попытка чтения строки после конца файла

catch(NullPointerException e)

{

JOptionPane.showMessageDialog(null, "Прочитан конец файла");

break;

}

} while(true); // псевдобесконечный цикл чтения

// из исходного файла

text="Программа закончила работу успешно!";

JOptionPane.showMessageDialog(null, text);

fileIn.close(); // закрытие исходного файла

fileOut.close(); // закрытие выходного файла

}

// обработка исключительной ситуации

catch(FileNotFoundException e)

{

JOptionPane.showMessageDialog(null, "Проверьте путь к файлу: " + e, "Файл не найден!", JOptionPane.ERROR_MESSAGE);

}

}

}

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

Структура выходного файла result.txt:

,литевс иинацрем в ,ворим идерС

,ями юяротвоп я ыдзевз йондО

,либюл ее я ботч ,умотоп еН

.имигурд с ьсюлмот я отч ,умотоп АйиксненнА йитнеконнИ

Результат работы программы в исключительной ситуации (исходный файл не найден):

В данной программе наряду с объектом text класса String был использован объект str класса StringBuffer, так как этот класс имеет метод reverse() для переворачивания строк.

15. Обработка исключительных ситуаций

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

if (переменная name вышла за диапазон)

{

действия программы в аварийной ситуации

}

На это уходит много времени, а сама программа превращается в набор таких проверок. Любая производственная программа, написанная на алгоритмических языках С или Pascal, состоит на 2/3 из них. Конечно, все случаи предусмотреть нельзя, поэтому рано или поздно какая-нибудь ошибочная ситуация приведет к аварийному завершению программы.

Внимание! Программа должна завершать работу, когда это нужно программисту, а не когда

она этого захочет!

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

Исключительная ситуация - это ошибка, которая возникает при выполнении программы.

Исключение - это объект, который описывает исключительную ситуацию (ошибку).

При обработке ошибки используется бейсбольная терминология (ну как же, америкосы!). Говорят, что программа выбрасывает (throws) объект-исключение, если произошла исключительная ситуация. Этот объект пролетает через всю программу, появившись сначала в том методе, где произошла ошибка. Программа в одном или нескольких местах пытается (try) его перехватить (catch) и обработать. Для того, чтобы попытаться (try) перехватить объект-исключение, нужно весь код программы, в котором может возникнуть исключительная ситуация, охватить операторами:

try

{

проверяемый код программы

}

catch (тип исключения)

{

действия в исключительной ситуации

}

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

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

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

Пример: определить значение переменной действительного типа и целого типа i=y/x, причем значение знаменателя ввести с помощью диалогового окна:

package javaapplicationtry;

import java.io.*;

import javax.swing.*;

public class JavaApplicationTry

{

public static void main(String[] args) throws IOException

{

double x, y=5.0, z=0;

int i;

String input;

input=JOptionPane.showInputDialog("Введите значение знаменателя:");

try

{

x=Double.parseDouble(input); //преобразование типов

z=Math.sqrt(y/x); // извлечение квадратного корня

i=(int)y/(int)x; // целочисленное деление

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

}

catch (ArithmeticException eArithmetic)