java异常

异常

1、对异常的理解

Throwable

Error类:程序运行过程中，非常严重的错误，我们是处理不了的  

 1.如while(true)死循环 会报堆溢出

2.栈内存溢出

比如说:

public class Test {
    public static void main(String[] args) {
        test();
    }
    public static void test (){
        test();
    }
}
就会报异常
    at com.d729.Test.test(Test.java:8)
    at com.d729.Test.test(Test.java:8)

这种错误一旦发生，我们阻止不了，只能修改代码

Exception类：一些简单的异常，通常我们处理的就是这种异常

语法错误不能称为编译器异常

1、编译期异常：

写代码时报错/红色，此时声称不了class文件，是不能运行的

public class Test {
    public static void main(String[] args) {
        String strData = "2024-07-31";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date data = simpleDateFormat.parse(strData);
    }
}

会出错,目的是起警示作用

Error:(10, 43) java: 未报告的异常错误java.text.ParseException; 必须对其进行捕获或声明以便抛出

解决方法1是将异常上抛,告诉计算机已经检查过了,没有问题,若代码有问题还是会报错.

public class Test {
    public static void main(String[] args) throws ParseException {
        String strData = "2024-07-31";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date data = simpleDateFormat.parse(strData);
        System.out.println(data);

    }

}

解决方法2是捕获异常  try--catch

public class Test {
    public static void main(String[] args){
        String strData = "2024/07/31";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date data = null;
        try {
            data = simpleDateFormat.parse(strData);
        } catch (ParseException e) {
            System.out.println("提示信息");//此时若报错会打印出提示信息
        }
        System.out.println(data);
    }
}

这种异常最容易发现，最容易修改

注意：语法错误不是编译期异常

设计理念:

编译期异常 他是给程序员准备的， 我们在书写代码的时候， 有一些地方 很容易出现错误的，而且程序员也经常不注意,Java就设计了编译期异常，提示程序员“这个地方很容易出错”，目的是为了引起程序员的注意。

现在无法编译，只能通过 try{}catch(){}  或者 throws 告知编译器我已经检查完代码了，现在可以编译通过了

运行时异常：RuntimeException,编写代码的过程没有错误，只有代码运行起来后才会报错

1、空指针异常

public class Test {
    public static void main(String[] args){
        String str = null;
        System.out.println(str.length());
    }
}

Exception in thread "main" java.lang.NullPointerException
    at com.d729.Test.main(Test.java:10)
 

2、除数为0造成的异常

public class Test {
    public static void main(String[] args){
        int a =10;
        int b =0;
        System.out.println(a/b);
    }
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.d729.Test.main(Test.java:11)
 

3、索引越界异常

public class Test {
    public static void main(String[] args){
        int[] arr = {1,2,3};
        System.out.println(arr[10]);
    }
}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
    at com.d729.Test.main(Test.java:10)

2、异常的处理

一旦发生异常，程序立刻终止

想要使得程序发生异常后我后面的代码还能正常执行

使用   try{}catch(){}

public class Test {
    public static void main(String[] args){
        int a =10;
        int b =0;
        int[] arr = {1,3};
        try{
        System.out.println(arr[10]);
        System.out.println(a/b);//此时该句不会被执行
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("除数不为0");
        }
    }
}
输出

除数不为0

public class Test {
    public static void main(String[] args){
        int a =10;
        int b =0;
        int[] arr = {1,3};
        try{
        System.out.println(a/b);
        System.out.println(arr[10]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("除数不为0");
        }
    }
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at com.d729.Test.main(Test.java:14)

这里只是交换了打印语句

可以抛出更大的异常来解决

public class Test {
    public static void main(String[] args){
        int a =10;
        int b =0;
        int[] arr = {1,3};
        try{
        System.out.println(a/b);
        System.out.println(arr[10]);
        }catch(Exception e){
            System.out.println("除数不为0");
        }
    }
}

注意：try里如有多个异常，只能抓到第一个异常

2、finally的使用

try catch代码块中如果不出异常try中的代码会被执行完，catch中的代码不被运行，如果出现异常try中的代码块可能执行不完，但是catch中的代码会被运行，但是如果有这样一个需求，不管有没有异常都得打印某项信息，此时我们可以用到finally，（finally常被用于关闭文件流或者与数据库的链接）

无论是否出现异常都会被执行

    2.throws（多数起提示作用）

针对编译期异常，只是起提示作用，告诉编译器让代码编译通过，可以生成class文件

      针对运行时异常，throws无作用，因为不管是否用throws，都没有差别，throws的设计理念针对的是编译期异常

抛出不抛出意义不大

3、自定义异常

1、需求：创建一个Student类，Student中有name和age两个成员属性，当我们年龄输入不合法时需要抛异常

定义一个异常类,继承RuntimeException或者Exception

创建学生类

public class Student {
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            if(age>0 && age<=130) {
                this.age = age;
            }else{//抛出异常
                throw new MyException("年龄不合法");
            }
        }
}
创建我的异常类

public class MyException extends RuntimeException{
    public MyException(String message){//发生什么异常了
        super(message);
    }
}

测试

public class Test {
    public static void main(String[] args){
        Student student = new Student();
        student.setAge(150);
    }
}

Exception in thread "main" com.d729.MyException: 年龄不合法
    at com.d729.Student.setAge(Student.java:23)
    at com.d729.Test.main(Test.java:8)

2、自定义异常的使用场景

当Java语言提供的异常类无法满足我们的需求时，我们就可以使用自定义异常

3、自定义异常有哪些要求

   a) 自定义异常类必须要继承异常体系中的类，一般继承于Exception类和RuntimeException，只有继承异常体系中的类，该自定义类才具有可抛性，即throw关键字 

  b) 自定义异常类要提供两个构造方法，一个是无参构造器，其二是有参构造器