Wie man Java-Ausnahmen abfängt und behandelt

Methoden zum Erfassen und Behandeln von Java-Ausnahmen: 1. Schlüsselwort throws, das System wirft die erfassten Ausnahmeinformationen automatisch an die übergeordnete aufrufende Methode. 2. Die Funktion von throw besteht darin, das instanziierte Objekt der Ausnahmeklasse manuell auszulösen Es handelt sich um eine Unterklasse von Exception, und es liegt am Benutzer, zu entscheiden, ob er damit umgeht.

【Verwandte Lernempfehlungen: Java-Grundlagen-Tutorial】

Java-Ausnahmeerfassungs- und -verarbeitungsmethoden:

1 Die Verwendung der Ausnahmebehandlung

Da der finale Block weggelassen werden kann, können Ausnahmen auftreten Die Verarbeitungsformate können in drei Kategorien unterteilt werden: try{ }——catch{ }, try{ }——catch{ }——finally{ }, try{ }——finally{ }.

 1 public class DealException
 2 {
 3     public static void main(String args[])
 4     {    
 5         try
 6         //要检查的程序语句
 7         {
 8             int a[] = new int[5];
 9             a[10] = 7;//出现异常
10         }
11         catch(ArrayIndexOutOfBoundsException ex)
12         //异常发生时的处理语句
13         {
14             System.out.println("超出数组范围！");
15         }
16         finally
17         //这个代码块一定会被执行
18         {
19             System.out.println("*****");
20         }
21         System.out.println("异常处理结束！");
22     }
23 }

Es ​​ist ersichtlich, dass während des Ausnahmeabfangprozesses zwei Beurteilungen getroffen werden müssen. Die erste besteht darin, ob im Try-Programmblock eine Ausnahme generiert wird, und die zweite darin, ob die generierte Ausnahme mit der Ausnahme von identisch ist in den Catch()-Klammern gefangen werden.

Was sollten Sie also tun, wenn die auftretende Ausnahme sich von der Ausnahme unterscheidet, die Sie in Catch() abfangen möchten? Tatsächlich können wir einer try-Anweisung mehrere Catch-Anweisungen zur Ausnahmebehandlung folgen lassen, um viele verschiedene Arten von Ausnahmen zu behandeln.

 1 public class DealException
 2 {
 3     public static void main(String args[])
 4     {    
 5         try
 6         //要检查的程序语句
 7         {
 8             int a[] = new int[5];
 9             a[0] = 3;
10             a[1] = 1;
11             //a[1] = 0;//除数为0异常
12             //a[10] = 7;//数组下标越界异常
13             int result = a[0]/a[1];
14             System.out.println(result);
15         }
16         catch(ArrayIndexOutOfBoundsException ex)
17         //异常发生时的处理语句
18         {
19             System.out.println("数组越界异常");
20             ex.printStackTrace();//显示异常的堆栈跟踪信息
21         }
22         catch(ArithmeticException ex)
23         {
24             System.out.println("算术运算异常");
25             ex.printStackTrace();
26         }
27         finally
28         //这个代码块一定会被执行
29         {
30             System.out.println("finally语句不论是否有异常都会被执行。");
31         }
32         System.out.println("异常处理结束！");
33     }
34 }

Im obigen Beispiel ist ex.printStackTrace(); die Verwendung des Ausnahmeklassenobjekts ex, das detaillierte Ausnahme-Stack-Trace-Informationen ausgibt, einschließlich des Ausnahmetyps, des Pakets, der Klasse und der Methode, in der die Ausnahme aufgetreten ist und wo die Ausnahme aufgetreten ist. Zeilennummer.

2. Das Schlüsselwort throws

Die durch throws deklarierte Methode bedeutet, dass die Methode keine Ausnahmen behandelt, das System jedoch die erfassten Ausnahmeinformationen automatisch an die übergeordnete aufrufende Methode weiterleitet.

 1 public class throwsDemo
 2 {
 3     public static void main(String[] args) 
 4     {
 5         int[] a = new int[5];
 6         try
 7         {
 8             setZero(a,10);
 9         }
10         catch(ArrayIndexOutOfBoundsException ex)
11         {
12             System.out.println("数组越界错误！");
13             System.out.println("异常："+ex);
14         }
15         System.out.println("main()方法结束。");
16     }
17     private static void setZero(int[] a,int index) throws ArrayIndexOutOfBoundsException
18     {
19         a[index] = 0;
20     }
21 }

Das Schlüsselwort throws löst eine Ausnahme aus. „ArrayIndexOutOfBoundsException“ gibt den möglichen Ausnahmetyp in der Methode setZero() an. Sobald eine Ausnahme in der Methode auftritt, wird sie von der Methode setZero() nicht selbst behandelt, sondern an sie weitergeleitet überlegene Caller-Main()-Methode.

3. Das Schlüsselwort throw

throw wird verwendet, um ein instanziiertes Objekt der Ausnahmeklasse manuell auszulösen.

 1 public class throwDemo
 2 {
 3     public static void main(String[] args) 
 4     {
 5         try
 6         {
 7             //抛出异常的实例化对象
 8             throw new ArrayIndexOutOfBoundsException("\n个性化异常信息：\n数组下标越界");
 9         }
10         catch(ArrayIndexOutOfBoundsException ex)
11         {
12             System.out.println(ex);
13         }
14     }
15 }

Wir können feststellen, dass throw nach Problemen zu suchen scheint, was Laufzeitausnahmen verursacht und die Eingabeaufforderungsinformationen anpasst. Tatsächlich wird throw normalerweise in Verbindung mit throws verwendet, und was geworfen wird, ist eine Instanz der Ausnahmeklasse, die im Programm generiert wurde.

ExceptionDemo

Ausgabeergebnis:

setZero-Methode startet:

setZero-Methode endet.

Ausnahme: java.lang.ArrayIndexOutOfBoundsException: 10

main()-Methode endet!

4. RuntimeException-Klasse

Der Unterschied zwischen Exception und RuntimeException:

Exception: Es ist für Benutzer obligatorisch, damit umzugehen;

RunException: Es ist eine Unterklasse von Exception, und der Benutzer entscheidet, ob es verarbeitet werden soll.

5. Benutzerdefinierte Ausnahmeklasse

Die benutzerdefinierte Ausnahmeklasse erbt von der Exception-Klasse, oder Sie können Ihre eigenen Methoden schreiben, um bestimmte Ereignisse zu verarbeiten . Java bietet eine Vererbungsmethode zum Ausführen von von Benutzern geschriebenen Ausnahmeklassen.

 1 class MyException extends Exception
 2 {
 3     public MyException(String message)
 4     {
 5         super(message);
 6     }
 7 }
 8 public class DefinedException
 9 {
10     public static void main(String[] args) 
11     {
12         try
13         {
14             throw new MyException("\n自定义异常类！");
15         }
16         catch(MyException e)
17         {
18             System.out.println(e);
19         }
20     }
21 }

Verwandte Lernempfehlungen: Programmiervideos

Das obige ist der detaillierte Inhalt vonWie man Java-Ausnahmen abfängt und behandelt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!