黑马程序员 第一篇 Java 异常处理 (Foundation; completed)

——- android培训、java培训、期待与您交流！ ———-

Java 基础 异常处理

• 什么是异常处理
• 如何进行异常处理
• 异常的分类和区别不同的异常

• 自定义异常和使用自定义异常

  1. 异常处理基本介绍

1.1 try和catch捕获异常

try语句块主要用于可能会出现异常的区域，在try的后面会跟有一个或者多个catch语句块，在catch语句块中主要是编写相应异常的处理方法。

语法

try
{
    //此处是可能出现异常的代码
}
catch(Exception e)
{
    //此处是如果发生异常的处理代码
}

public class YiChang1
{
    public static void main(String args[])
    {
        try
        {
            int[] a = new int[5]; //定义一个长度为5的数组
            a[5] = 6;
        }
        catch(Exception e)
        {
            //发生异常时执行的语句
            System.out.println("该程序发生异常")；
        }
    }
}           

该代码会运行try语句时，由于并不存在a[5],所以发生异常，执行catch语句

1.2 try…catch 语句使用注意点

1. try…catch语句是对有可能发生异常的程序进行查看，如果没有发生异常，就不会执行catch语句中的内容.

2. 在程序中如果不适用try…catch语句，则当程序发生异常的时候，会自动退出程序的运行.

3. try…catch语句中catch语句可以不只是一个，可以存在多个catch语句来定义可能发生的多个异常。当处理任何一个异常时，则将不再执行其他catch语句.

public class YiChang2
{
    public static void main(String args[])
    {
        try
        {
            int[] a = new int[5];//定义一个长度为5的数组
            a[5]=6;              //为其中元素赋值
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            //发生数组下标越界异常时执行的语句
            System.out.println("该程序发生数组下标越界异常");
        }
        catch(Exception ee)
        {
            //发生异常时执行的语句
            System.out.println("该程序发生异常");
        }
    }
}

输出结果为：
该程序发生数组下标越界异常

代码解析：
第一个catch语句中ArrayIndexOutOfBoundsException就是数组下标异常，它是Exception异常的子类。
该程序执行第一段catch语句后，不执行第二段catch语句

• 当对程序使用多个catch语句进行异常处理时，特别需要注意的是要将范围相对小的异常放在前面，讲范围相对大的异常放在后面。以下示范一个错误的catch语句顺序。

public class YiChangeCatchOrder
{
    public static void main(String args[])
    {
        try
        {
            int[] a = new int[5];//定义一个长度为5的数组
            a[5]=6;              //为其中元素赋值
        }
        catch(Exception ee)
        {
            //发生异常时执行的语句
            System.out.println("该程序发生异常");
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            //发生数组下标越界异常时执行的语句
            System.out.println("该程序发生数组下标越界异常");
        }
    }
}

输出结果：
该程序发生异常
代码解析：
由于第一段catch语句将对所有异常进行处理，执行该catch语句后将不执行后面的catch语句。

1.3 finally 语句

finally 语句是无论程序中是否发生异常都会被执行的

语法

try
{
    //此处是可能出现异常的代码
}
catch（Exception e)
{
    //此处是如果发生异常的处理代码
}
finally
{
    //此处是肯定被执行的代码
}

可能会中断finally语句的情况

1. finally语句中本身就产生异常
2. 执行finally语句的线程死亡
3. 执行到finally语句时停电

1.4 异常处理注意点

try…catch…finally语句
1. try后面必须有catch语句或者finally语句，否则程序不能通过编译
2. try…catch…finally语句之间不能有其他语句执行

2.异常的分类

补充：
捕获异常
通常是由外部因素造成的，不是由程序造成的。例如连接网络等操作，这些是和很多因素有关系，可能并不是程序的错误。虽然这些错误并不是程序的错误，但也是必须要进行处理的。

未捕获异常
1. 包括Error类以及它的直接子类和间接子类
RuntimeException类以及它的直接子类和间接子类

1. Error类通常由硬件运行错误所导致的错误
   RuntimeException类通常是程序运行时引起的异常

3.抛出异常

3.1

定义：
当一个程序段发生异常时，如果自己不能够进行异常处理，就可以抛出异常给上一层。如果上一层也不能解决就可以一直向上抛出异常，直到抛出给main方法。如果仍然不能解决，就会中断程序，将异常显示出来。

public class YiChang3
{
    public static void main(String args[])
    {
        YiChang3 yc=new YiChang3();
        yc.a();
    }
    //在a方法中进行异常处理
    public void a()
    {
        try
        {
            b();
        }
        catch(Exception e)
        {
            System.out.println("在该处进行异常处理");
        }
    }
    //该方法没有进行异常处理，抛出异常给a方法
    public void b()
    {
        c();
    }
    //该方法没有进行异常处理，抛出异常给b方法
    public void c()
    {
        int[] a=new int[5];
        a[5]=6;
    }
}

运行结果：
    在该处进行异常处理

分析：
    说明该程序进行了try..catch语句的异常处理，使程序能正常运行。

3.2 使用throws和throw语句抛出异常

throws语句是在方法的声明中使用抛出异常，而throw语句是在方法体内使用抛出异常。

import java.net.*;
public class YiChange32
{
    //在main方法中使用throws语句声明该方法抛出IOException异常
    public static void main(String args[])throws IOException
    {
        try
        {
            //可能出现捕获异常的语句
            ServerSocket s=new ServerSocket(8080);
        }
        catch(IOException e)
        {
            //使用throw语句抛出该IOEexception异常
            throw e;
        }   
    }
}
运行结果：
    正常运行
分析：
    使用throw语句抛出catch IOException异常，并在main方法中使用throws语句声明该方法抛出IOException异常

4.自定义异常

4.1 创建和使用自定义异常类

创建自定义异常类需要继承Exception类。在class自定义的异常类中通过
具有一个无参构造器和一个带有字符串参数的有参构造器。定义异常类通
常充当捕获异常的角色，所以需要从Exception类或者其他的类继承，它
的基本格式如下

class 类名 extends Exception
{
    类体
}

以下演示一个最简单的自定义异常类

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


代码解析:
在该自定义异常类中定义了一个无参构造器和一个需要字符串类型的有参构造器，自定义的类继承Exception类，这是一个最简单的自定义异常类。


Tips:
在自定义的异常类中继承Exception类可以拥有以下方法
printStackTrace:可以显示异常调用栈的信息
getMessage: 可以得到异常对象的字符串表示
toString: 可以得到异常对象中携带的出错信息

以下是一个使用自定义异常类的程序


public class YiChang
{
    public static void main(String args[])
    {
        MyException me = new MyException("自定义异常类");
        System.out.println("自定义异常对象携带的错误信息为: "+me.getMessage());
        System.out.println("自定义异常的字符串表示为: "+me.toString()); 
    }
}

4.2 自定义异常的实际应用

例子
在百分制的考试当中，0到100的得分都是可能发生的，但是超出这个范围，则肯定是发生了错误。这里就可以使用自定义异常。

以下一个在实际应用中使用自定义异常的程序

public class YiChang
{
    public String deiFen(int fen)throws MyException
    {
        if(fen>=0&&fen<=100)
        {
            return "正常";
        }
        else
        {
            throw new MyException("错误输入");
        }
    }
    public static void main(String args[])
    {
        YiChang yc = new YiChang();
        try
        {
            String s = yc.deiFen(68);
            System.out.println(s);
            String ss = yc.deiFen(123);
            System.out.println(ss);
        }
        catch(MyException e)
        {
            System.out.println("异常信息为: "+e.getMessage());
        }
    }
}

——- android培训、java培训、期待与您交流！ ———-