JAVA学习笔记(十九)- 异常

常见异常

/*
 * 常见异常
 */
public class Test02
{
    public static void main(String[] args)
    {
        // 算术异常
        int a = 10;
        int b = 0;
        System.out.println(a / b);*/

        //数组下标越界异常
        int[] nums={13,25,38};
        System.out.println(nums[-5]);
        for(int i=0;i<=nums.length;i++){
            System.out.println(nums[i]);
        }*/

        //空指针异常
        String name=null;
        if(name.equals("tom")){
            System.out.println("用户名正确!");
        }

        System.out.println("异常后的代码不会被执行");
    }
}

try..catch捕获并处理异常

/*
 * 捕获并处理异常
 * try..catch语句块
 * try语句块用于存放可能会出现异常的代码
 * catch语句块用于捕获异常并处理
 * finally语句块，不管程序运行是否出现异常，代码始终会被执行
 * 
 * 异常结构类型：
 * try..catch
 * try..finally
 * try..catch..finally
 */
public class Test03
{
    public static void main(String[] args)
    {
        test01();
    }

    public static void test01()
    {
        int[] nums = { 13, 25, 38, 4, 98 };
        int a = 5, b = 0;
        try
        {// 将可能出现异常的代码放在try语句块中,try语句块不能单独出现
            //int c = a / b;// 此处出现异常，异常后的代码压根就不会执行
            for (int i = 0; i < nums.length; i++)
            {
                System.out.println(nums[i]);
            }
            System.exit(0);//关闭JVM
            //return;
        } catch (ArrayIndexOutOfBoundsException e)
        { // 小括号中指定要捕获的异常对象
            System.out.println("亲，数组下标越界啦。。。。");
            e.printStackTrace();// 打印详细的异常住处
            System.out.println(e.getMessage());
        } catch (ArithmeticException e)
        {
            System.out.println("亲，出现算术异常啦。。。。");
            e.printStackTrace();
        } finally
        { // 始终被执行的代码应该放到finally代码块中，finally语句块是可选的
            System.out.println("无论如何都希望执行的代码！");
        }

        // 对异常进行捕获处理后，代码继续执行
        System.out.println("异常后的代码块");

        // Check Exception，必须捕获并处理此类异常
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try
        {
            Date date = sdf.parse("2014年3月15号");// ParseException属性Check
                                                // Exception
        } catch (ParseException e)
        {
            System.out.println("字符串格式不正确！");
        }
    }

    public static void test02()
    {
        int[] nums = { 13, 25, 38, 4, 98 };
        try
        {
            for (int i = 0; i <= nums.length; i++)
            {
                System.out.println(nums[i]);
            }
        } finally
        {
            System.out.println("始终被执行的代码");
        }

        System.out.println("最后的代码");
    }

捕获多种异常

/*
 * 捕获多种异常
 * catch语句块可能有多个，用来捕获不同类型的异常
 * 
 * 多个catch捕获不同异常时需要注意顺序，将范围小的异常放在最前面
 */

public class Test04
{
    public static void main(String[] args)
    {
        int[] nums = { 13, 25, 38, 4, 98 };
        try
        {
            for (int i = 0; i < nums.length; i++)
            {
                System.out.println(nums[i]);
            }

            String name = "tom";
            if (name.equals("tom"))
            {
                System.out.println("用户名正确！");
            } else
            {
                System.out.println("用户名不正确！");
            }

            int a = 5, b = 0;
            // int c = a / b;

            FileInputStream fis = new FileInputStream("e:\\sx.txt");
            fis.read();

        } catch (ArrayIndexOutOfBoundsException e)
        {
            System.out.println("出现数组下标越界异常。。。。。");
        } catch (NullPointerException e)
        {
            System.out.println("出现了空指针异常。。。。。");
        } catch (ArithmeticException e)
        {
            System.out.println("出现算术异常。。。。。");
        } catch (Exception e)
        {
            System.out.println("出现异常。。。。。");
        }finally{
            System.out.println("始终会被执行的代码块");
        }

        System.out.println("最后的代码。。。");
    }
}

throw和throws异常处理

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
 * throw和throws
 * 
 * 异常处理方式：
 * 1.自行处理异常try...catch...finally
 * 2.抛出异常
 */
public class Test05
{
    public static void main(String[] args) throws ParseException
    {
        //calc(5,0);//如果方法抛出check Exception，则调用者必须处理此异常
        //System.out.println("。。。。。。");

        convertDate("12-4-2013");
    }

    /*
     * 使用throw手动抛出异常
     * 使用throws声明方法会抛出异常，即告诉调用者，要对方法的异常进行处理
     */
    public static void calc(int num1, int num2) throws Exception 
    {
        //方式一：自行处理异常
        /*try{
            double result = num1 / num2;
            System.out.println(result);
        }catch(ArithmeticException e){
            System.out.println("出现算术异常");
        }*/

        //方式二：抛出异常
        if(num2==0){
            ArithmeticException ae=new ArithmeticException();
            throw ae;//手动抛出异常
        }else{
            double result = num1 / (double)num2;
            System.out.println(result);
        }
    }

    /*
     * 将字符串转换为日期
     * 如果自己不想处理异常，可以为方法声明抛出异常，将异常的处理交由方法的调用者来处理
     */
    public static Date convertDate(String str) throws ParseException{
        SimpleDateFormat sdf=new SimpleDateFormat("dd-MM-yyyy");
        return sdf.parse(str);
    }
}

自定义异常类

/*
 * 自定义异常类
 */
public class Test06
{
    public static void main(String[] args)
    {
        try
        {
            show(200);
        } catch (MyExp e)
        {
            e.printStackTrace();
        }
    }

    // 声明方法可能会抛出异常
    public static void show(int age) throws MyExp
    {
        if (age < 0 || age > 100)
        {
            throw new MyExp("年龄错误异常！");// 手动抛出异常
        } else
        {
            System.out.println(age);
        }
    }
}

/*
 * 自定义异常类，继承自Exception或其子类
 */
class MyExp extends Exception
{
    public MyExp(String msg)
    {
        super(msg);
    }
}

嵌套的异常处理

/*
 * 嵌套的异常处理
 * 一个异常只能被捕获处理一次
 */
public class Test07
{
    public static void main(String[] args)
    {
        Test test = new Test();
        try
        {
            try
            {
                test.fun1();
                test.fun2();
            } catch (Exception e)
            {
                System.out.println("异常2的处理");
                e.printStackTrace();
            } finally
            {
                System.out.println("异常2的finally");
            }
        } catch (Exception e)
        {
            System.out.println("异常1的处理");
            e.printStackTrace();
        } finally
        {
            System.out.println("异常1的finally");
        }
    }
}

/*
 * 自定义异常MyExp1
 */
class MyExp1 extends Exception
{
    public MyExp1(String msg)
    {
        super(msg);
    }
}

/*
 * 自定义异常MyExp2
 */
class MyExp2 extends Exception
{
    public MyExp2(String msg)
    {
        super(msg);
    }
}

class Test
{
    public void fun1() throws MyExp1
    {
        throw new MyExp1("出现异常1");
    }

    public void fun2() throws MyExp2
    {
        throw new MyExp2("出现异常2");
    }
}

重写和异常

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

/*
 * 重写和异常
 * 
 */
public class Test08
{

}

class A
{
    public void test1()
    {
        System.out.println("a");
    }
}

class B extends A
{
    public void test1(){
        try
        {
            new SimpleDateFormat().parse("aaa");
        } catch (ParseException e)
        {
            e.printStackTrace();
        }
    }
}

方法逐层调用，异常的处理

/*
 * 方法逐层调用，异常的处理
 */
public class Test09
{
    public void f1(int num) throws MyExp
    {
        System.out.println("方法f1的front");
        if (num < 0)
        {
            throw new MyExp("数据小于0异常!");
        }
        System.out.println("方法f1的back");
    }

    public void f2(int num) throws MyExp
    {
        System.out.println("方法f2的front");
        f1(num);
        System.out.println("方法f2的back");
    }

    public void f3(int num) throws MyExp
    {
        System.out.println("方法f3的front");
        f2(num);
        System.out.println("方法f3的back");
    }

    public void f4(int num)
    {
        System.out.println("方法f4的front");
        try
        {
            f3(num);
        } catch (MyExp e)
        {
            System.out.println("方法f4的catch");
            e.printStackTrace();
        } finally
        {
            System.out.println("方法f4的finally");
        }
        System.out.println("方法f4的back");
    }

    public void f5(int num)
    {
        System.out.println("方法f5的front");
        f4(num);
        System.out.println("方法f5的back");
    }

    public static void main(String[] args)
    {
        Test09 test = new Test09();
        test.f5(-10);
    }
}