Исключения: Основы

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

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

Иерархия классов исключений в Java начинается с класса Throwable, который делится на два подкласса: Error и Exception.

Error: Используется для обозначения серьёзных проблем, которые не могут быть обработаны приложением (например, ошибки виртуальной машины Java).
Exception: Используется для обозначения условий, которые приложение может попытаться обработать.

Иерархия классов исключений:

- Throwable
  - Error
  - Exception
    - RuntimeException

Checked и Unchecked исключения

Checked исключения: Проверяемые исключения (checked exceptions) являются подтипами класса Exception, за исключением подтипов RuntimeException. Эти исключения проверяются во время компиляции. Пример: IOException.
Unchecked исключения: Непроверяемые исключения (unchecked exceptions) являются подтипами класса RuntimeException. Эти исключения не проверяются во время компиляции. Пример: NullPointerException.

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

Checked исключение: FileNotFoundException, которое возникает, если файл не найден.
Unchecked исключение: ArrayIndexOutOfBoundsException, которое возникает при попытке доступа к несуществующему элементу массива.

Создание собственного исключения

Вы можете создать свои собственные исключения, расширяя класс Exception или RuntimeException.

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

Пример использования пользовательского исключения:

public class Main {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomException {
        if (age < 18) {
            throw new CustomException("Age must be at least 18.");
        }
    }
}

Основные методы класса Throwable:

getMessage(): Возвращает описание исключения.
printStackTrace(): Выводит трассировку стека исключения.
getStackTrace(): Возвращает массив элементов стека, представляющий трассировку стека исключения.


Пример использования методов класса Throwable:

public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Exception: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public static int divide(int a, int b) {
        return a / b; // Бросает ArithmeticException при делении на ноль
    }
}

#Java #Training #Exception

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

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

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

Синтаксис try-catch:

try {
    // Код, который может вызвать исключение
} catch (ExceptionType e) {
    // Код для обработки исключения
}

Пример использования try-catch:

public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // Бросает ArithmeticException при делении на ноль
    }
}

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

Синтаксис try-catch-finally:

try {
    // Код, который может вызвать исключение
} catch (ExceptionType e) {
    // Код для обработки исключения
} finally {
    // Код, который будет выполнен в любом случае
}

Пример использования try-catch-finally:

public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        } finally {
            System.out.println("Execution completed.");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // Бросает ArithmeticException при делении на ноль
    }
}

Обработка нескольких исключений
Можно обработать несколько типов исключений, используя несколько блоков catch.

Пример обработки нескольких исключений:

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds!");
        } catch (Exception e) {
            System.out.println("An error occurred!");
        }
    }
}

Множественные исключения в одном catch
С Java 7 можно обрабатывать несколько типов исключений в одном блоке catch, используя оператор |.

Пример использования одного catch для нескольких исключений:

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}

#Java #Training #Exception #TryCatch

Создание собственных исключений

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

Создание пользовательского исключения

Для создания пользовательского исключения необходимо создать класс, который наследует от Exception (для checked исключений) или RuntimeException (для unchecked исключений).

public class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }
}

Пример создания unchecked исключения:

public class CustomUncheckedException extends RuntimeException {
    public CustomUncheckedException(String message) {
        super(message);
    }
}

Пример использования пользовательского исключения:

public class Main {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomCheckedException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomCheckedException {
        if (age < 18) {
            throw new CustomCheckedException("Age must be at least 18.");
        }
    }
}

Конструкторы пользовательских исключений

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

public class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }

    public CustomCheckedException(String message, Throwable cause) {
        super(message, cause);
    }

    public CustomCheckedException(Throwable cause) {
        super(cause);
    }
}

Исключения с собственными методами

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

public class InvalidUserInputException extends Exception {
    private int errorCode;

    public InvalidUserInputException(String message, int errorCode) {
        super(message);
        this.errorCode = errorCode;
    }

    public int getErrorCode() {
        return errorCode;
    }
}

Использование исключения с собственными методами:

public class Main {
    public static void main(String[] args) {
        try {
            processInput(-1);
        } catch (InvalidUserInputException e) {
            System.out.println("Error: " + e.getMessage() + " (Error code: " + e.getErrorCode() + ")");
        }
    }

    public static void processInput(int value) throws InvalidUserInputException {
        if (value < 0) {
            throw new InvalidUserInputException("Input value must be non-negative", 1001);
        }
    }
}

#Java #Training #Exception

Вложенные и множественные catch блоки

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

Множественные catch блоки

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

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds!");
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic exception occurred!");
        } catch (Exception e) {
            System.out.println("An unknown error occurred!");
        }
    }
}

Вложенные блоки try-catch

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

public class Main {
    public static void main(String[] args) {
        try {
            try {
                int result = divide(10, 0);
            } catch (ArithmeticException e) {
                System.out.println("Inner catch: Cannot divide by zero!");
            }

            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Outer catch: Array index is out of bounds!");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // Бросает ArithmeticException при делении на ноль
    }
}

Множественные исключения в одном catch блоке

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

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}

Обработка исключений с полиморфизмом

Можно использовать полиморфизм для обработки исключений. Поскольку все исключения являются подтипами Exception, можно использовать один catch блок для обработки всех исключений, если не требуется специфическая обработка для каждого типа исключения.

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }
}

#Java #Training #Exception