Обробка помилок та виключень у Java

Розглянемо те, як можна обробляти помилки і що для цього використовується Java. Ця тема може здатися нудною, але насправді це дуже корисна навичка, яка стане вам у нагоді в майбутньому.

Що таке помилки та чому їх потрібно обробляти

Давай почнемо з того, що всі ми іноді припускаємося помилок. Так само і в програмах можуть виникати помилки через неправильно написаний код, невірні дані або інші непередбачені ситуації.

Якщо помилку не обробити, програма просто «впаде» з помилкою і не зможе продовжити роботу. А нам потрібно, щоб навіть при помилках програма працювала стабільно, не втрачала даних користувачів і коректно повідомляла про проблему. Ось для цього і використовується обробка помилок.

Основні типи помилок

Різні помилки можна класифікувати по-різному.

Давай розглянемо три основні типи:

1. Синтаксичні помилки – коли код написаний з порушенням syntax правил мови програмування. Наприклад, не закрито фігурну дужку або пропущено крапку з комою. Такі помилки програма зазвичай виявляє відразу під час компіляції коду.
2. Логічні помилки – коли логіка роботи програми неправильна. Наприклад, замість додавання робиться віднімання. Програма скомпілюється, але працюватиме неправильно.
3. Помилки часу – виникають під час роботи програми. Наприклад, поділ на нуль, спроба відкрити неіснуючий файл, переповнення пам'яті і т.д.

Для обробки різних типів помилок у Java використовуються винятки. Давай розберемося, як це працює.

Що таке винятки в Java

Виняток (exception) Java – це об'єкт, який містить інформацію про помилку. Коли у програмі виникає виняткова ситуація, створюється об'єкт-виключення та «викидається» (throw).

Усі винятки Java успадковані від базового класу Exception.

Є також підкласи для різних типів помилок:

• RuntimeException – для помилок часу виконання
• IOException – для помилок введення-виведення
• NullPointerException – для помилок із нульовим покажчиком
• І т.д.

Блок try-catch

У Java для обробки винятків використовується конструкція try-catch.

Ось простий приклад:

try < // код, який може викинути виняток > catch (Exception e) < // код для обробки виключення >

У блоці try пишеться код, що потенційно може викинути виняток. Якщо виняток стався, керування передається до блоку catch. Там ми можемо обробити помилку: вивести повідомлення, записати в балку тощо.

Після блоку catch програма продовжить виконання далі, як ні в чому не бувало. Таким чином, ми «перехопили» помилку і не дали програмі впасти.

Наприклад, спроба відкрити неіснуючий файл викине виняток FileNotFoundException.

Ми можемо обробити його так:

try < File file = new File("test.txt"); FileReader fr = новий FileReader(file); >catch (FileNotFoundException e) < System.out.println("Файл не знайдено: " + e); >// далі програма продовжить роботу

Якщо файл не знайдено, буде виведено повідомлення про помилку, а програма не впаде.

Блок finally

Після блоків try-catch можна додати ще блок:

try < // код > catch (Exception e) < // обробка помилки > finally < // цей код виконається у будь-якому випадку >

Блок finally виконується завжди, навіть якщо у блоці try не було винятків. Це зручно для закриття файлів, з'єднань з базами даних та інших прибирань після роботи коду.

Наприклад:

FileReader fr = null; try < fr = новий FileReader("file.txt"); // читаємо файл > catch (IOException e) < // обробка помилки > finally < if (fr! = null) < fr.close (); // Закриваємо потік читання файлу >>

Обробка кількох типів винятків

Ми можемо обробляти в блоці catch не тільки загальний виняток Exception, а й конкретні класи.

Наприклад:

try < // код > catch (FileNotFoundException e) < // файл не знайдено > catch (IOException e) < // помилка введення-виводу > catch (Exception e) < // інші помилки >

Спершу пишуться блоки для конкретних винятків, а наприкінці – загальний блок catch.Так ми можемо розрізняти різні типи помилок та обробляти їх по-різному.

Створення власних винятків

У Java можна створювати власні класи винятків, успадкувавши їх від Exception чи інших підкласів.

Наприклад:

public class MyException extends Exception < public MyException(String message) < super(message); >>

А потім уже викидати ці винятки в код через оператор throw:

Це дозволяє створювати власні типи винятків зручності обробки помилок.

Використання throws та throw

• Метод може оголошувати, які винятки він викидає через ключове слово throws:

void readFile(String file) throws IOException < // код, який може викинути IOException >

Тепер метод, що викликає, повинен буде обробити цей виняток.

throw new IOException("Помилка читання файлу");

Після цього виконання методу припиняється і виняток передається вище за стеком викликів.

Рекомендації

Прості поради:

• Не ігноруй виняток просто так. Краще хоч би вивести повідомлення про помилку.
• Не використовуй обробку винятків для керування логікою програми. І тому є оператори if/else.
• Намагайся писати зрозумілі повідомлення про помилки для інших розробників.
• Використовуйте finally для звільнення ресурсів.
• Не бійся створювати власні типи винятків, якщо це спростить код.

Java. Винятки (exceptions). Виняткова ситуація. Ключові слова try, catch, finally. Приклади

Винятки (exceptions). Виняткова ситуація. Ключові слова try, catch, finally. Приклади

Пошук на інших ресурсах:

1. Що таке виняткова ситуація?

Виняткова ситуація – це програмна помилка, що виникає під час виконання послідовності програмного коду. Програмна помилка може бути логічною помилкою програміста під час розробки програми. Наприклад, виняткова ситуація може виникати у випадках:

• спроби поділу на нуль
• спроби звернення до елемента масиву, номер індексу якого виходить за межі оголошеного;
• спроби взяти корінь із негативного числа;
• спроби відкрити файл на ім'я, якого немає на диску;
• інші випадки.

Правильне оброблення винятків є важливим елементом написання професійних програм на Java.

2. Поняття виключення у мові Java

Як правило, кожна виняткова ситуація може мати свій код помилки та обробку цього коду (висновок відповідних повідомлень, тощо) У мові програмування Java розроблено механізм обробки виняткових ситуацій.

У мові програмування Java, виняток - це спеціальний об'єкт, що описує виняткову ситуацію, яка виникла в деякій частині програмного коду. генерування виключення.Генерування винятку - процес створення об'єкта, який описує цей виняток.

3. Якими способами можуть генеруватися винятки?

У мові Java винятки можуть генеруватися одним із двох способів:

• автоматичноУ цьому випадку винятки генеруються виконавчою системою Java.
• вручнуУ цьому випадку винятки генеруються в програмному коді, який розробляється.

4. У яких випадках викликається стандартний обробник винятків Java?

Стандартний обробник виключень Java викликається у випадках, коли програма:

• не використовує блок try…catch для обробки та перехоплення виняткової ситуації взагалі;
• містить блок try ... catch, проте в цьому блоці даний тип виключення не перехоплюється.

Якщо програма містить власний код try…catch для обробки цієї виняткової ситуації, тоді стандартний обробник винятків не викликається.

5. Які ключові слова використовуються для обробки виключень Java?

Для обробки винятків у Java використовуються такі ключові слова:

• try;
• catch;
• throw;
• throws;
• finally.

6. Яке призначення конструкції try…catch…finally? Загальна форма

У мові Java можна вручну перехоплювати винятки (виключні ситуації) та відповідним чином обробляти їх. Важливо, щоб у разі виняткової ситуації програма не припинила своє виконання.

Для відстеження, генерування та обробки винятків у мові програмування Java використовується конструкція try…catch…finally, яка має наступну загальну форму

try
< // блок коду, в якому відстежуються та генеруються винятки
// . >
catch
(type_exception_1 objEx1) < // Обробник виключення типу type_exception_1
// . >
catch
(type_exception_2 objEx2) < // Обробник виключення типу type_exception_2
// . > . catch (type_exception_N objEx) < // Обробник виключення типу type_exception_N
// . >
finally
< // блок коду, який має бути обов'язково виконаний
// після завершення блоку try
// . >

У блоці try розміщуються оператори програми, які потрібно проконтролювати та, у разі виникнення виняткової ситуації, згенерувати виняток. Усередині блоку try можуть бути викликані різні методи, здатні згенерувати той чи інший виняток. Проте, обробник виключення буде лише один.

У блоці catch розміщується програмний код, який обробляє перехоплений виняток (обробник виключення). Код у блоці catch реалізує виконання відповідних дій, коли відбулася виняткова ситуація у блоці try . Блоків catch може бути декілька. Якщо генерується виняток, механізм обробки виключень шукає перший обробників винятків, аргумент якого відповідає поточному типу виключення.Після цього він входить до блоку catch , і, в результаті виняток вважається обробленим. Лише один відповідний блок catch обробляється.

У блоці finally вказується код, який має бути обов'язково виконаний після завершення блоку try . Блок операторів finally виконується незалежно від того, буде згенеровано виняток чи ні. Якщо виняток згенеровано, блок операторів finally виконується навіть за умови, що жоден оператор catch не збігається з цим винятком.

Оператори try та catch становлять єдине ціле. Оператор finally може бути відсутнім.

7. Приклад генерування виключення та його перехоплення стандартним обробником винятків Java

Якщо у програмі відсутній власний блок try…catch перехоплення виключення, буде викликано стандартного обробника виключення. У прикладі демонструється виклик стандартного оброблювача.

Оголошується клас DemoExceptions. З метою демонстрації у класі оголошується метод DivNumbers(). Метод повертає число типу double, яке є результатом поділу двох цілих значень змінних a і b . Ці змінні є вхідними параметрами методу.

Якщо b = 0, то при розподілі a на b може виникнути виняткова ситуація «розподіл на нуль» типу ArithmeticException. У програмі немає коду, який явно перехоплює та обробляє цю ситуацію. Тому викликається стандартний обробник Java.

Текст класу DemoExceptions наступний:

// клас реалізує метод,
// у якому може виникнути виняткова ситуація
class
DemoExceptions < // метод, у якому може виникнути поділ на 0

double
DivNumbers(int
a, int b) < // при розподілі на 0 буде викликаний стандартний обробник Java

double
res; res = a/b; 
return
res; > >

Якщо в іншому класі використовувати метод DivNumbers() так

public
class Train01 < 
public
static
void main(String[] args) < DemoExceptions d = new DemoExceptions(); // Створити екземпляр класу
double res; // Викликати метод DivNumbers() res = d.DivNumbers(2, 0);  // 2/0 => розподіл на нуль System.out.println("res color: #ff0000;">Exception in thread "main"  java.lang.ArithmeticException: / by zero
at DemoExceptions.DivNumbers(Train01.java:10)
at Train01.main(Train01.java:82)

У повідомленні вказується тип класу ArithmeticException. Це підклас похідний від класу RunTimeException. Цей підклас описує арифметичні помилки «розподіл на 0», «взяття кореня з негативного числа» тощо.

8. Приклад перехоплення та обробки виключення за допомогою оператора try…catch

У прикладі реалізований клас DemoExceptions, в якому оголошується метод з ім'ям DivNumbers2(). Метод DivNumbers2() ділить вхідний параметр a на вхідний параметр b . У методі DivNumbers2() продемонстровано перехоплення вилучення поділу на нуль за допомогою блоку try…catch.

Текст класу DemoExceptions наступний

// клас реалізує метод,
// у якому може виникнути виняткова ситуація
class
DemoExceptions <  // метод, у якому оброблено поділ на 0,
// блок try..catch

double
DivNumbers2(int
a,  int b) <  
double
res=0;  // змінна res обов'язково має бути ініціалізована

try
< res = a/b;  // якщо b = 0, то генерується виняток >

catch
(ArithmeticException e) < System.out.println("Поділ на 0."); >

return
res; > >

Тепер, використовуючи метод DivNumbers2() в іншому класі

public
class Train01 <  
public
static
void main(String[] args) < DemoExceptions d =  new DemoExceptions();  // Створити екземпляр класу
double res;  // Викликати метод DivNumbers2() res = d.DivNumbers2(2, 0);  // 2/0 => розподіл на нуль System.out.println("res color: #0000ff;">DivNumbers2() буде викликано власного обробника, який реалізовано в операторі  try…catch. У блок  try міститься програмний код, який потрібно перевірити

. res = a/b; .
Якщо виникає виняток (b = 0), то управління відразу передається з блоку try блок catch . У блоці catch відбувається обробка виключення із виведенням відповідного повідомлення
. catch (ArithmeticException e) < System.out.println("Поділ на 0."); > .

генерується виняток типу ArithmeticException;
відбувається перехід до обробки виключення (блок catch);
у блоці catch виводиться відповідне повідомлення;
після блоку catch виконання програми не зупиняється. В результаті змінна res набуває значення 0.

Можна змінити виведення власного повідомлення про виключення стандартного повідомлення. В цьому випадку потрібно змінити текст у блоці catch на наступний
. catch (ArithmeticException e) < System.out.println(e); //System.out.println("Поділ на 0."); > .
Після змін результат виконання програми буде такий
java.lang.ArithmeticException: /by zero res = 0.0
9. Приклад перехоплення та обробки виключення блоком try…catch…finally. Демонстрація роботи блоку операторів
У прикладі продовжено розвиток двох попередніх пунктів 7, 8. Приклад демонструє призначення блоку finally оператора try…catch…finally .
Оголошується клас DemoExceptions. У класі продемонстровано перехоплення виняткової ситуації розподілу на 0. Цей перехоплення реалізовано методом DivNumbers3() класу. Для перехоплення та обробки виняткової ситуації метод DivNumbers3() використовує оператор try…catch…finally .
Текст класу DemoExceptions наступний
// клас, який реалізує метод,
// у якому може виникнути виняткова ситуація
class DemoExceptions < // метод, у якому оброблено поділ на 0,
// блок try..catch..finally
double DivNumbers3(int
a, int
b) < 
double res; // не обов'язково ініціалізувати, оскільки є блок finally

try

< res = a/b; >
catch
(ArithmeticException e) < System.out.println("Поділ на 0."); >

finally < res = 0; // Викликається обов'язково >

return
res; > >
У методі DivNumbers3() оголошується змінна res , що є результатом поділу a на b . Оскільки оператор try…catch містить блок finally, то рядок
. finally
< res = 0; // Викликається обов'язково > .
буде викликатись завжди. І перед оператором
. return res; .
змінна res завжди буде ініціалізована. Тому компілятор Java не вимагає ініціалізації змінної на початку коду. Як відомо, щоб повернути значення змінної оператором return ця змінна повинна бути обов'язково ініціалізована. Отже, блок finally викликається завжди.
Використання методу DivNumbers3() в іншому класі може бути наступним
public
class Train01 < 
public
static
void main(String[] args) < DemoExceptions d = new DemoExceptions(); double res; res = d.DivNumbers3(2, 0); // 2/0 => розподіл на нуль System.out.println("res color: #333300;">⇑
10. Як реалізувати висновок опису винятку? приклад
Якщо потрібно вивести опис виключення e, то можна змінити висновок в обробнику catch в такий спосіб (див. пункт 8)
. catch (ArithmeticException e) < // Перехопити помилку поділу на 0 System.out.println("Виняток: " + e); >.
В результаті програма виводитиме наступний результат
Виняток: java.lang.ArithmeticException: / by zero
11. Приклад перехоплення кількох виняткових ситуацій (кілька операторів catch)
Трапляються випадки, коли в одному фрагменті коду може виникнути кілька винятків. Для обробки кількох виняткових ситуацій у блоці try…catch можна використовувати кілька операторів catch. Кожен із операторів catch використовується для перехоплення окремого типу виключення.
Реалізація класу DivArrays наступна
// кілька операторів catch
// клас, який ділить поелементно масиви
class DivArrays < 
double[] A1; 
double[] A2; // конструктор класу DivArrays(int
n1, double[] _A1, int n2, double[] _A2) < // Створити масиви A1 = new
double[n1]; for (int
i=0; inew
double[n2]; for (int
i=0; i // метод, який поділяє поелементно масив A1 на масив A2
// метод повертає масив типу double

double[] Division() < 
double[] A3; int n3; // встановити найбільший із розмірів

if
(A1.length > A2.length) n3 = A1.length; 
else n3 = A2.length; A3 = new
double[n3]; // цикл по i, у циклі обробляється виняткова ситуація

for
(int
i=0; i try
< // згенерувати виняток, якщо розподіл на 0
if (A2[i]==0.0) 
throw
new ArithmeticException(); A3[i] = A1[i]/A2[i]; > 
catch (ArithmeticException e) < // перехопити поділ на 0 A3[i] = 0; // просто встановити A3 значення 0 >
catch (ArrayIndexOutOfBoundsException e) < // Перехопити вихід індексу за межі масиву
// це випадок, коли довжини масивів відрізняються A3[i] = -1; > > 
return
A3; > >
Використання класу в іншому програмному коді
public
class Train03 < public
static
void main(String[] args) < double [] A1 = <2.5, 2.0, 1.5, 0.5>; double [] A2 = <1.0, 0.0, 2.0>; double [] A3; DivArrays dA = new DivArrays(4,A1,3,A2); A3 = dA.Division(); // вивести масив d for ( int i=0; iout .println( "A[" + i + "] color: #333300;">⇑ 
Пов'язані теми
Введення в обробку винятків
Винятки бувають і навмисними. Такі винятки розробник викликає (кидає, викидає) сам.
Виняток відрізняється від помилок. У документації Java сказано:
Error is superclass of all the exceptions from which ordinary programs no ordinally expected to recover.
Помилки (Error)
— це такі виняткові ситуації, в яких відновлювати роботу програми не передбачається.
Наприклад, якщо повернутися до попередньої теми, коли не встановлено базову умову виходу з рекурсії, переповнюється стек (stack overflow). У цьому випадку можна лише припинити роботу програми.
У випадку з винятком можна зробити так, що програма продовжить роботу і користувач: або нічого не побачить, або зрозуміє, що зробив щось не так.
Виняток: що з ним робити?
Коли виникає виняток, програмісти кажуть:
Це й не дивно. Адже всі винятки – спадкоємці класу. Throwable - кидається, або той, який можна покинути.
Знайомство почнемо з сімейства Exception, що так і перекладається як виняток.
Вбудований виняток
Деякі вбудовані винятки:

ArithmeticException: виникає при розподілі на нуль;
ArrayIndexOutOfBoundException: індекс поза межами масиву;
IlegallegalArgumentException: використання невірного аргументу під час виклику методу;
NumberFormatException: помилка перетворення рядка на число.

Розглянемо їх окремо на прикладах, створюючи методи та викликаючи їх (ми вже вміємо це робити).
Поділ на нуль (перехоплення немає)public class Program < // Ваш клас може називатися по-іншому public static void main(String args[]) < System.out.println("Divide without problem: " + divideTwoNum(42, 2)); ("Here the problem: " + divideTwoNum(42, 0)); b) < return a/b; // повертаємо результат поділу >> Висновок буде: Divide without problem: 21 Exception в thread "main" java.lang.ArithmeticException: / by zero

Висновки: Here the problem… і зовсім не було. Крім того, програма аварійно завершилася.
"Перехоплення" поділу на нульpublic class Program < // Ваш клас може називатися по-іншому public static void main(String args[]) < System.out.println("Divide without problem: " + divideTwoNum(42, 2)); ("Here the problem: " + divideTwoNum(42, 0)); b) < int result; try < result = a / b; // мінус сто-п'ятсот > return result;Тепер все працює як слід.
Що змінилося? Шматок коду, який може викликати виняток,обернули» в конструкцію try-catch (Спробувати, і, якщо що пішло не так, то «схопити»).
Як це працює?
Якщо у блоці try виникає виняток, зазначений у блоці catch, то виконання блоку try перерветься і програма перейде до блоку catch.
Тобто. виняток буде «схоплено» / «перехоплено».
У блоці catch («схопити») у дужках обов'язково потрібно вказати, що саме перехоплюється й ідентифікатор:
а в ідентифікаторі буде відображено повідомлення, яке можна також вивести на екран (що було зроблено).
Тепер попрацюємо з масивом:
"Перехоплення" некоректного індексуpublic class Program < // Ваш клас може називатися інакше static int array [] = ; // Статичне поле класу Programm public static void main(String args[]) < System.out.println("Array index without problem: " + arrayIndex(2)); // виведе 3 System.out.println("Here the problem with index: " + arrayIndex(5)); // поза діапазоном >static int arrayIndex(int ​​index) < // повертає значення поля за індексом int result; try <result = array[index]; // пробуємо отримати значення за індексом catch (ArrayIndexOutOfBoundsException e) < System.out.println("Index is not correct: " + e); result = -100500; // ті самі сто-п'ятсот зі знаком мінус >return result; > > Некоректний індекс "перехоплено".
Приклад невдалої спроби перетворення:
Помилка перетворенняpublic class Program < // Ваш клас може називатися по-іншому public static void main(String args[]) < System.out.println("Conversion without problem: " + stringToInt("22")); // виведе 3 System.out.println("Here the problem with conversion: " + stringToInt("two")); // не перетворюється static int stringToInt (String str) < int result; try <result = Integer.parseInt(str); // рядок у число (спроба) > catch (NumberFormatException e) < System.out.println("Conversion is impossible: " + e); result = -100500; // ті самі сто-п'ятсот зі знаком мінус >return result; > >Проблема "перехоплена".
Обробка кількох винятків:
Помилка перетворення та індексуimport java.util.Arrays; public class Program < // Ваш клас може називатися інакше public static void main(String args[]) < int[] numbers = new int[3]; // масив із трьох чисел try < numbers[0] = 5; numbers[1] = 10; numbers[2] = Integer.parseInt("one"); // Не перетворюється numbers[4] = 45; // такого індексу немає catch (ArrayIndexOutOfBoundsException e) < System.out.println("Out of range:" + e); >catch (NumberFormatException e) < System.out.println("Incorrect conversion: " + e); >System.out.println("Array: " + Arrays.toString(numbers)); > > Проблема "перехоплена".
У попередньому прикладі обробиться (перехопиться) або один виняток, або інший. Про це ми подбали заздалегідь. Якщо ж матимуть місце два винятки відразу, то обробиться тільки перше, обробка другого вже не буде видно, але програма продовжить роботу.
Після завершення виконання блоку catch програма продовжує свою роботу, виконуючи решту інструкцій, що йдуть за catch. Конструкція try..catch може мати блок finally.
Однак цей блок необов'язковий і його можна при обробці виключень опускати.
Блок finally виконується у будь-якому випадку, чи виникали винятки в блоці try, чи ні:
Використання блоку "finally"import java.util.Arrays; public class Program < // Ваш клас може називатися інакше public static void main(String args[]) < int[] numbers = new int[2]; // Індекси тільки 0 і 1 try <numbers[0] = 5; numbers[1] = 10; numbers[2] = 45; // немає такого індексу System.out.println(numbers[4]); >catch (ArrayIndexOutOfBoundsException e) < System.out.println("Problems with array index: " + e); >finally < System.out.print("Finally block's printing anyway: "); System.out.println("Array: " + Arrays.toString(numbers)); >> >
Розробник може передбачити виникнення винятків навіть якщо не знає, які саме з них відбудеться:
Отримання інформації про виключенняpublic class Program < // Ваш клас може називатися інакше public static void main(String args[]) < int a = 10, b = 0; // якщо b не дорівнює нулю, то виняток не буде try < // але ми не обробляємо ArithmeticException System.out.println("a divide b = " + (a / b)); >catch (Exception e) < // просто виняток, який заздалегідь не знаємо System.out.println("Exception is:" + e); // тепер знаємо яке саме >>>Інформація про виключення отримана
Вже згадувалося, що винятки бувають і навмисними. Такі винятки розробник сам викликає (кидає, викидає) примусово.
Чому «кидає»? Тому що використовується оператор throw.
Тобто за допомогою цього оператора ми можемо створити виняток і викликати його в процесі виконання.
Наприклад, у нашій програмі відбувається введення віку, і ми хочемо, щоб у разі, якщо вік був запроваджений негативним, то виникало виняток.
Тут можливо два способи:

"Кинути" просто виняток (Exception);
«Кинути» будь-який вбудований виняток (наприклад, IlegallegalArgumentException).

Спосіб 1:
"Кидаємо" виняток (перший прийом)public class Program < public static void main(String[] args) < int age; //заздалегідь ініціалізуємо неправильно System.out.print("Enter Your age here:"); try < Scanner in = new Scanner(System.in); age = in.nextInt(); if (age System.out.println("Your age is: " + age); > catch (Exception e) < System.out.println("Problem is: " + e.getMessage()); >> >Надіслане повідомлення було прочитано
Спосіб 2:
"Кидаємо" виняток (другий прийом)import java.util.Scanner; import java.util.InputMismatchException; public class Program < public static void main(String[] args) < int age; System.out.print("Enter Your age here: "); try < Scanner in = new Scanner(System.in); age = in.nextInt(); if (age System.out.println("Your age is: " + age); > catch (IllegalArgumentException e) < System.out.println("Problem is: " + e.getMessage()); >catch (InputMismatchException e ) < System.out.println("You have to input positive digit value!");Відправлене повідомлення також було прочитано
Підсумовуючи, хочеться відзначити:

Програмний код пишеться з урахуванням того, що в будь-якому його місці можливий виняток. Отже, необхідно вміти ефективно використати відповідні прийоми обробки виняткових ситуацій.
Обробка винятків, таким чином, дозволяє запобігти аварійному завершенню програми та гарантує її подальшу коректну роботу в рамках основного алгоритму;
Конструкція обробки винятків використовує ключові слова: try / catch / finally;
Є можливість «провокувати» певні ситуації для управління програмою шляхом «кидання» (throw) винятків. Наприклад, для перевірки коректного введення значень користувачем.