java系列笔记---异常

异常

一.异常与错误的区别

     再讲异常之前我们就应该要知道异常和错误的区别

     Error类和Exception类的父类都是throwable类，他们的区别是：

     Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，

仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。

    Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

二.异常的体现分类：

   1.checked 异常检查期异常 java.lang.Excetion 在编译期需要人工处理否则编译失败：Exception的子类除了运行期异常都是检查期异常

   2.非Checked异常运行时异常 java.lang.RuntimeException 不需要处理的直接能编译通过：所有的RuntimeException以及其子类都是运行异常

   举例：运行期异常

    结果：运行期异常，当你敲好代码时不会报错，而当你运行时才会报除数不能为0的错误

   举例：检查期异常：

   结果：检查期异常，当你编译的时候就会报错，一定要抛出异常编译才能通过

 三.异常的处理机制

      Java语言主要依赖于 try  catch  finally  和throws  throw  五个关键字来描述异常

 1） 在发生异常的地方直接处理

    使用try catch finally  直接处理异常

     a)  try-catch-finally结构中try块是必须有的，catch和finally块为可选，但两者至少必须出现其中之一。

     b) catch  可以同时出现多个，但一个异常最多捕获一个catch，而且catch的顺序是从上往下

     c) finally  无论是否捕获异常都会执行的一行代码

演示1：try异常

 1 public class TestException {
 2         public static void main(String[] args) {
 3              int c = 0;
 4                 try
 5                 {
 6                     int a = 3;
 7                     int b = 0;
 8                     // 这块代码出现了异常
 9                      c = a / b;
10                     // 那么异常之后的代码都不会被执行
11                     System.out.println("Hello World");
12                 }
13                 catch (ArithmeticException e)
14                 {
15                     System.out.println("除数不能为零");
16                 }
17                 finally
18                 {
19                     //不管有没有发生异常，finally语句块都会被执行
20                     System.out.println("Welcome");
21                 }
22                 System.out.println(c);
23                 // 当b为0时，有异常，输出为c的初始值0
24         }
25     }
26    //输出结果：除数不能为零  Welcome   0

try异常

演示2：带有return的异常

 1 import java.io.FileInputStream;
 2 import java.io.FileNotFoundException;
 3  public class DemoException {
 4      public static void main(String[] args) {
 5             int a=test3();
 6             System.out.println(a);    
 7   }
 8      @SuppressWarnings("finally")
 9      public static int  test3(){
10              try {
11              System.out.println(9 / 0);
12              return 1;
13              } catch (Exception e) {
14                System.out.println("呵呵");
15                 return 2;
16             }finally{  
17              System.out.println("哈哈");
18              return 3;
19        }
20     }
21  }
22  //输出结果 "呵呵""哈哈" 3

 

得出结论：作用范围   return  终止整个方法体，但在finally出现之前  return是老大  finally 作用范围> return

2）将异常抛给调用者让调用者处理 

1   //throws在方法体头部通过声明  抛出异常...
2     public void dealFile() throws FileNotFoundException{
3         FileInputStream fis =new FileInputStream("C:/name.txt");
4      }
5    //那么那么上面调用这个方法可以选择是继续抛出，还是捕获异常

案例一：通过throws抛出异常，调用者直接捕获抛出的异常

 1 public class TestException {
 2      public static void main(String[] args) {
 3                  try {
 4                       Test3();  //这里选择直接捕获异常，而不是在抛出异常
 5                  } catch (NumberFormatException e) {
 6                      System.err.println("非数据类型不能转换。");
 7                 } //System.err.println();这种输出方式可以输出错误的消息，在控制台呈现红色。
 8            }
 9        
10             public static void Test3() throws NumberFormatException{  
11                  String s = "abc";  
12                 System.out.println(Double.parseDouble(s));  
13              }  
14     }

throws异常

运行结果：

   非数据类型不能转换。

注意：使用Throws是的限制

两小原则

 使用throws 声明抛出异常一个限制

 子类继承父类重写父类的方法

 子类抛出的异常必须比父类少

 子类抛出的异常必须比父类小

 两小原则是针对检查期异常的，运行期异常不遵循这个规则(RuntimeException 以及子类)

案例二：通过throw抛出异常

 1 public class TestException {
 2      public static void main(String[] args) {
 3          String s = "abc";  
 4                if(s.equals("abc")) {  
 5                      throw new NumberFormatException("不能相等");
 6                  } else {  
 7                      System.out.println(s);  
 8                 }  
 9              }  
10     }

throw异常

运行结果如下：

面试题：Throw 和Throws有什么区别？

 Throw语句是用在方法体内表示抛出的异常由方法体内的语句处理

 Throws  语句是在方法声明之后抛出异常表示在抛出的异常交给调用者处理

 Throws 要么使用try –catch –finally 处理要么继续抛出

 四.自定义异常 

   所谓自定义异常，通常就是定义一个类，去继承Exception类或者它的子类。因为异常必须直接或者间接地继承自Exception类。

　　通常情况下，会直接继承自Exception类，一般不会继承某个运行时的异常类。

　　自定义异常可以用于处理用户登录错误，用户输入错误提示等。

   自定义异常需要遵循以下步骤

1. 继承RuntimeExcetion  或者Exception
2. 写一个无参的构造函数
3. 写一个String类型的构造函数

 举例：自定义异常：

public class MyException extends Exception
{
    public MyException()
    {
        super();
    }    
    public MyException(String message)
    {
        super(message);
    }
}

一种处理异常方式

public class ExceptionTest4
{

    public void method(String str) throws MyException
    {
        if(null == str)
        {
            throw new MyException("传入的字符串参数不能为null！");
        }
        else
        {
            System.out.println(str);
        }
    }
    public static void main(String[] args) throws MyException //异常处理方式1，不断向外抛出
    {
        ExceptionTest4 test = new ExceptionTest4();
        test.method(null);
    }
}

另一种异常处理方式：

 1 public class ExceptionTest4
 2 {
 3 
 4     public void method(String str) throws MyException
 5     {
 6         if (null == str)
 7         {
 8             throw new MyException("传入的字符串参数不能为null！");
 9         }
10         else
11         {
12             System.out.println(str);
13         }
14     }
15 
16     public static void main(String[] args)
17     {
18         //异常处理方式2，采用try...catch语句
19         try
20         {
21             ExceptionTest4 test = new ExceptionTest4();
22             test.method(null);
23 
24         }
25         catch (MyException e)
26         {
27             e.printStackTrace();
28         }    
29         finally
30         {
31             System.out.println("程序处理完毕");
32         }
33 
34     }
35 }

最后说一句，try-catch-finally虽好用，但是如果是滥用，这样只是会让程序的可读性变的很糟糕，当程序报错，就无法快速准确的定位了。

如果有个别地方写的不到位或者不够完善希望大家多多指点，看了有不明白的地方也可以留言，我也会尽快帮助解答。