Mari analisa punca dan pemprosesan pengecualian di Jawa-javaTutorial-php.cn

Artikel ini membawa anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu yang berkaitan dengan pengecualian, juga dikenali sebagai pengecualian, adalah peristiwa yang berlaku semasa pelaksanaan program Mari kita lihat. Saya harap ia akan membantu semua orang.

Mari analisa punca dan pemprosesan pengecualian di Jawa

Pembelajaran yang disyorkan: "tutorial video java"

Pengecualian dalam Java ), juga dikenali sebagai pengecualian, ialah peristiwa yang berlaku semasa pelaksanaan program yang mengganggu aliran biasa arahan dalam program yang melaksanakan. Untuk mengendalikan ralat berjalan dalam program dengan segera dan berkesan, kelas pengecualian mesti digunakan.

1. Punca dan klasifikasi pengecualian

1.1 Punca pengecualian

Pengecualian berlaku di Java atas tiga sebab utama:

(1) Ralat dalam menulis kod program Pengecualian yang dihasilkan, seperti tatasusunan luar sempadan, pengecualian penuding nol, dsb., dipanggil pengecualian tidak ditanda Pengecualian ini biasanya perlu dikendalikan dalam kelas

(2 ) An. pengecualian berlaku apabila ralat dalaman berlaku dalam Java Mesin maya Java menjana pengecualian

(3) Pengecualian dijana secara manual melalui pernyataan lontaran ini pengecualian biasanya digunakan untuk memberi pemanggil kaedah beberapa maklumat yang diperlukan

1.2 Pengelasan pengecualian

(1) Boleh Lempar: Ia ialah kelas peringkat atas sistem pengecualian, yang memperoleh dua subkelas penting, Ralat dan Pengecualian

Kedua-dua subkelas Ralat dan Pengecualian masing-masing mewakili ralat dan pengecualian.

Perbezaannya ialah Pengecualian Tidak Ditanda dan Pengecualian Ditanda .

(2) Kelas Pengecualian digunakan untuk pengecualian yang mungkin berlaku dalam atur cara pengguna Ia juga merupakan kelas yang digunakan untuk mencipta kelas jenis pengecualian tersuai.

(3) Ralat mentakrifkan pengecualian yang tidak dijangka akan ditangkap oleh program dalam keadaan biasa. Pengecualian jenis Ralat digunakan oleh masa jalan Java untuk memaparkan ralat yang berkaitan dengan sistem masa jalan itu sendiri. Limpahan tindanan ialah contoh ralat ini.

Pengecualian mungkin berlaku semasa penyusunan atau semasa program dijalankan Bergantung pada masa kejadian, ia boleh dibahagikan kepada:

Pengecualian RuntimeException ialah kelas RuntimeException dan pengecualian subkelasnya, seperti NullPointerException, IndexOutOfBoundsException, dll. Pengecualian ini bukan pengecualian yang disemak dan anda boleh memilih untuk menangkapnya program, atau Ia tidak perlu diproses. Pengecualian ini biasanya disebabkan oleh ralat logik program, dan program harus cuba mengelakkan berlakunya pengecualian tersebut dari perspektif logik.

Contohnya:

Pengecualian masa kompilasi merujuk kepada pengecualian lain daripada RuntimeException , semua jenis tergolong dalam kelas Exception dan subkelasnya. Dari perspektif sintaks program, ia adalah pengecualian yang mesti dikendalikan Jika ia tidak dikendalikan, program tidak akan disusun. Seperti IOException, ClassNotFoundException, dsb. dan pengecualian yang ditentukan pengguna Secara amnya, tiada pengecualian yang disemak tersuai digunakan.

Contohnya

class Person implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test01 {

    public static void main(String[] args) {
        Person person =new Person();
        Person person1 =(Person) person.clone();
    }
}

Salin selepas log masuk

2. Pengendalian pengecualian

2.1 Pengaturcaraan Defensif

Ralat wujud secara objektif dalam kod Jadi biarkan masalah timbul dalam program Cepat maklumkan pengaturcara

Terdapat dua cara untuk memberitahu:

(1) LBYL cukup sebelum operasi Semak

private static int pide() {
        int a = 0, b = 0;
        Scanner scanner = new Scanner(System.in);
        a = scanner.nextInt();
        b = scanner.nextInt();
        if (b == 0) {
            System.out.println("除数为0");
            return 0;
        } else {
            return a / b;
        }
    }

Salin selepas log masuk

缺点：正常流程和错误处理流程代码混在一起, 代码整体条理不清晰。

（2）EAFP 先操作遇到问题再处理

private static int pide() {
        int a = 0, b = 0;
        try (Scanner scanner = new Scanner(System.in)) {
            a = scanner.nextInt();
            b = scanner.nextInt();
            return a / b;
        } catch (ArithmeticException exception) {
            System.out.println("除数为0");
            return 0;
        } 
    }

Salin selepas log masuk

优点：正常流程和错误流程是分离开的, 程序员更关注正常流程，代码更清晰，容易理解代码

处理异常的核心思想就是EAFP

2.2 异常的抛出（throw）

在编写程序时，如果程序中出现错误，这就需要将错误的信息通知给调用者

这里就可以借助关键字throw，抛出一个指定的异常对象，将错误信息告知给调用者。

比如写一个运行时异常

    public static void func2(int a) {
        if(a == 0) {
           //抛出的是一个指定的异常，最多的使用方式是，抛出一个自定义的异常
            throw new RuntimeException("a==0");
        }
    }
    public static void main(String[] args) {
        func2(0);
    }

Salin selepas log masuk

注意：

（1）throw必须写在方法体内部

（2）如果抛出的是编译时异常，用户就必须要处理，否则无法通过编译

（3）如果抛出的运行时异常，则可以不用处理，直接交给JVM来处理

（4）一旦出现异常，后面的代码就不会执行

2.3 异常的捕获

2.3.1 throws异常声明

throws处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，

此时就可以借助throws将异常抛给方法的调用者来处理。

格式：

修饰符返回值类型方法名(参数列表) throws 异常类型 {

}

如果说方法内部抛出了多个异常，throws之后就必须跟多个异常类型，用逗号进行分隔

    public static void func2(int a) throws CloneNotSupportedException, FileNotFoundException {
        if(a == 0) {
            throw new CloneNotSupportedException("a==0");
        }
        if(a == 1) {
            throw new FileNotFoundException();
        }
    }

Salin selepas log masuk

如果抛出多个异常类型有父子关系，直接声明父类

    public static void func2(int a) throws Exception {
        if(a == 0) {
            throw new CloneNotSupportedException("a==0");
        }
        if(a == 1) {
            throw new FileNotFoundException();
        }
    }

Salin selepas log masuk

调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

   public static void main(String[] args) throws FileNotFoundException, CloneNotSupportedException {
        func2(0);
    }

Salin selepas log masuk

2.3.2 try-catch捕获异常并处理

当程序抛出异常的时候，程序员通过try-each处理了异常

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }
        System.out.println("其他程序！");
    }

Salin selepas log masuk

如果程序抛出异常，不处理异常，那就会交给JVM处理，JVM处理就会把程序立即终止

并且，即使用了try-each 也必须捕获一个对应的异常，如果不是对应异常，也会让JVM进行处理

如果try抛出多个异常，就必须用多个catch进行捕获

这里注意，用多个catch进行捕获，不是同时进行捕获的，因为不可能同时抛不同的异常

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

Salin selepas log masuk

也可以简写一下

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException  | ArithmeticException e) {
            System.out.println("捕获到了一个空指针或算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

Salin selepas log masuk

如果异常之间具有父子关系，那就必须子类异常在前，父类异常在后catch，不然会报错

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (Exception) {
            System.out.println("捕获到了一个算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

Salin selepas log masuk

2.3.3 finally

finally用来进行资源回收，不论程序正常运行还是退出，都需要回收资源

并且异常会引发程序的跳转，可能会导致有些语句执行不到

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }finally {
            scanner.close();
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

Salin selepas log masuk

如果不为空，那么finally还会被执行吗

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int[] array = {1,2,3};
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }finally {
            scanner.close();
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

Salin selepas log masuk

所以，不管程序会不会抛出异常，finally都会执行

如果将资源写在try中会自动帮助，关掉资源的

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int[] array = {1, 2, 3};
            System.out.println(array.length);
        } catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        } catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        } finally {
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

Salin selepas log masuk

下面看这一段代码

    public static int func(int a) {
        try{
            if(a == 0) {
                throw  new ArithmeticException();
            }
            return a;
        } catch (ArithmeticException e) {
            System.out.println("算术异常！");
        } finally {
            return 20;
        }
    }

    public static void main(String[] args) {
        System.out.println(func(10));
    }

Salin selepas log masuk

可以发现即使有return，finally也会被执行

总结一下：

throw抛出异常，throws声明异常

finally语句一定会执行

3.自定义异常类

虽然java中有很多异常类，但是在实际开发中所遇到的一些异常，不能完全表示，

所以这就需要我们自定义异常类

举一个例子

先自定义一个运行时异常

//自定义了一个运行时异常
public class MyException extends RuntimeException{
    public MyException() {

    }
    public MyException(String message) {
        super(message);
    }
}

Salin selepas log masuk

写一个类来捕获这个自定义异常

public class Test04 {
    public static void func(int a ) {
        throw new MyException("呵呵！");
    }

    public static void main(String[] args) {
        try {
            func(20);
        }catch (MyException myException) {
            myException.printStackTrace();
        }finally {
            System.out.println("sadasdasd");
        }

    }
}

Salin selepas log masuk

下面写一个用户登录的自定义异常类

class UserNameException extends RuntimeException {
    public UserNameException() {

    }
    public UserNameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException {

    public PasswordException() {
    }

    public PasswordException(String message) {
        super(message);
    }
}

Salin selepas log masuk

public class LogIn {
    private static String uName = "admin";
    private static String pword = "1111";

    public static void loginInfo(String userName, String password) {
        if ( !uName.equals(userName)) {
            throw new UserNameException("用户名错误！");
        }
        if ( !pword.equals(password)) {
            throw new RuntimeException("密码错误！");

        }
        System.out.println("登录成功！");
    }

    public static void main(String[] args) {
        try {
            loginInfo("admin","1111");
        } catch (UserNameException e) {
            e.printStackTrace();
        } catch (PasswordException e) {
            e.printStackTrace();
        }
    }
}

Salin selepas log masuk

注意：

自定义异常默认会继承 Exception 或者 RuntimeException

继承于 Exception 的异常默认是受查异常

继承于 RuntimeException 的异常默认是非受查异常

推荐学习：《java视频教程》

Atas ialah kandungan terperinci Mari analisa punca dan pemprosesan pengecualian di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!