java语言基础入门——异常处理

为什么要进行异常处理？在程序设计中，错误通常分为两类，一类编译错误，一类运行错误。编译错误很容易被发现，而运行错误比较难发现，而异常就是一种运行错误。如果不处理好异常很可能会使程序运行时出错崩溃。而异常也分为两种，受检异常和非受检异常。非受检异常是指像错误类型转换，数组越界等程序员的问题造成的，受检异常是指程序运行的外部原因造成的，比如，操作文件、和数据库连接时的异常，其中，受检异常要求必须处理，而非受检异常不强制要求处理，因为它本身是可以避免的。

java异常处理机制提供了try、catch、throw、throw、finally五个关键字对异常进行处理。

try为检测程序段中是否有异常存在，catch是将检测到异常与catch（）中的参数进行匹配，如果程序段中含有此类异常就进入catch程序段。像switch和case一样，catch可以有多个，并且程序只会进入第一个匹配到的catch程序段内，余下的catch将不再配对，因此一般将参数为子类的catch放前面，父类参数的catch放后面。 另外try和catch需要配套使用，并且这两个可以像if和else一样进行嵌套使用，并且是先处理内部try、catch再处理外部try、catch。

package try_catch;

public class TryDemo01 {

	public static void main(String[] args) {
		int number =0;
		try {
			number=Integer.parseInt(args[0]);
			System.out.println("正常");
			
		} catch (Exception e) {
			System.out.println("非正常");
		}
		System.out.println("您输入的数字为："+number);

	}

}

package try_catch;

public class NestTryDemo {

	public static void main(String[] args) {
	try {
		int number1=Integer.parseInt(args[0]);
		int number2=Integer.parseInt(args[1]);
		try {
			double result =number1/number2;
			System.out.println(result);
		} catch (Exception e) {
			System.out.println(e.getMessage());//返回返回异常愿意，如/by zero
		}finally{
			System.out.println("内层结束");
		}
	} catch (Exception e) {
		e.printStackTrace();//输出异常类型和原因，如：ArithmeticException:/by zero
	}finally{
		System.out.println("外层结束");
	}
	}

}

package try_catch;

import java.util.InputMismatchException;
import java.util.Scanner;

public class MoreCatchDemo {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		try {
			System.out.println("请输入第一学期总学时");
			int totalTime=in.nextInt();
			System.out.println("请输入第一学期课程数目");
			int totalCourse=in.nextInt();
			System.out.println("第一学期各位课程平均学时为："+totalTime/totalCourse);
		} catch (InputMismatchException e) {
			System.out.println("输入不为数字");
		}catch (ArithmeticException e) {
			System.out.println("输入科目不能为零");
		}catch (Exception e) {
			System.out.println("发生错误");
		}
		System.out.println("catch完结");

	}

}

throw和throws一般用来进行明确的抛出异常。其中throw语句用来明确的抛出一个异常，一般写于catch语句中，throw必须出现在函数体中，并且程序会在throw语句后立即终止，抛出一个Throwable的对象，后面的语句执行不到，并且在throw语句块内，throw语句后面不能再有语句出现。throws语句用来方法操作中，如果一个方法a可以引发异常，而它本身并不对该异常进行处理，而是抛出该异常给它的调用者，该调用者也可以继续向上抛出异常，直至被处理。其中throws可以抛出多个异常，在进行方法的定义时需要将这些可能出现的异常一一列举出来，并且用逗号分隔。在被throws定义的方法中可以使用throw，但是throws抛出类型要比throw类型范围要大。

package try_catch;

public class ThrowDemo {

	public static void main(String[] args) {
		int number=0;
		try {
			number=Integer.parseInt(args[0]);
		} catch (Exception e) {
			throw new ArrayIndexOutOfBoundsException("数组越界");
		   // System.out.println("throw后语句");
		}

		System.out.println("你输入的数字为："+number);
	}

}

package try_catch;

public class ThrowsDemo {

	public static void main(String[] args) {
		
       testThrows(args);
	}
	public static void  testThrows(String[] temp) {
		try {
			creatThrow(temp);
		} catch (Exception e) {
			System.out.println("来自createThrow方法的异常");
		}
	}
	public static void creatThrow(String[] temp)throws Exception {
		int number=0;
		number=Integer.parseInt(temp[0]);
		System.out.println("你输入的数字为："+number);
	}

}

package try_catch;

public class ThrowAndThrowsDemo {

	public static void main(String[] args) {
		testThrow(args);

	}

	public static void testThrow (String[] temp) {
		try {
			creatThrow(temp);
		} catch (Exception e) {
			System.out.println("捕捉到来自createThrow方法的异常");
		}
	}
	public static void creatThrow (String[] tmp)throws Exception {
		int number=0;
		try {
			number=Integer.parseInt(tmp[0]);
		} catch (Exception e) {
			throw new ArrayIndexOutOfBoundsException("数组越界");
		}
		System.out.println("你输入的数字为："+number);
	}
}

finally关键字主要用在try、catch后面，用来表示无论出现异常与否都会运行的程序段。且finally的代码段先于try的return语句运行，但是在finally中更改try要返回的值并不不起作用。

package try_catch;

public class FinallyDemo {

	public static void main(String[] args) {
		try {
			System.out.println("程序开始");
			int i=10/10;
			System.out.println("除零结束");
		} catch (Exception e) {
			System.out.println("除零出错");
			e.printStackTrace();//打印错误详情
		}
		finally{
			System.out.println("程序结束");
		}

	}

}

package try_catch;

import javax.management.RuntimeErrorException;

public class ReturnExceptionDemo {

	public static void  methonA() {
		try {
			System.out.println("进入方法A");
			throw new RuntimeException("制造异常A");
		} finally{
			System.out.println("A方法的finally");
		}
	}
	public static void   methonB() {
		int temp=2;
		int tempFinally=4;
		try {
			System.out.println("进入方法B");
			
			throw new RuntimeException("制造异常B");
			//return temp;
		} finally{
			temp=3; //并不能改变return temp的值，依然返回2
			System.out.println("B方法的finally");
			//return tempFinally; //使用return可以改变返回的值，使得返回值为4，
			//这是由于finally语句先于try中return语句执行，而一个函数只能执行一次return语句，
			//所以try语句块中return语句被屏蔽了
			
		}
		//return temp;//将return语句放于最后最为合理
	}
	public static void main(String[] args) {
		try {
			methonA();
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}

	//	System.out.println(methonB());
	}

}

getMessage方法和printStackrace 方法：getMessage用来返回出错原因，printStackTrace用来返回异常对象类型和出错原因。

自定义异常类，用户可以自己定义自己的异常类，只需要继承或间接继承Throwable类就可以了，一般选用Exception类作为父类。

package try_catch;

import commonly_class.string;

public class MyException extends Exception {

    public MyException(String string) {
		super(string);
	}
	public static void main(String[] args) {
		try {
			throw new MyException("自定义异常");
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}