Android异常处理——try、catch、finally、throw、throws_android try catch大异常exception-优快云博客

转：http://blog.youkuaiyun.com/yangzhaomuma/article/details/49985783

在代码的编写工作当中，我们会遇到很多有关错误处理的内容。
这个时候，你用的最多的应该是try-catch-finally，这样的句式。系统提供的这个句式极大方便我们的处理。我们可以抛出异常、抓取异常、显示异常到前端。但工作中我们大部分时候需要分工合作，因此规范的写法显得尤为重要，不然，后端很多异常处理不规范，将会导致前端人员抓瞎！
后端抛出异常、前端抓取异常，应该是我们基本的规范。
后端抛出的异常也应该有一个规范，比如，是否带返回码、带错误信息等；
先看一个图,这是我在网上载的一个throwable超类关系图：
这里写图片描述
说明：Throwable是一个超类，我们所有的异常类都是它的子类。这里列出了它们的关系图。
1、Error是Java中所有错误的基类。错误通常是我们无法处理的，绝大多数情况下，我们不应该试图捕获错误。因此这里不再做详细说明。
2、Exception是java中所有异常的基类。这就是我们常用到的了。
如何处理异常，就与我们标题列出的关键字相关了：
try-catch-finally：这是用于捕获异常；
throw、throws：这是用于抛出异常，区别在于throw是在语句中抛出、throws是在方法体抛出；
以下，我们模拟日常中出现异常，如何处理：
先看一组简单代码，如下：

package com.example.trycatchthrow_csdn;

import java.io.FileNotFoundException;

import android.os.Bundle;
import android.widget.Toast;
import android.app.Activity;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        last();
    }
/**
 * 生成并抛出异常
 * @throws FileNotFoundException    无法找到文件
 * @throws ClassNotFoundException  无法找到类
 */
    public void first() throws FileNotFoundException, ClassNotFoundException 
    {
            int i=0;
            if(i==0)
            {
            throw new ClassNotFoundException();
            }
            else  if(i==1)
            {
                throw new FileNotFoundException();
            }

    }
/**
 * 调用带有异常的方法first
 * @throws FileNotFoundException
 * @throws ClassNotFoundException
 */
    public void second() throws FileNotFoundException, ClassNotFoundException
    {
        try {
            first();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new FileNotFoundException("FileNotFoundException");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new ClassNotFoundException("ClassNotFoundException");
        }

    }
    /**
     * 调用second，并处理异常
     */
    public void last()
    {
        try {
            second();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

            Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_LONG).show();
            return;
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_LONG).show();
            return;
        }
        finally
        {
            Toast.makeText(MainActivity.this, "finally", Toast.LENGTH_LONG).show();
        }
    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

代码中我们在first方法中简单的生成了异常，second方法调用first方法，last方法调用second方法。
1、first方法：这里有两个关键字throw、throws。当你用在语句中抛出异常（throw xxx）的时候，在方法体上需要加上throws的说明，这是标准的写法，用于抛出异常。当其他方法调用first方法时，需要处理该异常；
2、second方法：这里有四个关键字try、catch、throw、throws。second方法调用了first方法，那么它就需要处理first方法中抛出的异常。所有这里需要用到try、catch。但second方法本身并不想处理这个异常，它继续抛出异常到上层，让其他方法在调用second方法时，处理。所以，在catch中，它继续抛出异常，在方法体加上了throws声明。
这里有个地方需要注意：

throw new FileNotFoundException("FileNotFoundException");
 
 1
 
 1

我们这么写的目的是：当该异常抛出时，调用该方法的时候，try-catch时，能拿具体的异常信息。
在该处还有一种写法：

throw e;
 
 1
 
 1

当这么写时，调用该方法的时候用try-catch，在getmessage()时，得到的是null。
因此，推荐第一种写法。
3、last方法：有关键字try-catch-finally。这个方法时我们最终调用的方法，它处理了我们抛出的异常，并显示在前端。
在该方法中有两个地方我们需要注意：
（1）看我们代码中，在catch后，都添加了return。但实际运行你会发现，在finally的toast执行后，才会return。
（2）在写catch语句时，请按异常子类->到父类，这种格式来写。不然，父类异常将覆盖子类异常。
以下是错误写法：

    try {
            second();
        }
        catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } 
        catch (ClassNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
 
 1
2
3
4
5
6
7
8
9
10
11
 
 1
2
3
4
5
6
7
8
9
10
11

还有另一种写法也不建议使用，当我们再second方法中定义好两个细分的异常，并抛出时，在last中这么写：

   try {
            second();
        } catch (Exception e) {
            // TODO: handle exception
        }
 
 1
2
3
4
5
 
 1
2
3
4
5

这样就无法具体看出我们抛出的异常是哪个。

以上，我们介绍了try、catch、finally、throw、throws这几个关键字，以及它们的组合使用。当团队分工编码时，定好规范很重要，可以减少后续的许多错误。
还有一种面向过程的异常处理，即自定义类，包含错误码、错误信息。这个也是一种很好的方法。