Почему "выкидывает исключение" необходимо при вызове функции?

Ответ 1

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

В Java вы можете выбросить все, что расширяет класс Throwable. Однако вам не нужно указывать предложение throws для всех классов. В частности, классы, которые являются Error или RuntimeException или любым из подклассов этих двух. В вашем случае Exception не является подклассом Error или RuntimeException. Таким образом, это проверенное исключение, которое должно быть указано в предложении throws, если вы не обработали это конкретное исключение. Вот почему вы нуждались в предложении throws.

Из Учебника по Java:

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

Теперь, как вы знаете, исключения делятся на две части: проверенные и непроверенные. Почему эти классификации?

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

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

• Исключения времени выполнения: Они обычно происходят из-за ошибки программиста. Например, если происходит ArithmeticException деления на ноль или ArrayIndexOutOfBoundsException, то это потому, что мы недостаточно осторожны в нашем кодировании. Обычно они происходят из-за некоторых ошибок в логике нашей программы. Таким образом, они должны быть очищены, прежде чем наша программа перейдет в рабочий режим. Они не проверяются в том смысле, что наша программа должна завершиться сбоем, когда она произойдет, чтобы мы, программисты, могли разрешить ее во время разработки и самого тестирования.

• Ошибки: Ошибки - это ситуации, из которых обычно программа не может восстановиться. Например, если происходит QaruError, наша программа не может многое сделать, например, увеличить размер стека вызова программных функций. Или, если OutOfMemoryError происходит, мы не можем сделать много, чтобы увеличить объем оперативной памяти, доступной для нашей программы. В таких случаях лучше выйти из программы. Вот почему они сделаны непроверенными.

Для получения подробной информации см.:

• Непроверенные исключения - противоречие
• Поймать или указать требование

Ответ 2

Java требует, чтобы вы обрабатывали или объявляли все исключения. Если вы не обрабатываете исключение, используя блок try/catch, он должен быть объявлен в сигнатуре метода.

Например:

class throwseg1 {
    void show() throws Exception {
        throw new Exception();
    }
}

Должен быть записан как:

class throwseg1 {
    void show() {
        try {
            throw new Exception();
        } catch(Exception e) {
            // code to handle the exception
        }
    }
}

Таким образом, вы можете избавиться от объявления "throws Exception" в объявлении метода.

Ответ 3

Exception - проверенный класс исключений. Поэтому любой код, вызывающий метод, объявляющий, что он throws Exception должен обрабатывать или объявлять его.

Ответ 4

Объявление throws Exception - это автоматизированный способ отслеживания методов, которые могут генерировать исключение по ожидаемым, но неизбежным причинам. Обычно объявление относится к типу или типам исключений, которые могут быть выбраны, например, throws IOException или throws IOException, MyException.

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

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

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

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

Самое приятное в этом решении - это то, что когда компилятор сообщает Error: Unhandled exception type java.io.IOException, он дает номер файла и строки метода, который был объявлен для исключения исключения. Затем вы можете просто просто передать доллар и объявить свой метод также "бросает IOException". Это можно сделать вплоть до основного метода, в результате чего программа остановится и сообщит об этом пользователю. Тем не менее, лучше поймать исключение и справиться с ним красиво, например, объяснить пользователю, что произошло, и как его исправить. Когда метод выполняет catch и обрабатывает исключение, ему больше не нужно объявлять исключение. Бак останавливается там, чтобы говорить.

Ответ 5

package javaexception;


public class JavaException {
   void show() throws Exception
    {
        throw new Exception("my.own.Exception");
    }

void show2() throws Exception  // Why throws is necessary here ?
{
    show();
}

void show3() throws Exception  // Why throws is necessary here ?
{
    show2();
}
public static void main(String[] args) {

   JavaException a = new JavaException();

   try{
   a.show3();
   }catch(Exception e){
       System.out.println(e.getMessage());
   }
}

Только небольшие изменения в вашей программе. Кажется, что многие неправильно понимают основную проблему, когда вы делаете исключение, которое вам нужно обрабатывать, не обязательно в одном месте (например, метод show1,2,3 в вашей программе), но вы должны сначала использовать метод вызова внутри "основного". одним словом, есть "бросок", должен быть "catch/try", даже если не тот же метод, где исключение происходит.

Ответ 6

void show() throws Exception
{
    throw new Exception("my.own.Exception");
}

Поскольку в методе show() проверяется исключение, которое не обрабатывается в этом методе, поэтому мы используем ключевое слово throw для распространения Исключения.

void show2() throws Exception //Why throws is necessary here ?
{
show();
}

Поскольку вы используете метод show() в методе show2(), и вы распространяли исключение, по крайней мере, вы должны работать здесь. Если вы не обрабатываете Исключение здесь, вы используете ключевое слово throw. Таким образом, это причина использования ключевого слова throw в сигнатуре метода.

Ответ 7

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

Ответ 8

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