Лабораторная работа №2. Отладка программ и обработка ошибок в vba

Методы обработки ошибок

1. Не обрабатывать.

2. Коды возврата. Основная идея — в случае ошибки возвращать специальное значение, которое не может быть корректным. Например, если в методе есть операция деления, то придется проверять делитель на равенство нулю. Также проверим корректность аргументов a и b:

При вызове метода необходимо проверить возвращаемое значение:

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

3.Использовать флаг ошибки: при возникновении ошибки устанавливать флаг в соответствующее значение:

Минусы такого подхода аналогичны минусам использования кодов возврата.

4.Можно вызвать метод обработки ошибки и возвращать то, что вернет этот метод.

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

5.В случае ошибки просто закрыть программу.

Это приведет к потере данных, также невозможно понять, в каком месте возникла ошибка.

Ответ: Windows
следит за изменениями в состоянии
системы (нажатие клавиш, перемещение
мыши и нажатие ее кнопок, и т.д.) и
генерирует

специальные
структуры данных, которые содержат
следующую информацию:

1. Ссылка на окно,
которое находилось в фокусе, когда
произошло событие.

3. Дополнительная
информация для данного события.

Далее эти пакеты
сохраняются в очереди сообщений Windows,
а ядро опять

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

Дайте определение
исключительной ситуации

Ответ: Исключительная
ситуация (исключение) — это некоторая
ситуация времени выполнения программы,
которая требует специальной обработки.
К таким событиям относятся ошибки
времени выполнения программы, например,
деление на ноль или попытка чтения
информации из несуществующего файла.

Расскажите об
объектах-исключениях в Delphi

Ответ: При
возникновении исключительной ситуации
Delphi создает экзем-

пляр некоторого
класса, в зависимости от характера
произошедшей ошибки

и вызывает команду
Raise, передавая ей ссылку на этот объект.
Все такие классы являются наследниками
класса Exception, что позволяет им быть
«узнаваемыми» для Delphi.

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

Любая подпрограмма
может сама сгенерировать исключительную
ситуацию с помощью оператора Raise.

Отладка
программы является итеративным процессом
обнаружения и исправления ошибок и
обычно требует последовательного
выполнения четырех этапов:

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

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

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

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

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

Семантические
ошибки – это
ошибки, проявляющиеся на этапе
выполнения программы при ее попытке
вычислить недопустимые значения
параметров или выполнить недопустимые
действия. Причина возникновения ошибок
данного типа связана с нарушением
семантических правил написания программ
(примером являются ситуации
попытки
открыть несуществующий файл или выполнить
деление на нуль). Если программа
обнаруживает ошибку такого типа, то она
завершает свое выполнение
и
выводит
соответствующее сообщение в окне Build,
содержащее номер строки с ошибкой и ее
возможный характер. Список сообщений
можно просмотреть с помощью команды
меню View/Debug
Windows/Event
Log.
При выполнении программы из среды Delphi
автоматически выбирается соответствующий
исходный файл и в нем находится
местоположение ошибки. Если же программа
выполнялась вне среды и в ней появилась
ошибка данного типа, то необходимо
запустить
среду и найти вызвавший ошибку оператор.

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

Читать также:  ПРОГРАММЫ "HAND TO HELP" О СЕМЕЙНЫХ ПРОБЛЕМАХ ДЛЯ ДЕТЕЙ И РОДИТЕЛЕЙ

Ошибки первого
типа легко выявляются самим компилятором.
Обычно устранение синтаксических ошибок
не вызывает особых трудностей. Более
сложно выявить ошибки второго и особенно
третьего типа. Для обнаружения и
устранения ошибок второго и третьего
типа обычно применяют специальные
способы и средства отладки программ.
Выявлению ошибок второго типа часто
помогает использование контролирующих
режимов компиляции с проверкой допустимых
значений тех или иных параметров (границ
индексов элементов массивов, значений
переменных типа диапазона, ситуаций
переполнения, ошибок ввода-вывода).
Устанавливаются эти режимы с помощью
ключей
компилятора,
задаваемых либо в программе, либо в меню
Project/Options/Compiler
среды
Delphi, либо
в
меню
Options/Compiler Турбо-среды.

Соседние файлы в папке крутые билеты по инфе

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

Основные
сведения о средствах отладки и обработки
ошибок

Отладка программ
— это проверка и внесение исправлений
в программу при ее разработке.

В процессе отладки
программы возможны три вида ошибок:

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

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

К средствам
обработки ошибок относятся операторы
On Error, Resume.

Оператор On
Error осуществляет
передачу управления на подпрограмму
обработки ошибок. Возможны три варианта
синтаксиса оператора:

Оператор Resume
передает управление из обработчика
ошибок в программу, возможны следующие
варианты синтаксиса оператора:

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

Number
— номер возникшей ошибки;

Source
— имя проекта, в котором возникла ошибка;

Description
— строка с описанием ошибки;

HelpFile
— полное имя файла справки;

HelpContext
— идентификационный номер ошибки в файле
справке;

LastDLLError
— содержит код системной ошибки для
последнего вызова DLL.

Clear
— очищает значения всех свойств объекта
Err;

Raise
— генерирует ошибку во время выполнения
программы. Используется для проверки
работы обработчика ошибок, или создания
собственных ошибок при выполнении
программы.

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

В VBA имеется три
режима работы с программой:

  • режим конструктора
    (режим работы с текстом программы);
  • режим выполнения
    (текст программы не доступен для
    изменения работы, его можно только
    просматривать);
  • режим прерывания
    (приостановка работы программы, режим
    позволяет просматривать значения
    переменных, продолжать или прекращать
    работу программы, вносить изменения в
    текст программы).

Команды отладки
доступны из меню Отладка
или через панель Отладка.
VBA
имеет следующие средства отладки:

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

Public Sub pr_Otl1()

Dim b(10) As Integer

Dim s As Single

Dim p As Integer

Dim s1 As Single

Dim k As Integer

For i = 1 To 10

If b(i) Mod 2 = 0 Then s1 = s1
+ b(i): k = k + 1

s = s +
b(i): p = p* b(i)

s = s / p : MsgBox s

s1 = s1 / k : MsgBox s1

VBA выдает ошибку
выполнения № 6 — «переполнение»
(Overflow).

В окне с сообщением
об ошибке нажать кнопку Debug
(Отладка).
Цветом выделяется оператор, выполнение
которого привело к возникновению ошибки.

  • для просмотра
    значений всех локальных переменных
    выполнить команду ViewLocals
    Window
    (ВидОкно локальных переменных);
  • для просмотра
    значений нужных переменных и выражений
    использовать окно
    Watches
    (Контрольные значения).

Просмотреть в
контрольном окне значение переменных
p и b(i), а также выражения p*b(i). Для добавления
переменной (выражения) в контрольное
окно, следует выделить ее имя (выражение)
в операторе и выполнить команду Add
Watch
(ОтладкаДобавить контрольное значение).

Просмотр окна
Watches
позволяет
сделать вывод, что тип переменной p не
соответствует помещаемому значению.
Тип переменной р необходимо изменить
на Long (Длинное целое). Внести изменение
в текст процедуры. Закрыть окно Watches.

  • Продолжить отладку
    программы. Запустить программу на
    выполнение и ввести значения 1, 2, 3, 4, 5,
    6, 7, 8, 9, 0. VBA выдает ошибку выполнения
    №11 — «деление на 0» (Division
    by
    zero).
    Просмотреть значение переменных,
    участвующих в вычислениях в операторе,
    выполнение которого привело к
    возникновению ошибки.
  • Перейти из режима
    прерывания программы в режим конструктора.
    Для этого выполнить команду RunReset
    (ЗапускСброс) или
    нажать кнопку Сброс
    на панели
    Стандарт.
  • Продолжить отладку
    программы. Запустить ее на выполнение
    и ввести значения 1,3,5,7,9,11,13,15,17, 19. VBA
    выдает ошибку выполнения № 6 —
    «переполнение». Просмотреть
    значение переменных, участвующих в
    вычислениях в операторе, выполнение
    которого привело к возникновению
    ошибки.
  • Добавить в процедуру
    обработчик ошибок. Для этого отредактировать
    процедуру в соответствии с приведенным
    ниже текстом:

Dim p As Long

On Error
GoTo MyErrHandler

Vvod: For i = 1 To 10

s = s + b(i): p = p * b(i)

Select Case Err.Number

MsgBox «среди
элементов массива нет четных чисел,
повторите ввод»

Err.Clear: s1 = 0: p = 1

MsgBox «Один из
элементов массива равен нулю,» & _

» отношение
суммы к произведению элементов найти
нельзя»

Dim err_num As Integer

err_num = Err.Number

  • Выполнить отладку
    обработчика ошибок. Для этого выполнить
    программу несколько раз, вводя по
    очереди такие исходные данные, которые
    привели бы к возникновению всех
    обрабатываемых ошибок.
  • Осуществить
    пошаговое выполнение программы
    (трассировку) с помощью команды DebugStep
    Into
    (Отладка Шаг с заходом), анализируя
    изменение значений переменных процедуры
    на каждом шаге выполнения.
  • Осуществить
    пошаговое выполнение части программы.
    Для этого необходимо:
  • запустить процедуру
    на выполнение;
  • после прерывания
    работы процедуры просмотреть значение
    переменных s,s1,p,k;
  • продолжить
    выполнение процедуры в режиме трассировки;

Соседние файлы в папке ФИК-2ой курс_ЗАО

Читать также:  Какие процедуры выполняются при создании программы?

Исключения в Java7

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

Байт-код, сгенерированный компиляцией такого catch-блока будет короче, чем код нескольких catch-блоков.

В приведенном примере в качестве ресурса использутся объект класса BufferedReader, который будет закрыт вне зависимосити от того, как выполнится try-блок.

Можно объявлять несколько ресурсов, разделяя их точкой с запятой:

Во время закрытия ресурсов тоже может быть брошено исключение. В try-with-resources добавленна возможность хранения «подавленных» исключений, и брошенное try-блоком исключение имеет больший приоритет, чем исключения получившиеся во время закрытия. Получить последние можно вызовом метода getSuppressed() от исключения брошенного try-блоком.

Компилятор Java SE 7 тщательнее анализирует перебрасываемые исключения. Рассмотрим следующий пример:

В примере try-блок может бросить либо FirstException, либо SecondException. В версиях до Java SE 7 невозможно указать эти исключения в декларации метода, потому что catch-блок перебрасывает исключение ex, тип которого — Exception.

В Java SE 7 вы можете указать, что метод rethrowException бросает только FirstException и SecondException. Компилятор определит, что исключение Exception ex могло возникнуть только в try-блоке, в котором может быть брошено FirstException или SecondException. Даже если тип параметра catch — Exception, компилятор определит, что это экземпляр либо FirstException, либо SecondException:

Если FirstException и SecondException не являются наследниками Exception, то необходимо указать и Exception в объявлении метода.

Разработка исключений

Чтобы определить собственное проверяемое исключение, необходимо создать наследника класса java.lang.Exception. Желательно, чтобы у исключения был конструкор, которому можно передать сообщение:

Синтаксис try catch

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

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

Обработка исключений try-catch в Java

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

Примеры исключений

  • любая операция может бросить VirtualMachineError. Как правило это происходит в результате системных сбоев.
  • OutOfMemoryError. Приложение может бросить это исключение, если, например, не хватает места в куче, или не хватает памяти для того, чтобы создать стек нового потока.
  • IllegalArgumentException используется для того, чтобы избежать передачи некорректных значений аргументов. Например:

Блок catch

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

В Java возможна обработка ошибок с помощью исключений:

Проверять b на равенство нулю уже нет необходимости, так как при делении на ноль метод бросит непроверяемое исключение ArithmeticException.

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

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

Таким образом, механизм обработки исключений содержит следующие операции:

  • Создание объекта-исключения.
  • Заполнение stack trace’а этого исключения.
  • Stack unwinding (раскрутка стека) в поисках нужного обработчика.

Чтобы сгенерировать исключение используется ключевое слово throw. Как и любой объект в Java, исключения создаются с помощью new.

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

Возможна ситуация, когда одно исключение становится причиной другого. Для этого существует механизм exception chaining. Практически у каждого класса исключения есть конструктор, принимающий в качестве параметра Throwable – причину исключительной ситуации. Если же такого конструктора нет, то у Throwable есть метод initCause(Throwable), который можно вызвать один раз, и передать ему исключение-причину.

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

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

Сразу после блока проверки следуют обработчики исключений, которые объявляются ключевым словом catch.

Сatch-блоки обрабатывают исключения, указанные в качестве аргумента. Тип аргумента должен быть классом, унаследованного от Throwable, или самим Throwable. Блок catch выполняется, если тип брошенного исключения является наследником типа аргумента и если это исключение не было обработано предыдущими блоками.

Код из блока finally выполнится в любом случае: при нормальном выходе из try, после обработки исключения или при выходе по команде return.

NB: Если JVM выйдет во время выполнения кода из try или catch, то finally-блок может не выполниться. Также, например, если поток выполняющий try или catch код остановлен, то блок finally может не выполниться, даже если приложение продолжает работать.

Блок finally удобен для закрытия файлов и освобождения любых других ресурсов. Код в блоке finally должен быть максимально простым. Если внутри блока finally будет брошено какое-либо исключение или просто встретится оператор return, брошенное в блоке try исключение (если таковое было брошено) будет забыто.

После того, как было брошено первое исключение — new Exception(«a») — будет выполнен блок finally, в котором будет брошено исключение new IOException(«b»), именно оно будет поймано и обработано. Результатом его выполнения будет вывод в консоль b. Исходное исключение теряется.

Обработка исключений, вызвавших завершение потока

При использовании нескольких потоков бывают ситуации, когда поток завершается из-за исключения. Для того, чтобы определить с каким именно, начиная с версии Java 5 существует интерфейс Thread.UncaughtExceptionHandler. Его реализацию можно установить нужному потоку с помощью метода setUncaughtExceptionHandler. Можно также установить обработчик по умолчанию с помощью статического метода Thread.setDefaultUncaughtExceptionHandler.

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

Интерфейс Thread.UncaughtExceptionHandler имеет единственный метод uncaughtException(Thread t, Throwable e), в который передается экземпляр потока, завершившегося исключением, и экземпляр самого исключения. Когда поток завершается из-за непойманного исключения, JVM запрашивает у потока UncaughtExceptionHandler, используя метод Thread.getUncaughtExceptionHandler(), и вызвает метод обработчика – uncaughtException(Thread t, Throwable e). Все исключения, брошенные этим методом, игнорируются JVM.

Информация об исключениях

  • getMessage(). Этот метод возвращает строку, которая была первым параметром при создании исключения;
  • getCause() возвращает исключение, которое стало причиной текущего исключения;
  • printStackTrace() печатает stack trace, который содержит информацию, с помощью которой можно определить причину исключения и место, где оно было брошено.

Exception in thread «main» java.lang.IllegalStateException: A book has a null property
at com.example.myproject.Author.getBookIds(Author.java:38)
at com.example.myproject.Bootstrap.main(Bootstrap.java:14)
Caused by: java.lang.NullPointerException
at com.example.myproject.Book.getId(Book.java:22)
at com.example.myproject.Author.getBookIds(Author.java:35)

Все методы выводятся в обратном порядке вызовов. В примере исключение IllegalStateException было брошено в методе getBookIds, который был вызван в main. «Caused by» означает, что исключение NullPointerException является причиной IllegalStateException.

Блок try

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

За блоком try должны следовать блоки catch или блок finally или оба.

Синтаксис блока try

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

Классификация исключений

Класс Java Throwable описывает все, что может быть брошено как исключение. Наследеники Throwable — Exception и Error — основные типы исключений. Также RuntimeException, унаследованный от Exception, является существенным классом.

Лабораторная работа №2. Отладка программ и обработка ошибок в vba

Иерархия стандартных исключений

Наследники класса Exception (кроме наслеников RuntimeException) являются проверяемыми исключениями(checked exception). Как правило, это ошибки, возникшие по вине внешних обстоятельств или пользователя приложения – неправильно указали имя файла, например. Эти исключения должны обрабатываться в ходе работы программы, поэтому компилятор проверяет наличие обработчика или явного описания тех типов исключений, которые могут быть сгенерированы некоторым методом.

Все исключения, кроме классов Error и RuntimeException и их наследников, являются проверяемыми.

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

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

Гарантии безопасности

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

  • Отсутствие гарантий (no exceptional safety). Если было брошено исключение, то не гарантируется, что все ресурсы будут корректно закрыты и что объекты, методы которых бросили исключения, могут в дальнейшем использоваться. Пользователю придется пересоздавать все необходимые объекты и он не может быть уверен в том, что может переиспозовать те же самые ресурсы.
  • Отсутствие утечек (no-leak guarantee). Объект, даже если какой-нибудь его метод бросает исключение, освобождает все ресурсы или предоставляет способ сделать это.
  • Слабые гарантии (weak exceptional safety). Если объект бросил исключение, то он находится в корректном состоянии, и все инварианты сохранены. Рассмотрим пример:

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

Несколько блоков catch

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

  • Один блок try может иметь любое количество блоков catch.
  • Общий блок catch может обрабатывать все исключения. Будь то ArrayIndexOutOfBoundsException или ArithmeticException или NullPointerException или любой другой тип исключения.

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

  • Если в блоке try не возникает исключение, блоки catch полностью игнорируются.
  • Соответствующие блоки catch выполняются для конкретного типа исключения: catch(ArithmeticException e) является блоком catch, который может обрабатывать ArithmeticException catch(NullPointerException e) является блоком catch, который может обрабатывать NullPointerException
  • Вы также можете выбросить исключение. Это рассмотрено в других уроках: пользовательское исключение, ключевое слово throws, throw vs throws.

Пример нескольких блоков catch

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

Расскажите о методах обработки исключительных ситуаций

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

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

Finally block

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *