异常的讲解（1）

_雨_

已于 2023-04-17 21:03:31 修改

阅读量240

点赞数

文章标签： java intellij-idea 开发语言

于 2023-04-16 04:15:00 首次发布

本文链接：https://blog.csdn.net/weixin_53616401/article/details/130034375

版权

本文介绍了Java中的异常处理，包括运行时异常如NullPointerException、ArithmeticException等和编译异常，强调了异常处理机制如try-catch-finally的使用，以及异常处理的注意事项和练习题。

摘要由CSDN通过智能技术生成

1.NullPointerException空指针异常

2.ArithmeticException数学运算异常

3.ArraylndexOutOfBoundsException数组下标越界异常

4.ClassCastException类型转换异常

5.NumberFormatException数字格式不正确异常

try-catch-finally执行顺序小结

异常入门的案例

在下面的代码中我们在执行到 int res = num1/num2; 的时候就会报错，如果我们没有使用try - catch 那么程序就会直接奔溃

package idea.chapter12.exception_;

public class Exception01 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;//Scanner();


        //1. num1 / num2 => 10 / 0
        //2. 当执行到 num1 / num2 因为 num2 = 0, 程序就会出现(抛出)异常 ArithmeticException
        //3. 当抛出异常后，程序就退出，崩溃了 , 下面的代码就不在执行
        //4. 这种情况非常的不好，不应该出现了一个不算致命的问题，就导致整个系统崩溃
        //5. 因此有一个异常处理机制来解决该问题
        //   int res = num1 / num2;
        //如果我们觉得，认为一段代码可能出现异常/问题，可以使用try-catch异常处理机制来解决
        //从而保证程序的发生了错误但是不会直接崩溃
        //将该代码块->选中->快捷键 ctrl + alt + t -> 选中 try-catch
        //6. 如果进行异常处理，那么即使出现了异常，程序可以继续执行
        try {
            int res = num1 / num2;
        } catch (Exception e) {
            e.printStackTrace();
            //System.out.println("出现异常的原因=" + e.getMessage());//输出异常信息
        }

        //从运行结果中我们可以看到，程序还是出错了，但是没有直接奔溃，而且将代码执行完毕在退出
        System.out.println("程序继续运行");

    }
}

异常介绍基本概念

Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)

执行过程中所发生的异常事件可分为两大类

1)Error(错误)：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError[栈溢出]和OOM(out of memory)[内存耗尽]，Error是严重错误，程序会崩溃。

2.Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等，Exception分为两大类：运行时异常[程序运行时，发生的异常]和编译时异常[编程时，编译器检查出的异常]。

异常的小结

1.异常分为两大类，运行时异常和编译时异常.

2.运行时异常，编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常

3.对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响

4.编译时异常，是编译器要求必须处置的异常

常见的运行时异常

1.NullPointerException空指针异常

当应用程序试图在需要对象的地方使用null时，抛出该异常

package idea.chapter12.exception_;

/**
 * 演示空指针异常
 */
public class NullPointerException_ {
    public static void main(String[] args) {
        String name = null;
        System.out.println(name.length());
    }
}

2.ArithmeticException数学运算异常

当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例，

package idea.chapter12.exception_;

/**
 * 演示数学运算异常
 */
public class ArithmeticException_ {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;//Scanner();
        System.out.println(num1/num2);
    }
}

3.ArraylndexOutOfBoundsException数组下标越界异常

数组下标越界异常用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引

package idea.chapter12.exception_;

/**
 * 演示数组下标异常
 */
public class ArrayIndexOutOfBoundsException_ {
    public static void main(String[] args) {
        int[] arr = {1, 2, 4};
        for (int i = 0; i <= arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

4.ClassCastException类型转换异常

类型转换异常当试图将对象强制转换为不是实例的子类时，抛出该异常。例如，以下代码将生成一个ClassCastException

package idea.chapter12.exception_;

/**
 * 演示类型转换异常
 */
public class ClassCastException_ {
    public static void main(String[] args) {
        A b = new B(); //向上转型
        B b2 = (B) b;//向下转型，这里是OK
        //多态的向下转型**
        //1)语法：子类类型 引用名= （子类类型)父类引用；
        //2)只能强转父类的引用，不能强转父类的对象
        //3)要求父类的引用必须指向的是当前目标类型的对象
        //4)当向下转型后，可以调用子类类型中所有的成员
        //这里c2的类型是B  和C没有任何关系所以报错
        C c2 = (C) b;//这里抛出ClassCastException
    }
}

class A {
}

class B extends A {
}

class C extends A {
}

5.NumberFormatException数字格式不正确异常

数字格式不正确异常当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常使用异常我们可以确保输入是满足条件数字.

package idea.chapter12.exception_;

/**
 * 演示类型转换异常
 */
public class NumberFormatException_ {
    public static void main(String[] args) {
        String name = "你好";
        //将String 转成 int
        int num = Integer.parseInt(name);//抛出NumberFormatException
        System.out.println(num);//1234
    }
}

编译异常

基本介绍

编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译。

常见的编译异常

SQLException//操作数据库时，查询表可能发生异常

IOException//操作文件时，发生的异常

FileNotFoundException//当操作一个不存在的文件时，发生异常

ClassNotFoundException//加载类，而该类不存在时，异常

EOFException//操作文件，到文件末尾，发生异常

IllegalArguementException//参数异常

异常处理

基本介绍

异常处理就是当异常发生时，对异常处理的方式。

异常处理的方式

1)try-catch-finally 程序员在代码中捕获发生的异常，自行处理

2.throws 将发生的异常抛出，交给调用者(方法)来处理

异常的练习

public class AAA{
    int x;    //默认 0
    public static void main(String[] args){
        int y;
        AAA a=new AAA();
        y=3/a.x;//==>3/0
        System.out.println("program ends ok!);
                //出现ArithmeticException
    }
}

    Cat c=new Cat();
    I cat=null;
    System.out.println(cat.name);
    出现NullPointerException


class Person{
    public static void main(String[] args){
        Object obj = new Date();
        Person person;
        person=(Person)obj;
        System.out.println(person);
        //出现ClassCastException
    }

}

try-catch异常处理

1.Java提供try和catch块来处理异常。try块用于包含可能出错的代码。catch块用于处理try块中发生的异常。可以根据需要在程序中有多个try...catch块。

2)基本语法

try {

    //可疑代码
    //将异常生成对应的异常对象，传递给catch块

}catch(异常)( //对异常的处理

}

//如果没有finally，语法是可以通过

try-catch方式异常处理注意事项

1)如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块.

2)如果异常没有发生，则顺序执行try的代码块，不会进入到catch.

3)如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码-finally{}

package idea.chapter12.try_;

public class TryCatchDetail01 {
    public static void main(String[] args) {
        /*
        1)如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块.
        2)如果异常没有发生，则顺序执行try的代码块，不会进入到catch.
        3)如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码-finally{}
         */

        try {
            String str = "你好";
            int a = Integer.parseInt(str);
            //1)如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块.
            //这里会报出一个classCastException异常，因为尝试将一个字符串，转成一个int
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
            //如果程序发生异常，就不会在执行try中的代码块，而是执行catch中的代码块
            System.out.println("异常信息=" + e.getMessage());
        } finally {
            //无论程序是否有异常，finally都会被执行
            System.out.println("finally代码块被执行...");
        }

        System.out.println("程序继续执行");
    }
}

4.可以有多个catch语句，捕获不同的异常(进行不同的业务处理)，要求父类异
常在后，子类异常在前，比如(Exception在后，NullPointerException在
前)，如果发生异常，只会匹配一个catch

package idea.chapter12.try_;

public class TryCatchDetail02 {
    public static void main(String[] args) {

        //1.如果try代码块有可能有多个异常
        //2.可以使用多个catch 分别捕获不同的异常，相应处理
        //3.要求子类异常写在前面，父类异常写在后面
        try {
            Person person = new Person();
            //person = null;
            System.out.println(person.getName());//NullPointerException
            int n1 = 10;
            int n2 = 0;
            int res = n1 / n2;//ArithmeticException
        } catch (NullPointerException e) {
            System.out.println("空指针异常=" + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("算术异常=" + e.getMessage());
        } catch (Exception e) {//因为Exception是他们的父类，所以要写在后面，如果写在前面会报错
            System.out.println(e.getMessage());
        } finally {
        }

    }
}

class Person {
    private String name = "jack";

    public String getName() {
        return name;
    }
}

5)可以进行try-finally配合使用，这种用法相当于没有捕获异常，因此程序会直接崩掉。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑

·try{ //代码

}

finallyfl {//总是执行

}

package idea.chapter12.try_;

public class TryCatchDetail03 {
    public static void main(String[] args) {

        /*
        可以进行 try-finally 配合使用, 这种用法相当于没有捕获异常，
        因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，
        都必须执行某个业务逻辑
         */
        try{
            int n1 = 10;
            int n2 = 0;
            System.out.println(n1 / n2);
        }finally {
            //及时没有捕获异常，也会执行finally中的代码
            System.out.println("执行了finally..");
        }
        System.out.println("程序继续执行..");

    }

}

try-catch异常处理习题

第一题

思路分析：
1.首先我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
  就会被catch中捕获到，返回3，但是要注意代码中finally存在，因此还要执行finally中的代码，而finally中代码返回的4那么最终的结果返回的也就是4
2.这里不要忘记，finally必须执行

package idea.chapter12.try_;

public class TryCatchExercise01 {
}

/*
思路分析：
1.首先我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
  就会被catch中捕获到，返回3，但是要注意代码中finally存在，因此还要执行finally中的代码，而finally中代码返回的4那么最终的结果返回的也就是4
2.这里不要忘记，finally必须执行  
 */
class Exception01 {
    public static int method() {
        try {
            String[] names = new String[3];//String[]数组
            if (names[1].equals("tom")) {//NullPointerException
                System.out.println(names[1]);
            } else {
                names[3] = "jack";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {//捕获
            return 3;
        } finally { //必须执行
            return 4; //返回4
        }
    }

    public static void main(String[] args) {
        System.out.println(method()); //4
    }
}

第二题

思路分析：
1.我们先执行了i++;因此i现在的值就是2
2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
  就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，但是要注意的是，还要finally中的代码没有执行
  所以会执行finally中的代码，finally中的代码也是return ++i 所以先自增后返回，最后返回的就是4

package idea.chapter12.try_;

public class TryCatchExercise02 {
}
/*
思路分析：
1.我们先执行了i++;因此i现在的值就是2
2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
  就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，但是要注意的是，还要finally中的代码没有执行
  所以会执行finally中的代码，finally中的代码也是return ++i 所以先自增后返回，最后返回的就是4
 */
class Exception02 {
    public static int method() {
        int i = 1;
        try {
            i++; //i = 2
            String[] names = new String[3];
            if (names[1].equals("tom")) {//空指针
                System.out.println(names[1]);
            } else {
                names[3] = "jack";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {
            return ++i; //i = 3
        } finally {//必须执行
            return ++i; //i = 4
        }
    }

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

第三题

思路分析：

1.我们先执行了i++;因此i现在的值就是2
2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
  就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，此时i自增完之后是3 ，但是要注意的是，还要finally中的代码没有执行
  所以不能直接返回，要执行finally中的代码，finally中的代码也是 ++i 导致i变成了4 然后在输出i,那么输出的结果也就是4
3.注意我们在catch中的i还没有返回，因为在执行finally中的代码的时候，会有一个临时变量，暂时保存到i去执行finally代码块之前的值，所以会返回一个3

package idea.chapter12.try_;

public class TryCatchExercise03 {
}
/*
1.我们先执行了i++;因此i现在的值就是2
2.我们创建了一个String类型的数组，因为我们没有给数组初始化，此时，数组中的元素初始值都是null， if (names[1].equals("tom")) 这句话的时候，会报出空指针异常
  就会被异常捕获，因为是空指针异常，所以会执行这句话，return ++i;因为是前++,所以i会先自增后返回，此时i自增完之后是3 ，但是要注意的是，还要finally中的代码没有执行
  所以不能直接返回，要执行finally中的代码，finally中的代码也是 ++i 导致i变成了4 然后在输出i,那么输出的结果也就是4
3.注意我们在catch中的i还没有返回，因为在执行finally中的代码的时候，会有一个临时变量，暂时保存到i去执行finally代码块之前的值，所以会返回一个3
 */
class ExceptionExe01 {
    public static int method() {
        int i = 1;//i = 1
        try {
            i++;// i=2
            String[] names = new String[3];
            if (names[1].equals("tom")) { //空指针
                System.out.println(names[1]);
            } else {
                names[3] = "jack";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            return 2;
        } catch (NullPointerException e) {
            return ++i;  // i = 3 => 保存临时变量 temp = 3;
            //因为必须要执行finally，但是finally没有return语句所以在执行完finally后返回到catch (NullPointerException e)这里，并且会保存一个临时变量，返回的也是临时变量的值
        } finally {
            ++i; //i = 4
            System.out.println("i=" + i);// i = 4
        }
    }

    public static void main(String[] args) {
        System.out.println(method());// 3
    }
}

第四题

package idea.chapter12.try_;

import java.util.Scanner;

public class TryCatchExercise04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//创建一个scanner
        int num = 0;
        String key = "";
        for (; ; ) {//创建一个无限循化
            try {
                System.out.println("请输入一个整数");//提示用户输入
                key = scanner.next();//接受用户的输入
                num = Integer.parseInt(key);
                //然后调用包装类  把输入的值转换成一个整数可能会报异常这时候就会执行到catch语句里 ，提示重新输入
                //因为是在循化里catch里没有break语句所以会重复执行一直到成功转换没有异常才会执行的try里面的break 跳出循化
                //如果没有异常，就不会执行到catch中的代码，直接执行break跳出循环
                break;
            } catch (Exception e) {
                System.out.println("输入错误，重新输入");
            }
        }
        System.out.println("你输入的数为：" + num);
    }
}