Java 中的异常处理机制

生活中的异常：

不能够完整而顺利的完成一些工作

根据不同的异常进行相应的处理，而不会就此终端我们的生活

引出：

异常处理：

　　方式：
　　　　1.选择结构（逻辑判断）避免

demo：if逻辑处理异常

import java.util.Scanner;

public class TestIF {

    /**

     * 程序中的异常

     * @param 房上的猫

     */

    public static void main(String[] args) {

        //处理异常的方式1：if ..逻辑判断

        Scanner input=new Scanner(System.in);

        System.out.print("请输入第一个整数：");

        if(input.hasNextInt()==true){

            int num1=input.nextInt();//1）输入不是整数类型  2）除法 输入 0

            System.out.print("请输入第二个整数：");

            int num2=input.nextInt();

            if(num2==0){

                System.err.println("除数不能为0，程序退出");

                System.exit(1);// 退出程序

            }

            else

            {

                int jg=num1/num2;//输入num2可能输入  0

                System.out.println(jg);

            }

        }else

        {

            System.err.println("输入的不是整数，程序退出");

            System.exit(1);

        }

    }

}

　　　　弊端：
  　　　　　　1）代码臃肿
  　　　　　　2）程序员要花很大精力“堵漏洞”
  　　　　　　3）程序员很难堵住所有漏洞
　2.使用异常机制

　　　　异常处理机制，是专门应对异常出现后，如何解决该异常的一种手段
　　异常是指程序在运行过程中所发生的不正常的时间，它会中断正在运行的程序
　　Java编程语言使用异常处理机制为程序提供了错误处理机制
   异常处理关键字
     捕获异常：
　　try（试一试）:执行可能产生异常的代码
　　catch（抓住，捕获）：捕获异常
　　finally（最终）：无论是否发生异常，代码总能执行
     声明异常：
　　throws（抛出）：声明方法可能要抛出的各种异常
     抛出异常：
　　throw（抛出）：手动抛出异常

   throws声明异常，抛给调用者，调用必须进行try...catch
   位置：方法名后面进行声明异常，多个异常使用逗号隔开
    //声明异常，多个异常用逗号隔开
　　只要有throws，强制要求方法调度方法必须手段1：try catch 2.继续向上抛
public static void a() throws 异常类型{
     //可能出现异常的代码
}
   throw：手动抛出异常
       throw new Exception("异常");

注：在真实开发中，如果我们定制了工具类，工具类中有特别复杂的方法，需要各种断定，这个时候，工具类的方法一定有一个机制，就是异常上抛的机制，作用：为了工具的使用房，可以感知到这个异常

demo 01:

import java.util.InputMismatchException;

import java.util.Scanner;

public class TestExceptionThrows1 {

    /**

     * throws声明异常，抛给调用者处理，调用者必须进行try..catch

     * 位置： 方法名后面进行 声明异常，多个异常使用逗号隔开

     */

    public static void divid() throws InputMismatchException,ArithmeticException,Exception{

            Scanner input=new Scanner(System.in);

            System.out.print("请输入第一个整数：");

            int num1=input.nextInt();//1）输入不是整数类型  2）除法 输入 0

            System.out.print("请输入第二个整数：");

            int num2=input.nextInt();

            int jg=num1/num2;//输入num2可能输入  0

            System.out.println(jg);

    }

    public static void main(String[] args) {

        //调用处必须处理

        try {

            divid();

        } catch (InputMismatchException e) {

            System.err.println("输入不匹配");

            e.printStackTrace();

        } catch (ArithmeticException e) {

             System.err.println("除数不能为0");

            e.printStackTrace();

        } catch (Exception e) {

             System.err.println(e.getMessage());

            e.printStackTrace();

        }

    }

}

demo 02:

import java.util.InputMismatchException;

import java.util.Scanner;

public class TestExceptionThrows2 {

    /**

     * throws声明异常，抛给调用者处理，调用者必须进行try..catch

     * 位置： 方法名后面进行 声明异常，多个异常使用逗号隔开

     */

    public static void divid() throws InputMismatchException,ArithmeticException,Exception{

            Scanner input=new Scanner(System.in);

            System.out.print("请输入第一个整数：");

            int num1=input.nextInt();//1）输入不是整数类型  2）除法 输入 0

            System.out.print("请输入第二个整数：");

            int num2=input.nextInt();

            int jg=num1/num2;//输入num2可能输入  0

            System.out.println(jg);

    }

    public static void main(String[] args) throws InputMismatchException,ArithmeticException,Exception{

        //调用处不处理，抛给了java虚拟机继续处理

            divid();

    }

}

demo 03:

public class PersonThrow {

    private String  name;

    private int age;

    private String sex;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        if(age>=0 && age<=100){

            this.age = age;

        }else{

            try {

                //手动抛出异常

                throw new Exception("输入的年龄必须是0~100之间的数");

            } catch (Exception e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) throws Exception {

        if(!sex.equals("男") && !sex.equals("女")){

            throw new Exception("输入必须是男或女");

        }else

        {

        this.sex = sex;

        }

    }

}

public class TestPerson {

   public static void main(String[] args) {

      PersonThrow per=new PersonThrow();

      per.setAge(-90);

      System.out.println(per.getAge());

      try {

        per.setSex("fd");

        System.out.println(per.getSex());

    } catch (Exception e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

    }

}

}

异常的分类

常见的异常处理类型

解析：检查时异常：编译时系统提示必须使用异常处理机制环绕（chenked异常）

　　　　运行时异常：运行时抛出异常

使用try-catch-finally处理异常

　　异常是一种特殊的对象，类型为 java.lang.Exception或其子类

语法：
　　
格式1 ：

try{

            //可能发生异常的语句

 } catch(Exception){

    //捕获异常

 }finally{

   //无论是否有异常，都进入执行

 }

执行顺序：
　　try块发生异常产生异常对象
　　异常类型匹配进入 catch块
　　程序继续执行

printStactTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程
ex.getMessage();
返回异常信息描述的字符串
ex.printStactTrace();
异常堆栈信息
显示具体异常类型
显示产生异常的具体位置

当异常类型不匹配时，程序之间中断

打印自定义处理信息：
System.err.println（“自定义信息”）；

多路异常捕获：

　　多个catch块并列，但异常类型不同（捕获可能出现多种异常的代码块）

　　注：子异常一定在顶级一次之前

　　demo：try..catch处理异常

import java.util.InputMismatchException;

import java.util.Scanner;

public class TestExceptionTry {

    /**

     *

     */

    public static void main(String[] args) {

        try {

            Scanner input=new Scanner(System.in);

            System.out.print("请输入第一个整数：");

            int num1=input.nextInt();//1）输入不是整数类型  2）除法 输入 0

            System.out.print("请输入第二个整数：");

            int num2=input.nextInt();

            int jg=num1/num2;//输入num2可能输入  0

            System.out.println(jg);

        }catch(ArithmeticException ae){

            System.err.println("除数不能为0"+ae.getMessage());

            ae.printStackTrace();

        }catch(InputMismatchException ae){

            System.err.println("输入的不是整数");

            System.exit(1);

        }

        catch (Exception e) {

            System.out.println(e.getMessage());

            e.printStackTrace();

        }

    }

}

（C）房上的猫。保留所有权利。
https://www.cnblogs.com/lsy131479/

如需转载，请注明出处！！！

巴特西

Java 中的异常处理机制

最新文章

热门文章