Cara menggunakan kata kunci Java throw, throws dan Throwable

melempar bermaksud "lempar, baling, baling". Throw, Throws dan Throwable semuanya digunakan untuk pengendalian pengecualian.

1. Throwable

Throwable ialah kelas induk peringkat teratas bagi cawangan pengendalian pengecualian di Java Pelaksanaan semua pengendalian pengecualian lain bergantung pada Throwable

Buka rasmi. Dokumentasi Java (versi Java8), cari Throwable, subkelas langsungnya ialah Ralat dan Pengecualian.

Ciri Ralat dan Pengecualian ialah program pengecualian Ralat tidak dapat mengendalikannya dan hanya boleh diserahkan kepada campur tangan manual untuk mengubah suai kod, seperti limpahan tindanan, timbunan limpahan, dsb.; dan Pengecualian Pengecualian Ia boleh dikesan lebih awal dan ditangani dengan berkesan.

1.1 Ralat Sambungan

Antara Ralat, ralat biasa termasuk limpahan tindanan, limpahan timbunan, dsb.

Contohnya, StackOverflowError

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

Rekursi tak terhingga, melaksanakan program ini akan melaporkan pengecualian limpahan tindanan.

Contoh lain ialah pengecualian timbunan, OutOfMemoryError

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

1.2 Extension-Exception

dalam Pengecualian Terdapat banyak pengecualian yang kita kenali, seperti NullPointerException (pengecualian penuding nol), ArrayIndexOutOfBoundsException (subskrip tatasusunan di luar sempadan), NumberFormatException (pengecualian pemformatan nombor), dsb.

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. balingan

balingan digunakan pada pengisytiharan kaedah untuk menunjukkan jenis pengecualian yang mungkin berlaku apabila kaedah ini dilaksanakan. Sebaik sahaja pengecualian berlaku apabila kaedah dilaksanakan, objek kelas pengecualian akan dijana pada kod pengecualian Apabila objek ini memenuhi jenis pengecualian selepas Throws, ia akan dilemparkan. Terdapat dua proses di sini Apabila terdapat pengecualian dalam kod

1 Hasilkan objek pengecualian

2 lontaran menangkap pengecualian ini dan membuang objek pengecualian balingan dan cuba-tangkap-akhirnya bersama dipanggil dua cara pengendalian pengecualian.

cuba-tangkap-akhirnya secara aktif mengendalikan pengecualian apabila pengecualian berlaku, supaya atur cara boleh terus melaksanakan manakala lontaran menangkap pengecualian dan melontar objek pengecualian ke atas tanpa benar-benar mengendalikan pengecualian.

Objek pengecualian lontaran ke atas adalah untuk menyerahkan objek pengecualian kepada pemanggil untuk diproses Contohnya, kaedah A memanggil kaedah B, B melontar pengecualian melalui lontaran, dan A boleh memilih untuk menggunakan cuba -tangkap-akhirnya untuk mengendalikannya Untuk pengecualian, anda juga boleh terus membuang objek pengecualian ke atas melalui lontaran sehingga pengecualian itu benar-benar dikendalikan. Jika tiada cara untuk mengendalikan pengecualian, objek pengecualian akhirnya akan dibuang ke JVM, menyebabkan program berhenti berjalan.

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

Pelanjutan 2.1

——Bagaimana untuk memilih cuba-tangkap-akhir atau balingan?

Apabila terdapat pengecualian dalam kaedah yang perlu dikendalikan, dalam kebanyakan kes, anda boleh sama ada memilih cuba-tangkap-akhirnya untuk mengendalikan pengecualian secara langsung, atau anda boleh memilih lontaran untuk melontar pengecualian ke atas dan serahkan kepada pemanggil untuk mengendalikan. (Apabila pengecualian dilemparkan pada penghujung, mesti ada satu pihak yang benar-benar mengendalikan pengecualian. Bagaimana untuk menanganinya? Mari gunakan cuba-tangkap-akhirnya.) Anda agak bebas dalam pilihan . Walau bagaimanapun, apabila dua situasi berikut berlaku, anda perlu mengikuti peraturan tertentu (Jika anda mempunyai apa-apa untuk ditambah, sila nyatakan).

Jika kaedah yang ditindih dalam kelas induk tidak menggunakan lontaran untuk membuang pengecualian, kaedah yang ditindih oleh subkelas tidak boleh menggunakan lontaran untuk membuang pengecualian, yang bermaksud situasi ini Mesti gunakan cuba -tangkap-akhirnya untuk mengendalikan.
Dalam kaedah A, beberapa kaedah lain dipanggil berturut-turut dalam perhubungan progresif dan kebanyakannya mempunyai pengecualian yang perlu dikendalikan Beberapa kaedah yang dipanggil menggunakan lontaran untuk melontar pengecualian ke atas Dalam kaedah A, cuba-tangkap-akhir digunakan untuk mengendalikan pengecualian ini secara seragam.
Berkenaan yang pertama, ini adalah satu ketetapan bahawa pengecualian yang dilemparkan oleh kaedah yang ditindih dalam subkelas menggunakan lontaran mestilah tidak lebih besar daripada pengecualian yang dilemparkan oleh kaedah yang ditindih dalam kelas induk skop. Sebagai contoh, jika kaedah B dalam kelas induk membuang NullPointerException, maka kaedah yang ditindih B dalam subkelas tidak boleh membuang pengecualian seperti Pengecualian yang mempunyai skop yang lebih luas daripada NullPointerException jika kaedah yang ditindih dalam kelas induk tidak membuang Jika sebarang pengecualian berlaku , subkelas tidak boleh membuang pengecualian.

Kenapa? Tunjukkan sekeping kod.

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

Dalam contoh ini, dengan mengandaikan bahawa kaedah B dalam kelas induk membuang NullPointerException, kaedah ganti B dalam subkelas boleh membuang Exception. Kemudian jika parameter yang diluluskan ke dalam kaedah ujian adalah objek instantiated kelas induk, maka tidak ada masalah untuk memanggil kaedah ujian. Jika parameter yang dilalui ialah objek termaktub bagi subkelas, dan kemudian kaedah B yang ditulis semula oleh subkelas dipanggil, Pengecualian boleh dilemparkan, dan struktur cuba-tangkap tidak boleh menghalang pengecualian ini .

针对第二条，假设方法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());
    }
}

Atas ialah kandungan terperinci Cara menggunakan kata kunci Java throw, throws dan Throwable. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!