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

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" в объявлении метода.

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

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

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

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

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

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

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

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());
   }
}

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

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

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

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

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