异常的处理

一、异常：不可预知的非正常情况
Java中的异常都是以对象的形式存在，一旦某句代码发生异常，
会在该代码处生成一个异常对象，以堆栈形式抛出，若不对其处理，最终会导致程序终止

 

二、异常的体系结构
java.lang.Throwable :所有错误和异常的父类
/--java.lang.Error :错误，一些严重的错误。如:内存溢出、系统错误等。我们在代码中不进行处理
/--java.lang.Exception :异常，我们应该尽可能预知并处理的异常。如:用户输入不匹配、网络连接中断等。
                        /--编译时异常(受检异常 checked):编译时对其进行检查，若不处理，编译不能通过。
                        /--运行时异常(非受检异常unchecked):有时可以保证程序的正常运行，一旦发生异常，会在该代码处生成一个异常对象
                                                          然后以堆栈式抛出，若不对其进行处理，最终导致程序终止运行。

 

/*
一、异常：不可预知的非正常情况
Java中的异常都是以对象的形式存在，一旦某句代码发生异常，
会在该代码处生成一个异常对象，以堆栈形式抛出，若不对其处理，最终会导致程序终止
二、异常的体系结构
java.lang.Throwable :所有错误和异常的父类
/--java.lang.Error :错误，一些严重的错误。如:内存溢出、系统错误等。我们在代码中不进行处理
/--java.lang.Exception :异常，我们应该尽可能预知并处理的异常。如:用户输入不匹配、网络连接中断等。
                        /--编译时异常(受检异常 checked):编译时对其进行检查，若不处理，编译不能通过。
                        /--运行时异常(非受检异常unchecked):有时可以保证程序的正常运行，一旦发生异常，会在该代码处生成一个异常对象
                                                          然后以堆栈式抛出，若不对其进行处理，最终导致程序终止运行。


 */
public class ExceptionTest {
    public static void main(String[] args) {
        // ------Error----------
               //java.lang.stackoverflowError
                // main(args);
        //java.lang.outOfMemoryError
        //byte[] bs = new byte[Integer.MAX_VALUE];
       /* List list = new ArrayList();
        int i = 0;
        while(true) {
            list.add(new byte[1024]);
            System.out.println(i++);
            }*/

        //----------Exception-----------
        //----------编译时异常-----------
        }
}

/*
一、异常：不可预知的非正常情况
Java中的异常都是以对象的形式存在，一旦某句代码发生异常，
会在该代码处生成一个异常对象，以堆栈形式抛出，若不对其处理，最终会导致程序终止
二、异常的体系结构
java.lang.Throwable :所有错误和异常的父类
/--java.lang.Error :错误，一些严重的错误。如:内存溢出、系统错误等。我们在代码中不进行处理
/--java.lang.Exception :异常，我们应该尽可能预知并处理的异常。如:用户输入不匹配、网络连接中断等。
                        /--编译时异常(受检异常 checked):编译时对其进行检查，若不处理，编译不能通过。
                        /--运行时异常(非受检异常unchecked):有时可以保证程序的正常运行，一旦发生异常，会在该代码处生成一个异常对象
                                                          然后以堆栈式抛出，若不对其进行处理，最终导致程序终止运行。


 */
public class ExceptionTest {
    public static void main(String[] args) {
        // ------Error----------
               //java.lang.stackoverflowError
                // main(args);
        //java.lang.outOfMemoryError
        //byte[] bs = new byte[Integer.MAX_VALUE];
       /* List list = new ArrayList();
        int i = 0;
        while(true) {
            list.add(new byte[1024]);
            System.out.println(i++);
            }*/

        //----------Exception-----------
        //----------编译时异常-----------
       /* FileInputStream fis = new FileInputStream("");
        fis.read();
        fis.close();*/

        //----------运行时异常-----------

        //java.lang.NullPointerException

        Customer[] custs = new Customer[5];//{new Customer( )， new Customer(), null， null，nuLl}
        custs[0] = new Customer( );
        custs[1] = new Customer();
        for (int i = 0; i < custs.length; i++) {
            System.out.println(custs[i].say());
        }
//            Customer customer=null;
//        customer.say();

        //java.util.InputMismatchException
        /*Scanner scanner=new Scanner(System.in);
        System.out.println("请输入整数:");
        int num= scanner.nextInt();
        System.out.println(num);*/
        System.out.println("一个功能模块");

    }
}

/*
一、异常：不可预知的非正常情况
Java中的异常都是以对象的形式存在，一旦某句代码发生异常，
会在该代码处生成一个异常对象，以堆栈形式抛出，若不对其处理，最终会导致程序终止
二、异常的体系结构
java.lang.Throwable :所有错误和异常的父类
/--java.lang.Error :错误，一些严重的错误。如:内存溢出、系统错误等。我们在代码中不进行处理
/--java.lang.Exception :异常，我们应该尽可能预知并处理的异常。如:用户输入不匹配、网络连接中断等。
                        /--编译时异常(受检异常 checked):编译时对其进行检查，若不处理，编译不能通过。
                        /--运行时异常(非受检异常unchecked):有时可以保证程序的正常运行，一旦发生异常，会在该代码处生成一个异常对象
                                                          然后以堆栈式抛出，若不对其进行处理，最终导致程序终止运行。


 */
public class ExceptionTest {
    public static void main(String[] args) {
        // ------Error----------
               //java.lang.stackoverflowError
                // main(args);
        //java.lang.outOfMemoryError
        //byte[] bs = new byte[Integer.MAX_VALUE];
       /* List list = new ArrayList();
        int i = 0;
        while(true) {
            list.add(new byte[1024]);
            System.out.println(i++);
            }*/

        //----------Exception-----------
        //----------编译时异常-----------
       /* FileInputStream fis = new FileInputStream("");
        fis.read();
        fis.close();*/

        //----------运行时异常-----------

        //java.lang.ArrayIndexOutOfBoundsException
        /*int[] array=new int[5];
        array[6]=10;*/


        //java.lang.NullPointerException
        /*Customer[] custs = new Customer[5];//{new Customer( )， new Customer(), null， null，null}
        custs[0] = new Customer( );
        custs[1] = new Customer();
        for (int i = 0; i < custs.length; i++) {
            System.out.println(custs[i].say());
        }*/
//            Customer customer=null;
//        customer.say();

        //java.util.InputMismatchException
        /*Scanner scanner=new Scanner(System.in);
        System.out.println("请输入整数:");
        int num= scanner.nextInt();
        System.out.println(num);*/
        //System.out.println("一个功能模块");

        //算术异常:java.lang.ArithmeticException
        //div(10,0);

        //类型转换异常：  java.lang.ClassCastException
        Object obj=new Customer();
        String str=(String)obj;

    }
    public static int div(int a,int b){
        return a/b;
    }
}

三、异常的处理：
Java中的异常处理采用的是“抓抛模型 ”
抛：一旦某句代码发生异常，会在该代码处生成一个异常对象，然后堆栈式抛出
抓：将上述抛出的异常进行捕获处理

try{
       需要捕获的异常语句
}catch( 异常的类型   变量名 ){
      异常的处理语句
}catch( 异常的类型   变量名 ){
      异常的处理语句
}
......
finally{
        一定执行的语句
}

三、异常的处理：
Java中的异常处理采用的是“抓抛模型 ”
抛：一旦某句代码发生异常，会在该代码处生成一个异常对象，然后堆栈式抛出
抓：将上述抛出的异常进行捕获处理

try{
       需要捕获的异常语句
}catch( 异常的类型   变量名 ){
      异常的处理语句
}catch( 异常的类型   变量名 ){
      异常的处理语句
}
......
finally{
        一定执行的语句
}
注意:
①catch 块可以有多个，一旦某个catch异常类型匹配成功，其他catch块将不再执行
②catch 块可以有多个，若多个catch块中的异常类型具有子父类关系，必须  子上父下
③try-catch可以嵌套
④finally 是可选的，一旦写上就一定执行的语句

四、异常处理的常用方法：
1、printStackTrace()：打印异常的堆栈信息
2、getMessage()：返回异常的描述信息

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
一、异常：不可预知的非正常情况
Java中的异常都是以对象的形式存在，一旦某句代码发生异常，
会在该代码处生成一个异常对象，以堆栈形式抛出，若不对其处理，最终会导致程序终止
二、异常的体系结构
java.lang.Throwable :所有错误和异常的父类
/--java.lang.Error :错误，一些严重的错误。如:内存溢出、系统错误等。我们在代码中不进行处理
/--java.lang.Exception :异常，我们应该尽可能预知并处理的异常。如:用户输入不匹配、网络连接中断等。
                        /--编译时异常(受检异常 checked):编译时对其进行检查，若不处理，编译不能通过。
                        /--运行时异常(非受检异常unchecked):有时可以保证程序的正常运行，一旦发生异常，会在该代码处生成一个异常对象
                                                          然后以堆栈式抛出，若不对其进行处理，最终导致程序终止运行。

三、异常的处理：
Java中的异常处理采用的是“抓抛模型 ”
抛：一旦某句代码发生异常，会在该代码处生成一个异常对象，然后堆栈式抛出
抓：将上述抛出的异常进行捕获处理

try{
       需要捕获的异常语句
}catch( 异常的类型   变量名 ){
      异常的处理语句
}catch( 异常的类型   变量名 ){
      异常的处理语句
}
......
finally{
        一定执行的语句
}
注意:
①catch 块可以有多个，一旦某个catch异常类型匹配成功，其他catch块将不再执行
②catch 块可以有多个，若多个catch块中的异常类型具有子父类关系，必须  子上父下
③try-catch可以嵌套
④finally 是可选的，一旦写上就一定执行的语句


四、异常处理的常用方法：
1、printStackTrace()：打印异常的堆栈信息
2、getMessage()：返回异常的描述信息

 */
public class ExceptionTest {
    public static void main(String[] args) {
        // ------Error----------
               //java.lang.stackoverflowError
                // main(args);
        //java.lang.outOfMemoryError
        //byte[] bs = new byte[Integer.MAX_VALUE];
       /* List list = new ArrayList();
        int i = 0;
        while(true) {
            list.add(new byte[1024]);
            System.out.println(i++);
            }*/

        //----------Exception-----------
        //----------编译时异常-----------
        //FileNotFoundException
//        try {
//            FileInputStream fis = new FileInputStream("");
//            fis.read();
//            fis.close();//上一步read发生异常抛出被捕获后程序继续向下执行，导致close并未执行到,close必须执行
//        }catch (FileNotFoundException e){
//            e.printStackTrace();
//        }catch (IOException e){
//            e.printStackTrace();
//        }
        FileInputStream fis =null;
        try {
            fis = new FileInputStream("");
            fis.read();

        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            }catch (IOException e){
                e.printStackTrace();
            }catch (NullPointerException e){//对象并未创建成功
                e.printStackTrace();
            }
        }

        //----------运行时异常-----------

        //java.lang.ArrayIndexOutOfBoundsException
        /*int[] array=new int[5];
        try {
            array[6]=10;
        }catch (ArrayIndexOutOfBoundsException e){
            //System.out.println("数组下标越界异常");
            e.printStackTrace();
        }*/



        //java.lang.NullPointerException
        /*Customer[] custs = new Customer[5];//{new Customer( )， new Customer(), null， null，null}
        custs[0] = new Customer( );
        custs[1] = new Customer();
        try {
            for (int i = 0; i < custs.length; i++) {
                System.out.println(custs[i].say());
            }
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }*/
//            Customer customer=null;
//            try {
//                customer.say();
//            }catch (NullPointerException e){
//                System.out.println("空指针异常");
//            }


        //java.util.InputMismatchException
//        Scanner scanner=new Scanner(System.in);
//        System.out.println("请输入整数:");
//        try {
//            int num = scanner.nextInt();
//            System.out.println(num);
//        }catch(InputMismatchException e){
//            System.out.println("输入有误!");
//        }
        System.out.println("一个功能模块");

        //算术异常:java.lang.ArithmeticException
       /* try {
            div(10,0);
        }catch (ArithmeticException e){
            e.printStackTrace();
            String msg= e.getMessage();
            System.out.println(msg);
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("其他异常");
        }*/


        //类型转换异常：  java.lang.ClassCastException
       /* Object obj=new Customer();
        try {
            String str=(String)obj;
        }catch (ClassCastException e){
            e.printStackTrace();
        }*/


    }
    public static int div(int a,int b){
        return a/b;
    }
}

Exer: 

1.编写ExceptionExer类，在main方法中接收两个命令行参数，将它们转换为整数，并用
第二个数除以第一个数，打印结果。
2.在命令行运行程序，给出两个参数，测试以下情况，观察运行结果:
    1．其中某个参数不是数字
    2．第二个参数为O
3．提示:
    -分别接收两个参数的语句为:
    int n1 = lnteger.parselnt(args[O]);
    int n2 = lnteger.parseInt(args[1]);
4．改写ExceptionExer类的main方法，在其中捕获可能发生的异常。
5.运行并测试各种异常情况，确认是否均被捕获。 

/*
1.编写TestException类，在main方法中接收两个命令行参数，将它们转换为整数，并用
第二个数除以第一个数，打印结果。
2.在命令行运行程序，给出两个参数，测试以下情况，观察运行结果:
    1．其中某个参数不是数字
    2．第二个参数为O
3．提示:
    -分别接收两个参数的语句为:
    int n1 = lnteger.parselnt(args[O]);
    int n2 = lnteger.parseInt(args[1]);
4．改写TestException类的main方法，在其中捕获可能发生的异常。
5.运行并测试各种异常情况，确认是否均被捕获。

 */
public class ExceptionExer {
    public static void main(String[] args) {
        try {
            int n1 = Integer.parseInt(args[0]);
            int n2 = Integer.parseInt(args[1]);
            System.out.println(n1/n2);
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }catch (NumberFormatException e){
            e.printStackTrace();
        }catch (ArithmeticException e){
            e.printStackTrace();
        }
        System.out.println("庞大的功能");
    }
}