1.0.0 Summary
Tittle：【Java】-NO.16.EBook.4.Java.1.010-【疯狂Java讲义第3版 李刚】- 异常
Style：EBook
Series：Java
Since：2017-09-29
End：....
Total Hours：...
Degree Of Diffculty：2
Degree Of Mastery：2
Practical Level：2
Desired Goal：2
Archieve Goal：....
Gerneral Evaluation：...
Writer:kingdelee
Related Links：
http://www.cnblogs.com/kingdelee/
1.异常
Check异常：编译阶段需要处理的异常（可以被修复的异常）。非RuntimeException及其子类的异常，都是Check异常。
Runtime异常：RuntimeException及其子类的异常，都是Runtime异常
1.2.catch之间是短路的，最多有且只有一个catch被执行，应从小到大依次写出。
1.3 捕获多个异常时的变量时，变量默认是final，捕获一个异常时，变量没有final
// 1 捕获多个异常时的变量时，变量默认是final，捕获一个异常时，变量没有final
public class MultiExceptionTest {
public static void main(String[] args) {
try {
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);
int c = a / b;
System.out.println("您输入的两个数相除的结果是：" + c);
} catch (IndexOutOfBoundsException | NumberFormatException
| ArithmeticException ie) {
System.out.println("程序发生了数组越界、数字格式异常、算术异常之一");
// 捕捉多异常时，异常变量默认有final修饰，
// 所以下面代码有错：
// ie = new ArithmeticException("test"); // ①
} catch (Exception e) {
System.out.println("未知异常");
// 捕捉一个类型的异常时，异常变量没有final修饰
// 所以下面代码完全正确。
e = new RuntimeException("test"); // ②
}
}
}
1.4 异常输出，可以是以一段流的方式输出异常跟踪信息，也可以是以一句字符串的信息输出异常描述信息
// 1.异常输出，可以是以一段流的方式输出异常跟踪信息，也可以是以一句字符串的信息输出异常描述信息
public class AccessExceptionMsg
{
public static void main(String[] args)
{
try
{
FileInputStream fis = new FileInputStream("a.txt");
}
catch (IOException ioe)
{
// 返回异常描述信息
// a.txt (系统找不到指定的文件。)
System.out.println(ioe.getMessage());
// 异常跟踪信息
// java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
// at java.io.FileInputStream.open0(Native Method)
// at java.io.FileInputStream.open(FileInputStream.java:195)
// at java.io.FileInputStream.<init>(FileInputStream.java:138)
// at java.io.FileInputStream.<init>(FileInputStream.java:93)
// at com.lee.test.java.ebook.crazy_java.u_10_exception.AccessExceptionMsg.main(AccessExceptionMsg.java:20)
ioe.printStackTrace();
}
}
}
1.5 try后面的catch（除非try里边的方法已经要throw了，所以要么跟着catch要么在方法中throw出去）、finally都是可选的。即，可以try接finally或者try接catch，但不能只单独写try。
// 1.try后面的catch（除非try里边的方法已经要throw了，所以要么跟着catch要么在方法中throw出去）、finally都是可选的。即，可以try接finally或者try接catch，但不能只单独写try。
public class AccessExceptionMsg2
{
public static void main(String[] args)
{
List list = null;
try
{
list.add(1);
}finally {
System.out.println(list);
}
}
}
1.6 catch中的return仅表示该方法在此短路，最后仍继续执行finally的方法，并返回finally中的return（如果有的话）
1.7 catch只有使用System.exit(1);才不会执行finally
// 1.catch中的return仅表示该方法在此短路，最后仍继续执行finally的方法，并返回finally中的return（如果有的话）
// 2.下面的例子中，更好的表明return即表示结束，也表示结束并返回某值
public class FinallyTest
{
public static void main(String[] args)
{
int a = t1();
System.out.println("a:" + a);
}
public static int t1(){
FileInputStream fis = null;
boolean b = true;
try
{
fis = new FileInputStream("a.txt");
}
catch (IOException ioe)
{
System.out.println(ioe.getMessage());
// return语句强制方法返回
b = false;
return 1; // ①
// 使用exit来退出虚拟机
// System.exit(1); // ②
}
finally
{
// 关闭磁盘文件，回收资源
if (fis != null)
{
try
{
fis.close();
}
catch (IOException ioe)
{
ioe.printStackTrace();
}
}
System.out.println("执行finally块里的资源回收!");
return 2;
}
// 编译失败
// System.out.println("111111");
// return 3;
}
}
1.8 异常要么处理，要么抛出给上一层调用者，若调用者依旧抛出，则直到main抛出被JVM捕获，输出异常，并中断程序
1.9 异常继承重写
1.重写方法的 两同两小一大 原则
1.1 两同：方法名相同 参数列表相同
1.2 两小：返回类型，异常 子类应比父类要小或者相同；
1.3 一大：修饰符 权限应该扩大或者相同
// 1.重写方法的 两同两小一大 原则
// 1.1 两同：方法名相同 参数列表相同
// 1.2 两小：返回类型，异常 子类应比父类要小或者相同；
// 1.3 一大：修饰符 权限应该扩大或者相同
class A{
A t1() throws Exception{
return new A();
}
}
class B extends A{
public B t1() throws IOException{
return new B();
}
}
1.10 抛出runtime异常，调用者可以不catch，但是程序一旦到达main之后就中断了
// 1.抛出check异常，调用者需要catch；抛出runtime异常，调用者可以不catch，但是程序一旦到达main之后就中断了
public class ThrowTest
{
public static void main(String[] args)
{
try
{
// 调用声明抛出Checked异常的方法，要么显式捕获该异常
// 要么在main方法中再次声明抛出
throwChecked(-3);
}
catch (Exception e)
{
System.out.println(e.getMessage());
}
// 调用声明抛出Runtime异常的方法既可以显式捕获该异常，
// 也可不理会该异常
throwRuntime(3);
System.out.println("aa");
}
public static void throwChecked(int a)throws Exception
{
if (a > 0)
{
// 自行抛出Exception异常
// 该代码必须处于try块里，或处于带throws声明的方法中
throw new Exception("a的值大于0，不符合要求");
}
}
public static void throwRuntime(int a)
{
if (a > 0)
{
// 自行抛出RuntimeException异常，既可以显式捕获该异常
// 也可完全不理会该异常，把该异常交给该方法调用者处理
throw new RuntimeException("a的值大于0，不符合要求");
}
}
}
//Exception in thread "main" java.lang.RuntimeException: a的值大于0，不符合要求
//at com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.ThrowTest.throwRuntime(ThrowTest.java:47)
//at com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.ThrowTest.main(ThrowTest.java:29)
1.11 自定义异常
public class MyException extends Exception {
public MyException() {
}
public MyException(String message) {
super(message);
}
}
1.12 catch and throw 企业对异常的使用 打印日志，在catch里将无法解决的异常抛出
// 1.企业打印异常的方式，将无法解决的异常抛出
public class AuctionTest {
private double initPrice = 30.0;
// 因为该方法中显式抛出了AuctionException异常，
// 所以此处需要声明抛出AuctionException异常
public void bid(String bidPrice) throws AuctionException {
double d = 0.0;
try {
d = Double.parseDouble(bidPrice);
} catch (Exception e) {
// 此处完成本方法中可以对异常执行的修复处理，
// 此处仅仅是在控制台打印异常跟踪栈信息。
e.printStackTrace();
// // 1.企业打印异常的方式，将无法解决的异常抛出
// 再次抛出自定义异常
throw new AuctionException("竞拍价必须是数值，" + "不能包含其他字符！");
}finally {
System.out.println("aaa");
}
if (initPrice > d) {
throw new AuctionException("竞拍价比起拍价低，" + "不允许竞拍！");
}
initPrice = d;
System.out.println("bbb");
}
public static void main(String[] args) {
AuctionTest at = new AuctionTest();
try {
at.bid("df");
} catch (AuctionException ae) {
// 再次捕捉到bid方法中的异常。并对该异常进行处理
System.err.println(ae.getMessage());
}
System.out.println("end");
}
}
//aaa
//end
//java.lang.NumberFormatException: For input string: "df"
//at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2043)
//at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
//at java.lang.Double.parseDouble(Double.java:538)
//at com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.AuctionTest.bid(AuctionTest.java:22)
//at com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.AuctionTest.main(AuctionTest.java:42)
//竞拍价必须是数值，不能包含其他字符！
1.13 throw异常检查机制，虽然 throw的是Exception异常，但是在try中会检测实际的异常，FileInputStream的异常是FileNotFoundException，只需要抛出这个即可
// 1.throw异常检查机制，虽然 throw的是Exception异常，但是在try中会检测实际的异常，FileInputStream的异常是FileNotFoundException，只需要抛出这个即可
public class ThrowTest2
{
public static void main(String[] args) throws FileNotFoundException
// Java 6认为①号代码可能抛出Exception，
// 所以此处声明抛出Exception
// throws Exception
// Java 7会检查①号代码可能抛出异常的实际类型，
// 因此此处只需声明抛出FileNotFoundException即可。
{
try
{
// new FileOutputStream("a.txt");
InputStream inputStream = new FileInputStream("aaa.txt");
}
catch (Exception ex)
{
ex.printStackTrace();
throw ex; // ①
}
}
}
1.14 一旦发生catch，都会中断try块内的代码不让其继续往下执行，但可以继续执行try之外的代码；在catch中出现throw，则直接中断catch所在的方法不让其继续往下执行
// 1. 一旦发生catch，都会中断try块内的代码不让其继续往下执行，但可以继续执行try之外的代码；在catch中出现throw，则直接中断catch所在的方法不让其继续往下执行
public class SalException extends Exception {
public SalException() {
}
public SalException(String msg) {
super(msg);
}
// 创建一个可以接受Throwable参数的构造器
public SalException(Throwable t) {
super(t);
}
public static void main(String[] args) {
try {
new A().t();
} catch (TooBigException e) {
System.out.println("1");
e.printStackTrace();
} catch (FileNotFoundException e) {
System.out.println("2");
e.printStackTrace();
} catch (Exception e){
System.out.println("3");
e.printStackTrace();
}
System.out.println("main");
}
}
class A {
public void tt(){
}
// 一旦发生catch，都会中断try块内的代码不让其继续往下执行，但可以继续执行try之外的代码；在catch中出现throw，则直接中断catch所在的方法不让其继续往下执行
public void t() throws TooBigException, FileNotFoundException {
try {
t1(); // t2 t3 t4都没机会执行
t2();
t3();
t4();
} catch (FileNotFoundException e) {
e.printStackTrace();
// throw e;
} catch (TooBigException e) {
e.printStackTrace();
// throw e;
}
System.out.println("aaaa");
}
public void t4(){
int [] a = {1, 2};
a[2] = 3;
}
private void t3() throws FileNotFoundException {
try {
FileReader fileReader = new FileReader("aa.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
throw e;
}
}
private void t2() {
String a = null;
try {
System.out.println(a.length());
} catch (NullException e) {
e.printStackTrace();
throw e;
}
}
public void t1() throws TooBigException {
int a = 10;
int b = 11;
if (b > a) {
throw new TooBigException(" b > a");
}
}
}
class FileException extends IOException{
public FileException() {
}
public FileException(String message) {
super(message);
System.err.println("file error");
}
public FileException(String message, Throwable cause) {
super(message, cause);
}
public FileException(Throwable cause) {
super(cause);
}
}
class NullException extends NullPointerException {
public NullException() {
}
public NullException(String s) {
super(s);
System.err.println("null~~~~~~~~~~");
}
}
class TooBigException extends Exception {
public TooBigException() {
}
public TooBigException(String message) {
super(message);
System.err.println("too big");
}
public TooBigException(String message, Throwable cause) {
super(message, cause);
}
public TooBigException(Throwable cause) {
super(cause);
}
public TooBigException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
//too big
//aaaa
//main
//com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.TooBigException: b > a
//at com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.A.t1(SalException.java:105)
//at com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.A.t(SalException.java:60)
//at com.lee.test.java.ebook.crazy_java.u_10_exception.c_10_4_runtimeexception.SalException.main(SalException.java:35)
1.15 避免使用catch all，Throwable会捕获所有的异常，因为是顶级类，不易区分异常
catch (Throwable a){
a.printStackTrace();
}