Интеграция XML в Java [дубликат]

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 в сигнатуре метода.

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

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

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

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

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

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

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

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», даже если не тот же метод, где исключение происходит.

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