So verwenden Sie die Java-Schlüsselwörter throw, throws und Throwable

throw, was „werfen, werfen, werfen“ bedeutet. Throw, Throws und Throwable werden alle für die Ausnahmebehandlung verwendet.

1. Throwable

Throwable ist die übergeordnete Klasse der Ausnahmebehandlungszweige in Java. Die Implementierung aller anderen Ausnahmebehandlungen hängt von Throwable ab.

# 🎜🎜 #Öffnen Sie die offizielle Java-Dokumentation (Java8-Version) und suchen Sie nach Throwable. Seine direkten Unterklassen sind Error und Exception.

Das Merkmal von Fehler und Ausnahme ist, dass das Fehlerausnahmeprogramm damit nicht umgehen kann und nur manuelle Eingriffe zum Ändern des Codes, z Stapelüberlauf, Heap-Überlauf usw. usw.; Ausnahmen können im Voraus erkannt und effektiv behandelt werden.

1.1 Erweiterungsfehler

Zu den häufigsten Fehlern gehören Stapelüberlauf, Heap-Überlauf usw.

Zum Beispiel StackOverflowError

public class ErrorTest {
    public static void main(String[] args) {
        main(args);
    }
}

Unendliche Rekursion, beim Ausführen dieses Programms wird eine Stapelüberlaufausnahme gemeldet.

Ein weiteres Beispiel ist die Heap-Ausnahme, OutOfMemoryError

public class ErrorTest {
    public static void main(String[] args) {
        Integer[] testArray = new Integer[1024*1024*1024];
    }
}

1 .2 Erweiterung – Exception

Es gibt viele Ausnahmen, die uns in Exception bekannt sind, wie z. B. NullPointerException (Nullzeiger-Ausnahme), ArrayIndexOutOfBoundsException (Array-Index außerhalb der Grenzen), NumberFormatException (Ausnahme bei der Zahlenformatierung) usw.

public class ExceptionTest {
    public static void main(String[] args) {
        int[] testArray = null;
        System.out.println(testArray[0]);  //空指针异常
    }
}

public class ExceptionTest {
    public static void main(String[] args) {
        int[] testArray = new int[3];
        System.out.println(testArray[3]);   //数组下标越界
    }
}

public class ExceptionTest {
    public static void main(String[] args) {
        String num = "abc";
        System.out.println(Integer.parseInt(num));    //数字格式化异常
    }
}

2. throws

throws wird bei der Methodendeklaration angewendet, um die Arten von Ausnahmen anzugeben, die auftreten können, wenn diese Methode ausgeführt wird. Sobald beim Ausführen der Methode eine Ausnahme auftritt, wird im Ausnahmecode ein Objekt der Ausnahmeklasse generiert. Wenn dieses Objekt nach Throws den Ausnahmetyp erfüllt, wird es ausgelöst. Hier gibt es zwei Prozesse:

1: Erzeugen Sie ein Ausnahmeobjekt.

2 🎜#

throws und try-catch-finally werden als zwei Arten der Ausnahmebehandlung bezeichnet.

try-catch-finally behandelt die Ausnahme aktiv, wenn eine Ausnahme auftritt, sodass das Programm weiterhin ausgeführt werden kann, während throws die Ausnahme abfängt und das Ausnahmeobjekt nach oben wirft, ohne die Ausnahme tatsächlich zu behandeln.

Das sogenannte Auswerfen eines Ausnahmeobjekts nach oben besteht darin, das Ausnahmeobjekt zur Verarbeitung an den Aufrufer zu übergeben. Beispielsweise ruft Methode A Methode B auf, B löst eine Ausnahme durch Würfe aus und A kann sich dafür entscheiden verwenden try-catch-finally Nach der Behandlung der Ausnahme können Sie das Ausnahmeobjekt auch weiterhin durch Würfe nach oben werfen, bis die Ausnahme tatsächlich behandelt wird. Wenn es keine Möglichkeit gibt, Ausnahmen zu behandeln, wird das Ausnahmeobjekt schließlich an die JVM geworfen, was dazu führt, dass das Programm nicht mehr ausgeführt wird.

@Test
public void throwsTest(){   //调用者解决抛出的异常
    try{
        formatChange("abc");
    }
    catch (NumberFormatException e){
        System.out.println("转换格式错误！");
    }
    catch (Exception e){
        System.out.println("出现错误");
    }
}
private int formatChange(String str) throws NumberFormatException{    //出现异常向上抛出
    return Integer.parseInt(str);
}

2.1 Erweiterung

——Wie wählt man Try-Catch-finally oder Würfe?

Wenn es in einer Methode eine Ausnahme gibt, die behandelt werden muss, können Sie in den meisten Fällen entweder try-catch-finally wählen, um die Ausnahme direkt zu behandeln, oder Sie können throws auswählen, um die Ausnahme auszulösen nach oben und übergeben Sie es an den Anrufer (wenn die Ausnahme am Ende ausgelöst wird, muss es eine Partei geben, die die Ausnahme tatsächlich behandelt. Wie geht man damit um? Verwenden wir try-catch-finally). In den folgenden beiden Situationen müssen Sie jedoch bestimmte Regeln befolgen (bitte weisen Sie darauf hin, ob es Ergänzungen gibt).

Wenn die überschriebene Methode in der übergeordneten Klasse keine Würfe zum Auslösen einer Ausnahme verwendet, kann die von der Unterklasse überschriebene Methode keine Würfe zum Auslösen einer Ausnahme verwenden, was bedeutet Dies Die Situation muss mit try-catch-finally behandelt werden.
In Methode A werden mehrere andere Methoden nacheinander aufgerufen und viele von ihnen haben Ausnahmen, die behandelt werden müssen Es wird empfohlen, dass mehrere aufgerufene Methoden Throws verwenden, um nach oben gerichtete Ausnahmen auszulösen. Verwenden Sie in Methode A try-catch-finally, um diese Ausnahmen einheitlich zu behandeln.
In Bezug auf den ersten Punkt handelt es sich um eine Bedingung, dass die von der überschriebenen Methode in der Unterklasse mithilfe von Würfen ausgelöste Ausnahme nicht größer sein darf als die überschriebene Methode in der übergeordneten Klasse Der Bereich, in dem Ausnahmen ausgelöst werden. Wenn beispielsweise Methode B in der übergeordneten Klasse eine NullPointerException auslöst, kann die überschriebene Methode B in der Unterklasse keine Ausnahmen auslösen, die einen größeren Gültigkeitsbereich als NullPointerException haben, wenn die überschriebene Methode in der übergeordneten Klasse keine Ausnahme auslöst , kann die Unterklasse keine Ausnahme auslösen.

Warum? Zeigen Sie einen Codeabschnitt.

//假设父类中的方法B抛出NullPointerException异常,子类中的方法B可以抛出Exception
private void test(ParentClassTest parent){
    try{
        parent.B();
    }
    catch(NullPointerException e){
        System.out.println("出现了空指针异常");
    }
}

Angenommen in diesem Beispiel, dass Methode B in der übergeordneten Klasse eine NullPointerException auslöst, kann die überschriebene Methode B in der Unterklasse eine Ausnahme auslösen. Wenn die an die Testmethode übergebenen Parameter dann instanziierte Objekte der übergeordneten Klasse sind, gibt es kein Problem beim Aufrufen der Testmethode. Wenn der übergebene Parameter ein instanziiertes Objekt der Unterklasse ist und dann die von der Unterklasse neu geschriebene Methode B aufgerufen wird, wird möglicherweise eine Ausnahme ausgelöst, und die Try-Catch-Struktur kann diese Ausnahme offensichtlich nicht unterdrücken .

针对第二条，假设方法A中调用了方法C、D、E，这三个方法都有可能产生异常，且存在递进关系，也就是D、E执行需要C执行完成、E执行依赖C、D执行完成。那么就推荐在C、D、E中向上抛出异常，在方法A中集中处理。为什么？如果C、D、E都是向上抛出异常，而A使用try-catch-finally去处理这个异常，如果某个方法真的出现异常，则不再继续执行。而如果C、D、E都使用try-catch-finally直接解决掉异常，那么即使产生了异常，方法A也不会接收到异常的产生，那么还会接着往下执行，但是C出现了异常，再执行D、E没有任何意义。

3. throw

如果在程序编写时有手动抛出异常的需求，则可以使用throw

throw使用在方法体内。与try-catch-finally和throws都不同，异常处理的两个阶段：1.遇到异常，生成异常对象；2.捕获到异常，进行抛出或处理。try-catch-finally和throws都处在第二个阶段，都是捕获到异常后的相关处理，一般使用系统根据异常类型自动生成的异常对象进行处理。而throw应用在第一阶段，手动地产生一个异常对象。

举一个例子，判断一个数值是否为非负数，如果为负数，则抛出异常。

class ThrowTest{
    private int Number;
    public void judge(int num){
        if(num>=0){
            this.Number = num;
        }
        else{
            throw new RuntimeException("传入参数为负数");
        }
    }
}

@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    throwTest.judge(-100);
}

成功抛出异常。

使用try-catch捕获一下异常。

@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    try{
        throwTest.judge(-100);
    }
    catch (RuntimeException e){
        System.out.println(e.getMessage());
    }
}

如果把throw抛出的异常改为Exception，则直接报错，也就是不能编译。Exception包含两种异常：编译时异常和运行时异常，前者在编译前就要检查是否有可能产生编译时异常；后者是在编译后运行时才会判断的异常。而throw new Exception包含了编译时异常，需要显式处理掉这个异常，怎么处理？try-catch-finally或者throws

class ThrowTest{
    private int Number;
    public void judge(int num) throws Exception{
        if(num>=0){
            this.Number = num;
        }
        else{
            throw new Exception("传入参数为负数");
        }
    }
}

调用方也要随着进行更改。

@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    try{
        throwTest.judge(-100);
    }
    catch (RuntimeException e){
        System.out.println(e.getMessage());
    }
    catch (Exception e){
        System.out.println(e.getMessage());
    }
}

3.1 扩展

——自定义异常类

throw还可以抛出自定义异常类。

自定义异常类的声明需要继承于现有的异常体系。

class MyException extends RuntimeException{
    static final long serialVersionUID = -703489719076939L;   //可以认为是一种标识
    public MyException(){}
    public MyException(String message){
        super(message);
    }
}

此时我们可以抛出自定义的异常

class ThrowTest{
    private int Number;
    public void judge(int num) throws MyException{
        if(num>=0){
            this.Number = num;
        }
        else{
            throw new MyException("不能输入负数");
        }
    }
}

调用者修改

@Test
public void test2(){
    ThrowTest throwTest = new ThrowTest();
    try{
        throwTest.judge(-100);
    }
    catch (MyException e){
        System.out.println(e.getMessage());
    }
}

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Java-Schlüsselwörter throw, throws und Throwable. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!