Notas do estudo sobre Java: Mecanismo de exceção do Java

Notas do estudo sobre Java: Mecanismo de exceção do Java

Dois métodos de processamento:

• try-catch
• lança
  lança exceção gerada deve ser uma subclasse de throwable

declaração try-catch

try
{
    语句1；//如果语句1有异常，则语句2不会执行，直接到catch
    语句2；
    //放入可能异常的句子
}
catch(Exception e)   //catch (错误类型 + 对象)，                  
{                    //错误类型一般写Exception就可以了，因为Exception是其他错误类型的父类
    //处理或者提醒用户的句子
}
//可以捕捉多个异常
catch(异常类型1 e)    
{
    //...
}
catch(异常类型2 e)
{
    //...
}
...
finally
{
    //无论是否捕捉到，都一定会执行的代码
    //一般用于关闭文件，删除临时文件等资源的清理工作
}

No programa acima, apenas uma captura é executada ou nenhuma das capturas () {} é executada
. Não pode haver código entre captura e captura.

• Assuntos que precisam de atenção
  Primeiro, pegue a exceção da subclasse, depois a exceção da classe pai, caso contrário, compile o erro, porque a exceção da classe pai inclui todas as exceções da subclasse.

class A extends Exception {
}

class B extends A {
}

class C extends B {
}

class M {
    public void compare(int i, int j) throws A, B {
        if (i > j)
            throw new A();
        else
            throw new B();
    }
}

public class TestTryCatch {
    public static void main(String[] args) {
        M mm = new M();
        try {
            mm.compare(-4, 1);
        } catch (B bb) {
            System.out.println("左边不能小于右边");
        } catch (A aa) {
            System.out.println("左边不能大于右边");
        }

    }
}

Quando a subclasse substitui o método da classe base, o escopo da exceção lançada pelo
método da subclasse não pode ser maior que o escopo da exceção lançada pelo método da classe base Não é possível lançar exceções que não sejam métodos de classe base

//自定义异常A
class A extends Exception
{
}

//自定义异常B
class B extends Exception
{
}

//自定义异常C
class C extends Exception
{
}

class M
{
    void f() throws A, B
    {
    }
}

class N extends M
{
 //可以throws A或B,也可以throws A,B  也可以不throws，
 //但不可以throws C  即"子类覆盖了基类方法时，
 //子类方法抛出异常的范围不能大于基类方法抛出的异常范围"
    void f() throws A,B 
    {
    }
}

class Test
{
    public static void main(String[] args)
    {
        M m = new M();
        N n = new N();

        System.out.println("1111");
    }
}

• Resumo do manipulador anormal

  1. Quando ocorre um erro em um programa Java, o sistema detecta automaticamente o erro e gera imediatamente um objeto de exceção correspondente ao erro.
  2. Em seguida, forneça o objeto de exceção à JVM.
  3. A JVM encontrará primeiro o código correspondente para manipular a exceção.Se não for encontrado, a JVM fará algum processamento simples e o programa será encerrado à força.
  4. Os programadores podem escrever seu próprio código para capturar e manipular as exceções correspondentes.

• Suplemento:

try
{
    //...
}
catch(Exception e)
{
    e.printStackTrace();
}

printStackTrace

Imprima as informações de erro e o caminho do objeto de erro e na pilha (ou seja, imprima as informações de erro)