JAVA基础-异常

1. 异常的概念

在Java中异常被当做对象来处理，根类是java.lang.Throwable类。所有异常类分为两大类：Error和Exception

• Error是无法处理的异常，比如OutOfMemoryError（内存），一般发生这种异

常，JVM会选择终止程序。因此我们编写程序时不需要关心这类异常

• Exception，也就是我们经常见到的一些异常情况，这些异常是我们可以处理的

2. 常见的异常及捕获

下表中列出了几个常见的异常，其中所有的异常都是Exception的子类：

我们使用try catch块来捕获异常，最基本的用法如下，我们捕获一个NullPointerException异常：

Ps:请留意异常的打印到栈的用法。

public class Ex1 {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		try {
			/*
			 *  1.抛出到main的外面
			 *  2.捕获
			*/
//			int a = 10/0;
			String string = null;
			System.out.println(string.length());
			System.out.println("不报错");
		} catch (Exception e) {
			// TODO: handle exception
			//异常的打印到栈
			e.printStackTrace();
			System.out.println("报错了");
		}
		
		System.out.println("程序结束！！");
	}

}

//输出：
//java.lang.NullPointerException
//报错了
//程序结束！！
//	at Ex1.main(Ex1.java:15)

我们还可以捕获一个日期类型的异常：

这里我们顺便复习了如何用Date类去统计某一段程序的运行时间。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Ex2 {

	
	public static void main(String[] args)  {
		
		//统计运行时间
		Date d1=new Date();
		System.out.println(d1);
		long t1 = d1.getTime();
		for(int i = 0;i < 100000000 ;i++) {
			int a = i;
			for(int j = 0;j < 100000000 ;j++) {
				int b = 1;
			}
		}
		Date d2 = new Date();
		long t2 = d2.getTime();
		System.out.println(t2-t1);
        
        //异常
		SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd");
		try {
			Date d3 = s.parse("2020-12-aaaaaaa");
			System.out.println(s.format(d3));
			System.out.println("okokoko");
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}


/*
Sun Apr 12 22:19:29 CST 2020
78
java.text.ParseException: Unparseable date: "2020-12-aaaaaaa"
at java.base/java.text.DateFormat.parse(Unknown Source)
at Ex2.main(Ex2.java:26)
 * */
 */

上面这段程序的异常类型是ParseException类型，我们可以从parse函数的源码中知道为什么。

    public Date parse(String source) throws ParseException
    {
        ParsePosition pos = new ParsePosition(0);
        Date result = parse(source, pos);
        if (pos.index == 0)
            throw new ParseException("Unparseable date: "" + source + """ ,
                pos.errorIndex);
        return result;
    }

下面我们捕获一个ClassCastException异常；

public class Man {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
            //向上转换
			Man m1 = new Teacher();
			Student s1 = (Student)m1;
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		System.out.println("运行结束");
	}
}

/*
java.lang.ClassCastException: Teacher cannot be cast to Student
运行结束
	at Man.main(Man.java:12)
*/

public class Student extends  Man{

}

public class Teacher extends Man{

}

下面是一个ArrayIndexOutOfBoundsException异常，同样的还有字符串对应的IndexOutOfBoundsException（不演示了）；

public class Ex3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		try {
			int[] num = new int[3];
			num[4] = 2; 
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

}

//
//java.lang.ArrayIndexOutOfBoundsException: 4
//at Ex3.main(Ex3.java:9)

下面捕获一个输入异常InputMismatchException，如果我们输入了一个字符串，基本的情况如下；

import java.util.Scanner;

public class Ex4 {
	
	public int getInputNum() {
		Scanner s = new Scanner(System.in);
		return s.nextInt();
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Ex4 ex4 = new Ex4();
		
		System.out.println(ex4.getInputNum());

	}

}
/**
Exception in thread "main" java.util.InputMismatchException
	at java.base/java.util.Scanner.throwFor(Unknown Source)
	at java.base/java.util.Scanner.next(Unknown Source)
	at java.base/java.util.Scanner.nextInt(Unknown Source)
	at java.base/java.util.Scanner.nextInt(Unknown Source)
	at Ex4.getInputNum(Ex4.java:7)
	at Ex4.main(Ex4.java:14)
*/

我们想要让这段代码具有更高的容错率，如果我们输入了字符串或其他，应该让我们重复输入，直到我们输入了正确的int类型：

import java.util.Scanner;

public class Ex4 {
	
	public int getInputNum() {
		while (true) {
			try {
				System.out.println("请输入数字：");
				Scanner s = new Scanner(System.in);
				return s.nextInt();
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println("您的输入不是数字");
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ex4 ex4 = new Ex4();
		System.out.println(ex4.getInputNum());
	}

}

/**
请输入数字：
sen
您的输入不是数字
请输入数字：
12
12

*/

3. 异常的抛出

异常可以大致分为两类：编译时异常（显式异常）和运行时异常（隐式异常）

首先我们来看一个显式异常的例子：

这里的parseException是一个显式异常，必须在编译期处理，类似的还有SQLException和IOException

我们对于这种异常，必须在编写程序的时候添加抛出（throws ParseException），不然编译器就会爆红；

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Ex5 {

	public Date getDate(String sDate) throws ParseException {
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
		return simpleDateFormat.parse(sDate);
	}
	
	//parseException 显式异常，必须在编译期处理
	//类似的还有SQLException和IOException
	public static void main(String[] args) {
		
		Ex5 ex5 = new Ex5();
		try {
			System.out.println(ex5.getDate("2020-1-3"));
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

下面再来看一个隐式异常：

这里如果分母是0的话会出现异常，这种异常在编译期间是不处理的，编译期间不报错，如果不处理，一旦发生异常，就会造成程序的终止。

public class Ex6 {

	public int math(int a,int b) {
		return a/b;
	}
    
	/**
	 * 隐式异常（运行时异常）的处理
	 * 这种异常在编译期间是不处理的，编译期间不报错；
	 * 如果不处理，一旦发生异常，就会造成程序的终止
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ex6 ex6 = new Ex6();
		ex6.math(10, 0);
		System.out.println("all is ok");
	}
}

/**
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Ex6.math(Ex6.java:6)
	at Ex6.main(Ex6.java:17)
	*/

在处理异常的时候我们有两个关键字 throws和throw。

throws的用法就是在函数的方法名后面可以抛出异常，throw可以用来转换异常。

我们可以看出throw是动词，所以是一个转换的动作。

注意，异常的抛出和截获要保持一致。

这里利用throw把ParseException转换成IOException。（并没有什么用，仅仅为了演示用法）

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.imageio.IIOException;

public class Ex5 {
	
	public Date getDate(String sDate) throws IOException  {
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
		
		try {
			return simpleDateFormat.parse(sDate);
		} catch (ParseException e) {
			//利用throw把ParseException转换成IOException
            //同时，throws对应的异常也要改。
			throw new IOException();
		}
	}
	
	//parseException 显式异常，必须在编译期处理
	//类似的还有SQLException和IOException
	public static void main(String[] args) {
		
		Ex5 ex5 = new Ex5();
		try {
			System.out.println(ex5.getDate("AAA-1-3"));
            //异常的抛出和截获要保持一致。
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}
/**
java.io.IOException
at Ex5.getDate(Ex5.java:18)
at Ex5.main(Ex5.java:28)
*/

4. 自定义异常

我门可以通过继承Exception来自定义异常，自定义异常实际上是实际上用的最多的地方。

我门假设以下情况：

这里我们主要模拟这里的用户异常和系统异常。

首先先创建系统异常和用户异常两个异常类，继承与Exception。

package demo2;

//自定义异常--用户级异常
public class appException extends Exception{

	//	异常码和异常信息
	private int ErrorCode;
	private String ErrMessags;
	
	/**
	 * 有参数的构造器
	 * @param errorCode
	 * @param errMessags
	 */
	public appException(int errorCode, String errMessags) {
		super();
		ErrorCode = errorCode;
		ErrMessags = errMessags;
	}
	
	public int getErrorCode() {
		return ErrorCode;
	}
	public void setErrorCode(int errorCode) {
		ErrorCode = errorCode;
	}
	public String getErrMessags() {
		return ErrMessags;
	}
	public void setErrMessags(String errMessags) {
		ErrMessags = errMessags;
	}
}

package demo2;


//自定义异常--系统级异常
public class systemException extends Exception{
	//	异常码和异常信息
	private int ErrorCode;
	private String ErrMessags;
	
	/**
	 * 有参数的构造器
	 * @param errorCode
	 * @param errMessags
	 */
	public systemException(int errorCode, String errMessags) {
		super();
		ErrorCode = errorCode;
		ErrMessags = errMessags;
	}

	public int getErrorCode() {
		return ErrorCode;
	}
	public void setErrorCode(int errorCode) {
		ErrorCode = errorCode;
	}
	public String getErrMessags() {
		return ErrMessags;
	}
	public void setErrMessags(String errMessags) {
		ErrMessags = errMessags;
	}
}

随后我们模拟上图中的两种异常：

建立主函数来调用我们创建好的两个异常：

package demo2;

public class Ex8 {

	public int math(int a,int b) throws appException, systemException {
		try {
//			数组越界异常，利用系统异常抛出
			int[] nums = new int[3];
			nums[3] = 8;
//			数学运算异常，利用用户异常抛出
			return a/b;
		} catch (ArithmeticException e) {
			//转换成自定义异常为用户级异常；
			throw new appException(1001, "b不能为0！");
		}catch (IndexOutOfBoundsException e) {
			// TODO: handle exception
			throw new systemException(999, "系统异常！");
		}
		
	}
	public static void main(String[] args) {
		Ex8 ex8 = new Ex8();
		
		try {
			ex8.math(20, 0);
		} catch (appException e) {
			System.out.println(e.getErrMessags());
		}catch (systemException e) {
			System.out.println(e.getErrMessags());
		}
		System.out.println("finished!");
	}
}

//系统异常！
//finished!