Java 第十三次作业

一、异常

1.1 认识异常

        在 Java 中，将程序执行过程中发生的不正常行为称为异常 。

1.2  异常类型

        Throwable：是所有异常的父类，其派生出两个重要的子类, Error 和 Exception
 Error：指的是Java虚拟机无法解决的严重问题，正常情况下程序不会捕捉到的异常。比如：JVM的内部错误、资源耗尽等，典型代表： StackOverflflowError和OutOfMemoryError。
Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。

异常范例

package jjj;
class jj { //创建一个类
    int i=10;//定义一个整型变量并初始化
}
public class j {
    public static void main(String[] args) {//主方法
        int a=10;//定义一个整型变量并初始化
        int b=0;//定义一个整型变量并初始化
        int temp=a/b;//计算两个变量的商
        System.out.println(temp);//输出结果
 
    }
 
}

hrow必须写在方法体内部
抛出的对象必须是Exception 或者 Exception 的子类对象
如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
异常一旦抛出，其后的代码就不会执行

二、处理异常

代码

try{//捕捉异常
异常语句
}catch(Exception e){//处理异常
 
}
finally{//会执行的语句
一定会执行的代码
class Quadrangle { //创建一个类
    int i=10;//定义一个整型变量并初始化
}
 
public class ExceptionDemo01 { //创建ExceptionDemo01类
    public static void main(String[] args) {//主方法
        int a=10;//定义一个整型变量并初始化
        int b=0;//定义一个整型变量并初始化
        int temp=0;//计算两个变量的商
        try{ temp=a/b;//计算两个变量的商
        }catch(ArithmeticException e){//处理异常
            System.out.println(e);//输出异常信息
        }
 
        System.out.println(temp);//输出结果
 
    }
}

 三、异常处理 -常见异常 

代码

class Quadrangle { //创建一个类
    int a=10;//定义一个整型变量并初始化
    int b=10;//定义一个整型变量并初始化
}
 
public class ExceptionDemo01 { //创建ExceptionDemo01类
    public static void main(String[] args) {//主方法
        int temp=0;//定义一个整型变量并初始化
        Exc e=null;//创建对象
        //e=new Exc();//实例化对象
        try{//捕捉异常
            temp=e.a/e.b;//计算商
            System.out.println(temp);//输出结果
        }catch(NullPointerException e2){//处理异常
            System.out.println("空指针异常："+e2);//输出异常信息
        }catch(ArithmeticException e2){//处理异常
            System.out.println("算数异常："+e2);//输出异常信息
        }
        finally{//最后一定会执行的代码
            System.out.println("程序推出");//输出信息
        }
    }
}

3-1  异常类分两大类型

        Error类代表了编译和系统的错误，不允许捕获；Exception类代表了标准Java库方法所激发的异常。Exception类还包含运行异常类Runtime_Exception和非运行异常类Non_RuntimeException这两个直接的子类。

        运行异常类对应于编译错误，它是指Java程序在运行时产生的由解释器引发的各种异常。运行异常可能出现在任何地方，且出现频率很高，因此为了避免巨大的系统资源开销，编译器不对异常进行检查。所以Java语言中的运行异常不一定被捕获。出现运行错误往往表示代码有错误，如：算数异常（如被0除）、下标异常（如数组越界）等。

        非运行异常时Non_RuntimeException类及其子类的实例，又称为可检测异常。Java编译器利用分析方法或构造方法中可能产生的结果来检测Java程序中是否含有检测异常的处理程序，对于每个可能的可检测异常，方法或构造方法的throws子句必须列出该异常对应的类。在Java的标准包java.lang java.util 和 java.net 中定义的异常都是非运行异常。

在 Java 中一个异常的产生，主要有如下三种原因：

Java 内部错误发生异常，Java 虚拟机产生的异常。
编写的程序代码中的错误所产生的异常，例如空指针异常、数组越界异常等。
通过 throw 语句手动生成的异常，一般用来告知该方法的调用者一些必要信息。

异常捕获处理
异常捕获处理详细说明：

private static void testException2() {
        try {
            //1、对可能产生异常的代码进行检视
            //2、如果try代码块的某条语句产生了异常, 就立即跳转到catch子句执行, try代码块后面的代码不再执行
            //3、try代码块可能会有多个受检异常需要预处理, 可以通过多个catch子句分别捕获
        } catch (异常类型1 e1) {
            //捕获异常类型1的异常, 进行处理
            //在开发阶段, 一般的处理方式要么获得异常信息, 要么打印异常栈跟踪信息(e1.printStackTrace())
            //在部署后, 如果有异常, 一般把异常信息打印到日志文件中, 如：logger.error(e1.getMessage());
        } catch (异常类型2 e1) {
            //捕获异常类型2的异常, 进行处理
            //如果捕获的异常类型有继承关系, 应该先捕获子异常再捕获父异常
            //如果没有继承关系, catch子句没有先后顺序
        } finally {
            //不管是否产生了异常, finally子句总是会执行
            //一般情况下, 会在finally子句中释放系统资源
        }
}

四.throws关键字

        使用throws关键字声明的方法表示此方法不处理异常，而交给方法调用处进行处理。

        throws声明的方法之后，那么不管操作是否出现异常，都必须使用try...catch语句进行异常处理。
  主方法使用throws后，那么这个异常就将交给JVM进行处理，而后结束程序调用。        

代码

public class ExceptionDemo02 {  //创建ExceptionDemo02 
    public static void main(String[] args) {//主方法
        tell(10,0);//调用方法并传入值
    }
    public static void tell(int i,int j)throws ArithmeticException{//创建类并抛出算数异常
        int temp=0;//定义一个整型变量并初始化
        temp=i/j;//计算商
        System.out.println(temp);//输出信息
    }
 
}

 

五.throw关键字

throw
throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。

throw是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行throw一定是抛出了某种异常。

throw一般用于抛出自定义异常。

throws
throws语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。

throws主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类型。

throws表示出现异常的一种可能性，并不一定会发生这种异常。

throws关键字格式：

public 返回值类型 方法名称（参数列表，，，）throws 异常类{}；

假设定义一个除法，对于除法操作可能出现异常，可能不会。所以对于这种方法最好将它使用throws关键字声明，一旦出现异常，

则应该交给调用处处理。

class Math{undefined
    public int div(int i,int j) throws Exception{    // 定义除法操作，如果有异常，则交给被调用处处理
        int temp = i / j ;    // 计算，但是此处有可能出现异常
        return temp ;
    }
};
public class ThrowsDemo01{undefined
    public static void main(String args[]){undefined
        Math m = new Math() ;        // 实例化Math类对象
        try{undefined
            System.out.println("除法操作：" + m.div(10,2)) ;
        }catch(Exception e){        // 处理异常
            e.printStackTrace() ;    // 就打印了异常内容
        }
    }

代码

public class ExceptionDemo03 {//创建ExceptionDemo03
    public static void main(String[] args) {//主方法
        try{//捕捉异常
            throw new Exception("实例化异常对象");//利用throw关键字直接抛出异常实例化对象
        }catch(Exception e){//处理异常
            System.out.println(e);//输出异常信息
        }
 
    }
 
}

 

 

六.自定义异常 

        Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是没有定义好的,此时我们根据自己业务的异常情况来定义异常类。

如何自定义:

　　① 一般地，用户自定义异常类都是 RuntimeException 的子类；

　　② 自定义异常类通常需要编写几个重载的构造器；

　　③ 自定义异常需要提供 serialVersionID；

　　④ 自定义的异常通过 throw 抛出；

　　⑤ 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型；

 自定义异常的语法形式为：

<class><自定义异常名><extends><Exception>

        在编码规范上，一般将自定义异常类的类名命名为 XXXException，其中 XXX 用来代表该异常的作用。

代码

class MyException extends Exception{//创建自定义异常类并继承父类
    public MyException(String msg){//定义方法并传入一个字符串参数
        super(msg);//调用父类构造方法
    }
}
public class ExceptionDemo04 {//创建类
        public static void main(String[] args) {//主方法
            try{//捕捉异常
                throw new MyException("自定义异常");//直接抛出自定义异常实例化对象
            }catch(MyException e){//处理异常
                System.out.println(e);//输出异常信息
        }
    }
}