Java: Операторы throw и throws. Операторы throw без параметров

Для Windows 23.03.2019
Для Windows

Равномерное прямолинейное движение – это частный случай неравномерного движения.

Неравномерное движение – это движение, при котором тело (материальная точка) за равные промежутки времени совершает неодинаковые перемещения. Например, городской автобус движется неравномерно, так как его движение состоит в основном из разгонов и торможений.

Равнопеременное движение – это движение, при котором скорость тела (материальной точки) за любые равные промежутки времени изменяется одинаково.

Ускорение тела при равнопеременном движении остаётся постоянным по модулю и по направлению (a = const).

Равнопеременное движение может быть равноускоренным или равнозамедленным.

Равноускоренное движение – это движение тела (материальной точки) с положительным ускорением, то есть при таком движении тело разгоняется с неизменным ускорением. В случае равноускоренного движения модуль скорости тела с течением времени возрастает, направление ускорения совпадает с направлением скорости движения.

Равнозамедленное движение – это движение тела (материальной точки) с отрицательным ускорением, то есть при таком движении тело равномерно замедляется. При равнозамедленном движении векторы скорости и ускорения противоположны, а модуль скорости с течением времени уменьшается.

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

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

V cp = s / t

– это скорость тела (материальной точки) в данный момент времени или в данной точке траектории, то есть предел, к которому стремится средняя скорость при бесконечном уменьшении промежутка времени Δt:

Вектор мгновенной скорости равнопеременного движения можно найти как первую производную от вектора перемещения по времени:

Проекция вектора скорости на ось ОХ:

V x = x’

это производная от координаты по времени (аналогично получают проекции вектора скорости на другие координатные оси).

– это величина, которая определяет быстроту изменения скорости тела, то есть предел, к которому стремится изменение скорости при бесконечном уменьшении промежутка времени Δt:

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

Если тело движется прямолинейно вдоль оси ОХ прямолинейной декартовой системы координат, совпадающей по направлению с траекторией тела, то проекция вектора скорости на эту ось определяется формулой:

V x = v 0x ± a x t

Знак «-» (минус) перед проекцией вектора ускорения относится к равнозамедленному движению. Аналогично записываются уравнения проекций вектора скорости на другие оси координат.

Так как при равнопеременном движении ускорение является постоянным (a = const), то график ускорения – это прямая, параллельная оси 0t (оси времени, рис. 1.15).

Рис. 1.15. Зависимость ускорения тела от времени.

Зависимость скорости от времени – это линейная функция, графиком которой является прямая линия (рис. 1.16).

Рис. 1.16. Зависимость скорости тела от времени.

График зависимости скорости от времени (рис. 1.16) показывает, что

При этом перемещение численно равно площади фигуры 0abc (рис. 1.16).

Площадь трапеции равна произведению полусуммы длин её оснований на высоту. Основания трапеции 0abc численно равны:

0a = v 0 bc = v

Высота трапеции равна t. Таким образом, площадь трапеции, а значит, и проекция перемещения на ось ОХ равна:

В случае равнозамедленного движения проекция ускорения отрицательна и в формуле для проекции перемещения перед ускорением ставится знак «–» (минус).

График зависимости скорости тела от времени при различных ускорениях показан на рис. 1.17. График зависимости перемещения от времени при v0 = 0 показан на рис. 1.18.

Рис. 1.17. Зависимость скорости тела от времени для различных значений ускорения.

Рис. 1.18. Зависимость перемещения тела от времени.

Скорость тела в данный момент времени t 1 равна тангенсу угла наклона между касательной к графику и осью времени v = tg α, а перемещение определяют по формуле:

Если время движения тела неизвестно, можно использовать другую формулу перемещения, решая систему из двух уравнений:

Поможет нам вывести формулу для проекции перемещения:

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

Графиком координаты x(t) также является парабола (как и график перемещения), но вершина параболы в общем случае не совпадает с началом координат. При а x < 0 и х 0 = 0 ветви параболы направлены вниз (рис. 1.18).

Обработка исключений строится на использовании трех ключевых слов: try , catch и throw . Сначала рассмотрим этот процесс в самых общих чертах. Операторы программы, предназначенные для управления исключениями, содержатся в блоке try. Если исключение (т.е. ошибка) возникает в блоке try, происходит его "выброс" (с помощью оператора throw). "Выброшенное" исключение подхватывается (вернее, перехватывается) с помощью оператора catch и затем обрабатывается. А теперь более детально.

Как отмечено выше, любой оператор, который генерирует исключение, должен выполняться внутри блока try. (Функции, вызываемые из блока try, также могут генерировать исключения.) Любое исключение должно быть перехвачено оператором catch, который располагается сразу после оператора try, сгенерировавшего исключение. Общая форма записи блоков try и catch имеет следующий вид.

Try{ //блок_trу } catch (тип1 arg ) { //блок_саtch_l } catch (тип2 arg ) { //блок_catch_2 } catch (типЗ arg ) { //блок_сatch_3 } // . . . catch (типN arg ) { //блок_catch_N }

Блок try должен содержать ту часть программы, которая предназначена для обработки ошибок. Она может быть совсем небольшой и состоять всего из нескольких операторов, принадлежащих одной функции, или настолько всеобъемлющей, что в блок try будет помещено тело функции main()(в этом случае будет эффективно обрабатываться вся программа).

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

Оператор throw генерирует исключение. Вот как выглядит общая форма оператора throw,

Throw исключение ;

Оператор throw должен выполняться либо из самого блока try, либо из любой функции, вызываемой(прямо или косвенно) из блока try. Элемент исключение представляет собой "выбрасываемое" в этот критический момент значение.

Если программа сгенерирует исключение, для которого не найдется соответствующего оператора catch, может произойти аварийное завершение программы. При генерации необработанных исключений будет вызвана функция terminate(). По умолчанию функция terminate() вызывает функцию abort(), предназначенную для останова программы. Однако, используя функцию set_terminate(), можно указать свои обработчики таких ситуаций.

Пример

#include using namespace std; int main() { cout << "Начало\n"; try { // начало блока try cout << "Внутри блока try\n"; throw 100; // генерируем ошибку cout << "Этот оператор выполнен не будет"; } catch (int i) { // перехватываем ошибку cout << "Перехватываем исключение - "; cout << "значение равно: "; cout << i << "\n"; } cout << "Конец"; return 0; }

При выполнении этой программы будут выведены следующие сообщения.

Начало Внутри блока try Перехватываем исключение - значение равно: 100 Конец

Как видите, в программе присутствует блок try, содержащий три оператора, и оператор catch (int i), который обрабатывает исключения целого типа. Внутри блока try будут выполнены только два из трех операторов: первый (из двух) оператор cout и оператор throw. Как только будет сгенерировано исключение, управление сразу перейдет к выражению catch и блок try прекратит свою работу, т.е. оператор catch не вызывается: просто ему передается управление программой. (Для реализации этой передачи стек программы автоматически устанавливается должным образом.) Значит, оператор cout, следующий за оператором throw, никогда не будет выполнен.

Операторы throw и finally

Оператор throw

Исключение может быть сгенерировано вручную с помощью оператора throw . Ниже приведена общая форма такого генерирования:

throw exceptOb;

где в качестве exceptOb должен быть обозначен объект класса исключений, производного от класса Exception. Ниже приведен пример программы, в которой демонстрируется применение оператора throw для генерирования исключения OverflowException:

Using System; namespace ConsoleApplication1 { class Program { static void Main() { int i = int.Parse(Console.ReadLine()); byte j; try { if (i > 255) // Генерируем исключение throw new OverflowException(); else j = (byte)i; } catch (OverflowException) { Console.WriteLine("Возникло переполнение"); } Console.ReadLine(); } } }

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

Повторное генерирование исключений

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

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

Using System; namespace ConsoleApplication1 { class Program { static void Del(int x, int y) { try { int result = x / y; } catch(DivideByZeroException) { Console.WriteLine("Деление на ноль!"); throw; } } static void Main() { try { Del(5, 0); } catch (DivideByZeroException) { Console.WriteLine("Программная ошибка!"); } Console.ReadLine(); } } }

Как видите, исключение DivideByZeroException обрабатывается как во внутреннем блоке, так и во внешнем.

Использование блока finally

Иногда требуется определить кодовый блок, который будет выполняться после выхода из блока try/catch. В частности, исключительная ситуация может возникнуть в связи с ошибкой, приводящей к преждевременному возврату из текущего метода. Но в этом методе мог быть открыт файл, который нужно закрыть, или же установлено сетевое соединение, требующее разрывания. Подобные ситуации нередки в программировании, и поэтому для их разрешения в C# предусмотрен удобный способ: воспользоваться блоком finally .

Использование блока finally гарантирует, что некоторый набор операторов будет выполняться всегда, независимо от того, возникло исключение (любого типа) или нет.

Для того чтобы указать кодовый блок, который должен выполняться после блока try/catch, достаточно вставить блок finally в конце последовательности операторов try/catch. Ниже приведена общая форма совместного использования блоков try/catch и finally:

try { // Блок кода, предназначенный для обработки ошибок. } catch (ExcepTypel exOb) { // Обработчик исключения типа ExcepTypel } catch (ExcepType2 exOb) { // Обработчик исключения типа ЕхсерType2. } finally { // Код завершения обработки исключений. }

Блок finally будет выполняться всякий раз, когда происходит выход из блока try/catch, независимо от причин, которые к этому привели. Это означает, что если блок try завершается нормально или по причине исключения, то последним выполняется код, определяемый в блоке finally. Блок finally выполняется и в том случае, если любой код в блоке try или в связанных с ним блоках catch приводит к возврату из метода.

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

throw объектThrowable;

Объект-исключение может уже существовать или создаваться с помощью оператора new :

t hrow new IOException () ;

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

Ниже приведен пример, в котором сначала создается объект-исключение, затем оператор throw генерирует исключение, обрабатываемое в разделе catch ,
в котором генерируется другое исключение.

/* пример # 3: генерация исключений: ThrowGeneration . java */

package chapt08;

import java.io.File;

public class ThrowGeneration {

public static void connectFile(File file) {

if (file == null || !file.exists())

throw new IllegalArgumentException();/* генерация

исключения */

//

public static void main(String args) {

File f = new File("demo.txt");

// File f = null;

connectFile (f);

} catch (IllegalArgumentException e) {

System.err .print("обработка unchecked-"

+ " исключения вне метода: " + e);

Вызываемый метод connectFile () может (при отсутствии файла на диске или при аргументе null ) генерировать исключение, перехватываемое обработчиком. В результате этого объект непроверяемого исключения IllegalArgument Exception , как подкласса классаRuntime Exception , передается обработчику исключений в методе main() .

В случае генерации проверяемого исключения компилятор требует обра­ботки исключения в методе или отказа от нее с помощью инструкции throw s .

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



Рекомендуем почитать

Наверх