IO流-异常的概述和分类

异常的概述和分类

package fun_01;

/*
 * 异常的概述和分类
 * 
 * 异常:程序出现了不正常的情况
 * 
 * 举例:今天天气很好,小明出去旅游。骑着自行车,去山里面呼吸新鲜空气。
 * 		问题1:山路塌陷了,小明及时停住了,但是过不去了。---严重的问题。
 * 		问题2:小明出门推自行车,发现气没了,把气打起来。---出发前就应该检查的问题。
 * 		问题3:小明骑着车在山路上惬意的行驶着,山路两边有小石子的,中间是平坦的水泥路。
 * 			一直在平坦的水泥路上行驶是没有任何问题的,但是呢,他偏偏喜欢骑到小石子上,结果爆胎了。---旅游的过程中出现的问题。
 * 
 * 程序的异常:Throwable
 * 		严重问题:Error 我们不处理。这种问题一般很严重,比如说内存溢出。
 * 		问题:Exception
 * 			编译期问题:不是RuntimeException的异常	必须进行处理的,因为你不处理,编译就不能通过。
 * 			运行期问题:RuntimeException 这种问题我们也不处理,因为是你的问题,而且这个问题出现肯定是我们代码不够严谨,需要修正代码的。
 */
public class ExceptionDemo {

}

JVM默认是如何处理异常的

package fun_01;

/*
 * JVM默认是如何处理异常的
 * 
 * 如果程序出现了问题,我们没有做任何处理,最终jvm会做出默认的处理。
 * 把异常的名称,原因及出现等信息输出在控制台。
 * 同时会结束程序。
 */
public class ExceptionDemo2 {
	public static void main(String[] args) {
		// 第一阶段
		int a = 10;
		// int b = 2;
		int b = 0;
		System.out.println(a / b);

		// 第二阶段
		System.out.println("over");
	}
}

 

try...catch的方式处理异常1

package fun_02;

/*
 * try...catch的方式处理异常1
 * 
 * 我们自已如何处理异常呢?
 * 		A:try...catch...finally
 * 		B:throws	抛出
 * 
 * try...catch...finally的处理格式:
 * 		try{
 * 			可能出理问题的代码;
 * 		}catch(异常名	变量){
 * 			针对问题的处理	
 * 		}finally{
 * 			释放资源;
 * 		}
 * 
 * 变形格式:
 * 		try{
 * 			可能出现问题的代码
 * 		}catch(异常名	变量){
 * 			针对问题的处理
 * 		}
 * 
 * 注意:
 * 		A:try里面的代码越少越好。
 * 		B:cathc里面必须有内容,那怕是给出一个简单的提示。
 */
public class ExceptionDemo {
	public static void main(String[] args) {
		// 第一阶段
		int a = 10;
		int b = 0;
		// System.out.println(a / b);
		try {
			System.out.println(a / b);
		} catch (ArithmeticException ae) {
			System.out.println("除数不能为零");
		}

		// 第二阶段
		// 处理异常可以看到"over"已经可以输出了
		System.out.println("over");
	}
}

try...catch的方式处理异常2

package fun_02;

/*
 * try...catch的方式处理异常2
 * 
 * A:一个异常 
 * 
 * B:两异常的处理
 * 		a:每一个写一个try...catch
 * 		b:写一个try,多个catch
 * 			try{
 * 				...
 * 			}catch(异常类名 变量名){
 * 				...
 * 			}catch(异常类名 变量名){
 * 				...
 * 			}
 * 			...
 * 
 * 			注意事项:
 * 				1.能明确的尽量明确,不要用大的来处理。
 * 				2.平级关系的异常谁前谁后无所谓,如果出现了子父关系,父必须在后面。
 * 注意:
 * 		一旦try里面出了问题,就会在这里把问题给抛出去,然后和catch里面的问题进行匹配,
 * 		一旦有匹配的,就执行catch里面的处理,然后结束了try...catch
 * 		继续执行后面的语句。
 */
public class ExceptionDemo2 {
	public static void main(String[] args) {
		// method1();

		// method2();

		// method3();

		method4();
	}

	public static void method4() {
		int a = 10;
		int b = 0;
		int[] arr = { 1, 2, 3 };

		// Exception在后面
		try {
			System.out.println(arr[3]);
			System.out.println(a / b);
		} catch (ArithmeticException e) {
			System.out.println("除数不能为0");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("数据越界");
		} catch (Exception e) {
			System.out.println("有问题");
		}

		// Exception在前面是不可以的
		// try {
		// System.out.println(arr[3]);
		// System.out.println(a / b);
		// } catch (Exception e) {
		// System.out.println("有问题");
		// } catch (ArithmeticException e) {
		// System.out.println("除数不能为0");
		// } catch (ArrayIndexOutOfBoundsException e) {
		// System.out.println("数据越界");
		// }

		System.out.println("over");
	}

	// 两个异常的处理
	public static void method3() {
		int a = 10;
		int b = 0;
		int[] arr = { 1, 2, 3 };
		try {
			System.out.println(a / b);
			System.out.println(arr[3]);
		} catch (ArithmeticException e) {
			System.out.println("除数不能为0");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("数据越界");
		}

		System.out.println("over");
	}

	// 两个异常
	public static void method2() {
		int a = 10;
		int b = 0;
		try {
			System.out.println(a / b);
		} catch (ArithmeticException e) {
			System.out.println("除数不能为0");
		}
		int[] arr = { 1, 2, 3 };

		try {
			System.out.println(arr[3]);
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("数据越界");
		}
		System.out.println("over");
	}

	// 一个异常
	public static void method1() {
		int a = 10;
		int b = 0;
		// System.out.println(a / b);
		try {
			System.out.println(a / b);
		} catch (ArithmeticException ae) {
			System.out.println("除数不能为零");
		}
		System.out.println("over");
	}
}

JDK7针对多个异常的处理方案

package fun_02;

/*
 * JDK7针对多个异常的处理方案
 *
 * JDK7出一了一个新的异常处理方案:
 * 		try{
 * 
 *  	catch(异常名1 |异常名2 | ... 变量){
 *  		...
 *  	}
 *  
 *  	注意:这个方式虽然简洁,但是也不够好。
 *  		A:处理方式是一致的。(在实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理)
 *  		B:多个异常间必须是平级关系。
 */
public class ExceptionDemo3 {
	public static void main(String[] args) {
		method();
	}

	public static void method() {
		int a = 10;
		int b = 0;
		int[] arr = { 1, 2, 3 };

		try {
			System.out.println(arr[3]);
			System.out.println(a / b);
		} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
			System.out.println("除数不能为0");
		} catch (Exception e) {
			System.out.println("有问题");
		}
	}
}

编译时的异常和运行时的异常的区别

package fun_03;

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

/*
 * 编译时的异常和运行时的异常的区别
 * 
 * 编译期异常:Java程序必须显示处理,否则程序就会发生错误,无法通过编译(必须处理)
 * 运行期异常:无需显示处理,也可以和编译时异常一样处理(可处理也不可处理)
 */
public class ExceptionDemo {
	public static void main(String[] args) {
		// int a = 10;
		// int b = 0;
		// if (b != 0) {
		// System.out.println(a / b);
		// }

		String s = "2017-01-16";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
		// Date date = sdf.parse(s);
		try {
			Date date = sdf.parse(s);
			System.out.println(date);
		} catch (ParseException e) {
			// e.printStackTrace();
			System.out.println("解析日期出问题了");
		}
	}
}

Throwable的几个常见方法

package fun_04;

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

/*
 * Throwable的几个常见方法
 * 
 * 在try里面发现问题后,jvm会帮我们生成一个异常对象,然后把这个对象抛出,和catch里面的类进行匹配。
 * 如果该对象是某个类型的,就会执行该catch里面的处理信息。
 * 
 * 异常中要了解的几个方法:
 * 		public String getMessage():异常的消息字符串
 * 		public String toString():返回异常的简单描述
 * 			此对象的类的name(全路径)
 * 			": "(冒号和一个空格)
 * 			调用此对象getLocalizedMessage()方法结果(默认返回的是getMessage()的内容)
 * printStackTrace()获取异常类名和异常信息,以及异常出现在程序的位置。返回值void。把信息输出在控制台。
 */
public class ExceptionDemo {
	public static void main(String[] args) {
		String s = "2017-01-16";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
		try {
			Date date = sdf.parse(s);// 创建了一个ParseException对象,然后抛出去,catch里面进行匹配
			System.out.println(date);
		} catch (ParseException e) {// ParseException e = new ParseException();
			// ParseException
			// e.printStackTrace();
			// System.out.println("解打日期出问题了");

			// getMessage();
			// System.out.println(e.getMessage());// Unparseable date:
			// "2017-01-16" (我不能解析这个日期)

			// toString()
			// System.out.println(e.toString());
			// java.text.ParseException: Unparseable date: "2017-01-16"
			e.printStackTrace();
		}
		System.out.println("over");

	}
}

throws的方式处理异常

package fun_05;

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

/*
 * throws的方式处理异常
 * 
 * 有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根本就没有权限去处理某个异常。
 * 或者说，我处理不了，我就不处理了。
 * 为了解决出错问题，Java针对这种情况，就提供了另一种处理方案：抛出。
 * 
 * 格式：
 * 		throws 异常类名
 * 		注意：这个格式必须跟在方法的括号后面。
 * 
 * 注意：
 * 		尽量不要在main方法上抛出异常。
 * 
 * 小结：
 * 		编译期异常抛出，将来调用者必须处理。
 * 		运行期异常抛出，将来调用可以不用处理。
 */
public class ExceptionDemo {
	public static void main(String[] args) {
		System.out.println("今天天气很好");
		try {
			method();
		} catch (ParseException e) {
			e.printStackTrace();
		}
		System.out.println("但是就是不该有雾霾");

		method2();
	}

	// 运行期异常的抛出
	public static void method2() throws ArithmeticException {
		int a = 10;
		int b = 0;
		System.out.println(a / b);
	}

	// 编译期异常的抛出
	// 在方法声明上抛出，是为了告诉调用者，你注意了，我有问题。
	public static void method() throws ParseException {
		String s = "2014-11-20";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse(s);
		System.out.println(d);
	}
}

throw的概述以及和throws的区别

package fun_06;

/*
 * throw的概述以及和throws的区别
 * 
 * throw:如果出现了异常情况,我们可以把该异常抛出,这个时候的抛出应该是异常的对象。
 * 
 * throws和throw的区别(面试题):
 * 		throws:
 * 			用在方法的声明后面,跟的是异常类名
 * 			可以跟多个异常类名,用逗号隔开
 * 			表示抛出异常,由该方法的调用者来处理
 * 			throws表示出现异常的一种可能性,并不一定会发生这种异常
 * 		throw:
 * 			用在方法体内,跟的是异常对象名
 * 			只能抛出一个对象异常名
 * 			表示抛出异常,由方法内的语句外理
 * 			throw则是抛出了异常,执行了throw则一定抛出了某种异常
 */
public class ExceptionDemo {
	public static void main(String[] args) {
		// method();
		method2();
	}

	public static void method() {
		int a = 10;
		int b = 0;
		if (b == 0) {
			throw new ArithmeticException("除数不能为0");
		} else {
			System.out.println(a / b);
		}
	}

	public static void method2() {
		int a = 10;
		int b = 0;
		if (b == 0) {
			throw new ArithmeticException("除数不能为0");
		} else {
			System.out.println(a / b);
		}
	}
}

到底如何处理异常呢

原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
区别:
	后续程序需要继续运行就try
	后续程序不需要继续运行就throws
举例:
	感冒了就自己吃点药就好了,try
	吃了好几天药都没好结果得了H7N9,那就的得throws到医院	
	如果医院没有特效药就变成Error了