异常

1、

/*
 * 异常即是一种意外，是程序运行过程中产生的一种突发（意外）
 * 事件，该事件会干扰程序的正常执行，打破程序的正常流程。
 * 
 * 当异常产生时，会创建一个相关异常类的对象，该对象含有异常的
 * 相关信息。
 * 异常产生时，会在异常的上下文中寻找异常处理程序，如果没有
 * 异常处理程序，则异常产生之后的语句将不会得到执行。该异常
 * 会向上传播（传播给方法的调用端）。如果传播到main方法里，还
 * 未处理该异常，则main方法会将异常传播给JVM，此时，整个
 * 线程终止执行。在控制台会打印出异常的相关信息与堆栈的调用
 * 轨迹。该轨迹是按照方法调用的逆序打印，即离异常发生地最近
 * 的方法会最先打印。
 */
package day12;

public class ExceptionTest {
	public static void main(String[] args) {
		a();
	}

	public static void a() {
		b();
	}

	public static void b() {
		c();
	}

	public static void c() {
		int x = 5;
		int y = 0;
		int z = x / y;
		System.out.println("x除以y的结果是：");
		System.out.println(z);
	}
}

　　2、

异常可以分成以下三种：

      受检异常      运行时异常           错误

说明：运行时异常与错误统称为非受检异常。

当异常发生时，我可以采用两种方式进行处理：

 捕获异常

 抛出异常

说明：受检异常要求程序员在编译时显式处理，而非受检异常则不需要。

3、异常处理

/*
 * 异常处理程序（异常处理器）
 * try {
 * 		可能产生异常的程序
 * } catch (异常1) {
 * 		恢复措施
 * } catch (异常2) {
 * 		恢复措施
 * } ……
 * catch (异常n) {
 * 		恢复措施
 * }
 * 
 * try-catch的三种情况：
 * 1 try语句块中没有产生异常。此时try语句块全部执行完毕，
 * 之后执行try-catch之后的语句。
 * 2 try语句块中产生异常，catch捕获了该异常。
 * try中如果产生异常，则此时会创建一个相关异常类的对象，异常之后
 * 的语句将不会得到执行。程序会跳转到catch分支，从上到下依次使用
 * 异常类对象与每个catch中的异常类型进行匹配，哪一个catch分支
 * 匹配成功，则执行哪个catch语句块，此时异常被成功捕获。try-catch
 * 之后的语句正常执行。（最多只会执行一个catch分支）
 * 3 try语句块中产生异常，catch没有捕获该异常。
 * 当try中产生异常时，try异常之后的语句不会得到执行。程序
 * 跳转到catch分支进行异常匹配，没有匹配成功，则表示没有捕获
 * 该异常（该异常继续存在），则try-catch之后的语句不会得到
 * 执行，该异常会继续向上传播（传播给方法的调用端）。
 */
package day12;

public class Try {

	public static void main(String[] args) {
		try {
			int x = 1;
			// int y = 10;
			int y = 0;
			int z = x / y;
			// System.out.println(z);
			// String s = null;
			// s.length();
			// System.out.println("dd");
		} catch (ArithmeticException e) {
			// 打印异常错误的堆栈轨迹
			e.printStackTrace();
			// 打印异常的信息。
			// System.out.println(e.getMessage());
		}
		System.out.println("try-catch后的语句执行");
	}

}

　　4、finally

/*
 * try-catch-finally
 * try-catch语句块可以同时使用finally。
 * catch与finally都是可选的。但是二者不能同时缺失。
 * finally的特征：
 * 不管try是否产生异常，也不管catch是否捕获了try中产生
 * 的异常，finally都将会得到执行。
 * 因为finally总是会得到执行（虚拟机退出的情况例外），所以
 * 我们在finally语句块中进行资源的释放是非常合适的。
 * 
 * finally中的返回值会镇压try中的返回值。
 */
package day12;

public class Finally {
	public static void main(String[] args) {
		try {
			// System.out.println("没有产生异常");
			// String s = null;
			// s.length();
			// System.out.println(5 / 0);
			// 回收程序
		} catch (NullPointerException e) {
			// e.printStackTrace();
		} finally {
			// System.out.println("finally执行了");
		}

		// for (int i = 0; i < 10; i++) {
		// try {
		// break;
		// } finally {
		// System.out.println("finally执行了");
		// }
		// }
		// f();
		// try {
		// // 退出虚拟机
		// System.exit(0);
		// } finally {
		// System.out.println("finally执行了");
		// }
		System.out.println(g());
	}

	public static void f() {
		try {
			return;
		} finally {
			System.out.println("finally执行了");
		}
	}

	// 返回的是fianlly中的return值。
	public static int g() {
		try {
			return 1;
		} finally {
			return 2;
		}
	}
}

　　5、

/*
 * 捕获异常时，如果多个catch捕获的异常类型存在父子关系，
 * 则需要将子类型方法前面，父类型放在后面。因为子类型能够
 * 捕获的，父类型都能够捕获，如果父类型的catch放在前面，
 * 则子类型的catch永远没有机会得到执行。
 */
package day12;

public class CatchOrder {

	public static void main(String[] args) {
		try {

		} catch (NullPointerException e) {

		} catch (RuntimeException e) {

		} catch (Exception e) {

		}
		/*
		 * try {
		 * 
		 * } catch(Exception e) {
		 * 
		 * } catch (RuntimeException e) { //永远没有机会得到执行 }
		 */
	}

}

　　6、多重捕获异常

/*
 * 多重捕获异常
 * 
 * 当try语句块中，可能会产生多个异常，而多个异常的处理方式
 * 又完全相同时，我们就可以使用多重捕获异常。
 * 注意：不要使用多个异常的父类来代替多重捕获异常，因为父类
 * 会捕获更多的异常（我们意料之外的异常），这可能会隐藏掩盖
 * 我们程序的漏洞。
 * 
 * 当使用多重异常捕获时，catch捕获异常的参数将隐式使用final
 * 来修饰。
 */
package day12;

public class MultiCatch {

	public static void main(String[] args) {
		try {
			// 可能产生异常的代码
		} catch (ArithmeticException e) {
			e.printStackTrace();
		} catch (NullPointerException e) {
			e.printStackTrace();
		}
		// 多重捕获
		try {
			// String s = null;
			// s.length();
			// System.out.println(1 / 0);
		} catch (ArithmeticException | NullPointerException e) {
			e.printStackTrace();
			// e = null;
		}

		try {
			String s = null;
			s.length();
			// System.out.println(1 / 0);
		} catch (RuntimeException e) {
			e.printStackTrace();
		}
	}

}

　　7、throws 异常列表

/*
 * throws 异常列表
 * 
 * 如果一个方法中可能会抛出受检异常，则要求该异常必须
 * 同时声明在方法的异常列表中。对于非受检异常（运行时
 * 异常与错误），则不要求声明在方法的异常列表中。
 * 
 * 异常分为三种：
 * 1 受检异常（编译时异常）
 * 2 运行时异常
 * 3 错误
 * 运行时异常和错误统称为非受检异常。
 * 
 * 受检异常继承Exception类或其子类。
 * （不包括RuntimeException或其子类）
 * 运行时异常继承RuntimeException或其子类。
 * 错误继承Error类或其子类。
 * 
 * 受检异常与非受检异常的区别：
 * 受检异常必须在编译期间就需要明确对其进行处理，
 * 而非受检异常则不需要。
 */
package day12;

import java.io.FileNotFoundException;

public class Throws {

	public static void main(String[] args) {

	}

	public void f(int x, int y) throws FileNotFoundException {
		if (x < 0) {
			throw new NullPointerException();
		}

		if (y < 0) {
			throw new FileNotFoundException();
		}
	}

	// 该方法不会抛出FileNotFoundException（受检异常）
	public void g(int x) {
		// try {
		// if (x < 0) {
		// throw new FileNotFoundException();
		// }
		// } catch(FileNotFoundException e) { }
	}

}

　　8、方法重写的第五条

/*
 * 方法重写的第五条要求：
 * 子类重写父类的方法，则子类方法不能比父类方法抛出更多
 * 的受检异常。（只能与父类相同，或者是父类抛出受检异常的
 * 子类异常）。对于非受检异常，则不受限制。
 */
package day12;

public class Override5 {
	public static void main(String[] args) {
		Override5 o = new Override5();
		o.use(new WhiteHorse());
	}

	public void use(Horse h) {
		h.run();
	}

	/*
	 * public int x() { throw new NullPointerException(); }
	 */
}

class Horse {
	public void run() {

	}
}

class WhiteHorse extends Horse {
	// 错误，子类方法比父类方法抛出了更多的受检异常。
	/*
	 * @Override public void run() throws Exception {
	 * 
	 * }
	 */

	@Override
	public void run() throws NullPointerException, IllegalArgumentException {

	}
}

　　9、手动抛出异常

/*
 * 手动抛出异常 throw
 */
package day12;

public class Throw {
	public static void main(String[] args) {
		Throw t = new Throw();
		t.deal(-1);
		
	}

	public void deal(int age) {
		if (age <= 0) {
			throw new IllegalArgumentException("年龄必须大于0！输入年龄为：" + age);
		}
		System.out.println("执行了吗？");
		// 对年龄进行处理
	}
}

　　10、自定义异常

/*
 * 自定义异常
 * 为什么要使用自定义异常？
 * 1 Java类库提供的异常类不能满足所有人的需要。
 * 2 自定义异常可以令我们快速定位问题。
 * 
 * 按照惯例，自定义异常名使用Exception进行结尾。
 */
package day12;

public class SelfException {
	public void use() {
		SelfException s = new SelfException();
		//s.deal(-1);
		try {
			s.deal(-1);
		} catch (NegtiveAgeException e) {
			System.out.println("进行异常的处理");
		}
	}

	public void deal(int age) {
		if (age <= 0) {
			throw new NegtiveAgeException("年龄为负！" + age);
		}
		System.out.println("年龄合理，进行处理。");
	}
}

class NegtiveAgeException extends RuntimeException {
	public NegtiveAgeException(String s) {
		super(s);
	}

	public NegtiveAgeException() {
		this("年龄为负数，请输入核对！");
	}
}

　　11、异常优势：

使用异常具有如下优势：
 可以将正常的代码与异常处理的代码相分离。
 可以将异常信息沿着方法调用轨迹向上传播。
 异常具有明确的类型与继承体系， 便于分类处理。

　　补充：

1、捕获异常

使用try（尝试着）去执行可能产生异常的程序，一旦异常发
生，系统会自动创建一个相应的异常类对象，同时终止try的
执行（ try语句块异常产生位置之后的代码将不会执行）。
 一旦产生异常，将会从上到下去匹配catch中异常类，一旦匹
配成功，则异常对象就会传递给catch参数，执行相应catch
语句块。如果没有匹配成功，则该异常会继续向上抛出给方
法调用端。
 catch语句块最多只会执行一个。如果所有方法中都没有合适
的异常处理器，则当前线程终止。

无论try是否抛出异常，也无论catch是否捕获异常， finally
语句块都将在try或catch执行后执行。
 catch捕获的异常类型必须是Throwable类型或其子类型。
 finally是可选的。 catch也是可选的，但catch与finally不能
同时为空。

2、

常见异常：
1：非受检异常
NullPointerException,ClassCastException,ArrayIndexsOutOfBoundsException,ArithmeticException(算术异常，除0溢出)
2)受检：Exception,FileNotFoundException,IOException,SQLException.