Bagaimana untuk mengendalikan jenis pengecualian dalam Java

1. Perihalan pengecualian

Peristiwa yang tidak dijangka berlaku apabila program sedang berjalan, yang menghalang program daripada melaksanakan secara normal seperti yang dijangkakan oleh pengaturcara. Apabila pengecualian berlaku, program dibiarkan untuk mengatasi dirinya sendiri dan keluar serta-merta. Dalam Java, iaitu ralat yang berlaku semasa penyusunan atau operasi Java atau semasa operasi.

Java menyediakan penyelesaian yang lebih baik: mekanisme pengendalian pengecualian.

Mekanisme pengendalian pengecualian membolehkan program mengendalikan pengecualian mengikut cara yang disasarkan mengikut logik pengendalian pengecualian pratetap kod apabila pengecualian berlaku, supaya atur cara boleh kembali normal dan meneruskan pelaksanaan sebanyak mungkin , sambil mengekalkan kejelasan kod .

Pengecualian dalam Java boleh disebabkan apabila penyataan dalam fungsi dilaksanakan, atau ia boleh dilemparkan secara manual oleh pengaturcara melalui penyataan lontaran Selagi pengecualian berlaku dalam program Java, Pengecualian objek jenis yang sepadan digunakan untuk merangkum pengecualian, dan JRE akan cuba mencari pengendali pengecualian untuk mengendalikan pengecualian.

• Pengecualian merujuk kepada situasi tidak normal yang berlaku semasa operasi.

• menggunakan kelas dalam Java untuk menerangkan situasi tidak normal dan merangkum objek.

• Kelas yang menerangkan situasi luar biasa menjadi kelas pengecualian.

• Asingkan kod biasa dan kod pengendalian masalah untuk meningkatkan kebolehbacaan.

• Sebenarnya, pengecualian ialah Java merangkum masalah ke dalam objek melalui pemikiran berorientasikan objek, dan menggunakan kelas pengecualian untuk menerangkannya.

2. Sistem pengecualian

Dua kategori utama:

• hrowable: Pengecualian boleh lontar, sama ada ralat Atau pengecualian, ia sepatutnya dilemparkan apabila masalah berlaku, supaya pemanggil dapat mengetahui dan mengendalikannya.

• Ciri sistem ini ialah Throwable dan semua subkelasnya boleh throwable.

Apakah sebenarnya maksud kebolehlontaran? Bagaimana untuk mencerminkan kebolehlontaran?

• dicerminkan oleh dua kata kunci.

• lontaran lontaran Semua kelas dan objek yang boleh dikendalikan oleh dua kata kunci ini boleh dilontar.

• Subkategori 1 umumnya tidak boleh diproses. ————Ralat

• Ciri-ciri: Ia adalah masalah serius yang dilemparkan oleh jvm Apabila masalah seperti ini berlaku, ia biasanya tidak ditangani dengan cara yang disasarkan dan program diubah suai secara langsung.

• Subkelas 2) boleh mengendalikannya. ——Pengecualian, masalah dilemparkan kepada pemanggil, sesiapa yang melemparkannya kepada siapa.

• Ciri: Nama akhiran subkelas semuanya diakhiri dengan nama kelas induknya, yang sangat mudah dibaca!

Contoh: Contohnya, sesuaikan pengecualian subskrip negatif dan merangkumnya ke dalam objek menggunakan pemikiran berorientasikan objek.

• Nota: Jika kelas dipanggil kelas pengecualian, ia mesti mewarisi kelas pengecualian. Kerana hanya subkelas sistem pengecualian boleh dibuang.

class FuShuIndex extends Exception{
                //构造函数 和类名一样
                FuShuIndex(){  
                }
                //定义一个带参数的构造函数
                FuShuIndex(String msg){
                    //调用Exception中的带参数异常函数
                    super(msg);  
                }
            }
            主函数 throws FuShuIndex：{
               int[] arr = new int[3];
               method(arr,-7);
            }
            public static int method(int[] arr,int index) throws arrIndexexception {
                 if (index<0){
                    throw new arrIndexexception("数组的角标不能为负数");
                 }
                return arr[index];
            }

3. Klasifikasi pengecualian:

Pengecualian yang dikesan semasa penyusunan juga merupakan Pengecualian dan subkelasnya, kecuali sistem RuntimeException subkelas khas yang menyusun tanpa pemprosesan gagal!

• Apabila masalah seperti ini berlaku, kami berharap dapat mengesannya pada masa penyusunan supaya masalah seperti ini dapat ditangani dengan sewajarnya, dan masalah sedemikian dapat ditangani dengan cara yang disasarkan .

Pengecualian tidak dikesan pada masa penyusunan (pengecualian masa jalan): RuntimeException dan subkelasnya

• boleh diproses atau tidak, dan kompilasi boleh lulus , ia akan dikesan semasa runtime!

• Berlakunya masalah seperti ini ialah fungsi tidak dapat diteruskan dan operasi tidak dapat dijalankan kebanyakannya disebabkan oleh panggilan atau perubahan keadaan dalaman. Masalah jenis ini secara amnya tidak ditangani, dan disusun secara langsung dan diluluskan Pada masa jalan, program terpaksa berhenti oleh pemanggil, membenarkan pemanggil membetulkan kod.

Perbezaan antara balingan dan balingan:

• balingan digunakan pada fungsi ————Pernyataan

• lontaran digunakan dalam fungsi Anda boleh melontar berbilang, dipisahkan dengan koma. ————Baling

• lontaran lontaran kelas pengecualian dan berbilang pengecualian boleh dilontar.

• lontaran lontaran objek pengecualian.

4. Tangkap bentuk pengendalian pengecualian

Ini ialah cara untuk mengendalikan pengecualian dengan cara yang disasarkan.

Format:

try{
            //需要被检测异常的代码
        }
        catch(异常类 变量)//该变量用于接收发生的异常对象{
            //处理异常代码
        }
        finally{
            //一定会被执行的代码
      }

Contoh

class FuShuIndex extends Exception{
            //构造函数 和类名一样
            FuShuIndex(){  
            }
            //定义一个带参数的构造函数
            FuShuIndex(String msg){
                //调用Exception中的带参数异常函数
                super(msg);  
            }
  }

Fungsi utama: Tidak perlu balingan, mari kita tangkap pengecualian sendiri di bawah

{
           int[] arr = new int[3];
           try{
           method(arr,-7);
           }catch(arrIndexexception a){
                a.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。
                System.out.println("数组的角标异常！！！");//自定义捕获后打印的信息
                System.out.println(a.toString());//打印该异常对象的信息
                System.out.println(a.getMessage());//获取我们自定义抛出所定义的信息
                }
  }
public static int method(int[] arr,int index) throws arrIndexexception {
             if (index<0){
                throw new arrIndexexception("数组的角标不能为负数");
             }
            return arr[index];
 }

Satu percubaan sepadan dengan beberapa tangkapan :

• Dalam kes berbilang tangkapan, tangkapan kelas induk hendaklah diletakkan di bahagian bawah, jika tidak, kompilasi akan kosong.

5 Prinsip pengendalian pengecualian

Jika pengecualian yang perlu dikesan dilemparkan ke dalam fungsi, ia mesti diisytiharkan dalam fungsi, atau ia mesti ditangkap dengan try catch dalam fungsi , jika tidak penyusunan gagal.

Jika fungsi yang mengisytiharkan pengecualian dipanggil, sama ada cuba tangkap atau baling, jika tidak, kompilasi gagal.

Bila hendak menangkap? Bila melontar?

• Kandungan berfungsi boleh diselesaikan dengan menggunakan tangkapan.

• tidak boleh diselesaikan, gunakan lontaran untuk memberitahu pemanggil, dan pemanggil akan menyelesaikannya.

一个功能如果抛出了多个异常，那么调用时，必须有对应的多个catch来进行针对性处理。

• 内部有几个需要检测的异常，就抛几个异常，抛出几个就catch几个异常。

六、finally

通常用于关闭（释放）资源。必须要执行。除非jvm虚拟机挂了。

范例：出门玩，必须关门，所以将关门这个动作放在finally里面，必须执行。

凡是涉及到关闭连接等操作，要用finally代码块来释放资源。

try catch finally 代码块组合特点：

• try catch finally：当有资源需要释放时，可以定义finally

• try catch(多个)：当没有资源需要释放时，可以不定义finally

• try finally：异常处理不处理我不管，但是我得关闭资源，因为资源是我开的，得在内部关掉资源。

范例：

try{
                    //连接数据库
                }
                    //没有catch意思不处理异常，只单纯的捕获异常
                finally{
                    //关闭连接
                }

七、异常的应用

老师用电脑讲课范例：

电脑类：

public class Computer {
                private int state = 2;
                public void run() throws lanpingExcption,maoyanExcption{
                    if (state == 1){
                        throw new lanpingExcption("电脑蓝屏啦～");
                    }else if (state == 2){
                        throw new maoyanExcption("电脑冒烟啦～");
                    }
                    System.out.println("电脑启动");
                }
                public void chongqi(){
                    state = 0;
                    System.out.println("重启电脑！");
                }
  }

老师类：

public class Teacher {
            private String name;
            private Computer computer;
            Teacher(String name){
                this.name = name;
                computer = new Computer();
            }

            void teach() throws maoyanExcption{
                try {
                    computer.run();
                    System.out.println(this.name + "开始用电脑讲课了");
                } catch (lanpingExcption l) {
                    l.printStackTrace();
                    computer.chongqi();
                    teach();//重启后再次讲课
                } catch (maoyanExcption m) {
                    m.printStackTrace();
                    test();
                    throw m;
                }
            }

            public void test(){
                System.out.println("大家自己练习去～");
            }

  }

蓝屏异常类：

public class lanpingExcption extends Exception{
            lanpingExcption (String msg){
                 super(msg);
            }
 }

冒烟异常类：

public class maoyanExcption extends Exception {
            maoyanExcption (String msg){
                super(msg);
            }
}

主函数：

public class Testmain {
            public static void main (String[] args){
                Teacher teacher = new Teacher("丁老师");
                try {
                    teacher.teach();
                } catch (maoyanExcption m) {
                    //m.printStackTrace();
                    System.out.println("。。。。。");
                }
            }
    }

八、异常的注意事项：

• 子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

• 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。

• 子类覆盖父类，只能抛出父类的异常或者子类。

• 如果父类的方法没有抛出异常，子类覆盖时绝对不能抛。

Atas ialah kandungan terperinci Bagaimana untuk mengendalikan jenis pengecualian dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!