浅析Java中的异常处理机制

异常处理机制

1、抛出异常

2、捕获异常

3、异常处理五个关键字：

try、catch、finally、throw、throws

注意：假设要捕获多个异常：需要按照层级关系(异常体系结构) 从小到大！

package exception;

/**
 * java 捕获和抛出异常：
 * 异常处理机制
 * 1、抛出异常
 * 2、捕获异常
 * 3、异常处理五个关键字
 * try、catch、finally、throw、throws
 * 注意：假设要捕获多个异常：需要按照层级关系(异常体系结构) 从小到大！
 */
public class test {

  public static void main(string[] args) {

    int a = 1;

    int b = 0;

    /**
     * try catch 是一个完整的机构体，finally 可以不要
     * 假设io流，或者跟资源相关的东西，最后需要关闭，关闭的操作就放在 finally 中
     */
    try { //try 监控区域
      system.out.println(a / b);
    } catch (arithmeticexception exception){ //catch（想要捕获的异常类型） 捕获异常
      system.out.println("程序出现异常,变量b不能为0");
    } finally { //处理善后工作
      system.out.println("finally");
    }

    system.out.println("-------------- 分隔符 --------------");

    try {
      new test().a(); //无限循环
    } catch (error error){
      system.out.println("error");
    } catch (exception exception){
      system.out.println("exception");
    } catch (throwable throwable){
      system.out.println("throwable");
    } finally {
      system.out.println("finally");
    }

  }

  public void a(){
    b();
  }

  public void b() {
    a();
  }
}

捕获异常

快捷键：选中代码 ctrl + alt + t

捕获异常的好处：程序不会意外的停止，try catch 捕获异常后程序会正常的往下执行

package exception;

/**
 * 捕获异常快捷键
 * 选中代码后：ctrl + alt + t
 * 如：
 * 选中 system.out.println(a / b);
 * 然后快捷键 ctrl + alt + t
 */
public class test2 {

 public static void main(string[] args) {

  int a = 1;
  int b = 0;

  try {
   system.out.println(a / b);
  } catch (exception exception) {
   exception.printstacktrace(); //打印错误的栈信息
  } finally {
  }

 }
}

抛出异常

1、在方法中抛出异常：throw

2、在方法上抛出异常：throws

package exception;

/**
 * 捕获异常
 * 抛出异常
 */
public class test3 {

 public static void main(string[] args) {

  /**
   * 方法中抛出异常
   */
  new test3().test(1,0); //匿名内部类直接调用

  system.out.println("------------ 分隔符 -------------");

  /**
   * 方法上抛出异常
   * 捕获异常的好处：
   * 程序不会意外的停止，try catch 捕获异常后程序会正常的往下执行
   */
  try {
   new test3().test2(1,0); //匿名内部类直接调用
  } catch (arithmeticexception e) {
   e.printstacktrace();
  }

 }

 /**
  * 在方法中抛出异常：throw
  * @param a
  * @param b
  */
 public void test(int a, int b){
  if (b == 0){ //throw
   throw new arithmeticexception(); //主动抛出异常,一般在方法中使用
  }
  system.out.println(a / b);
 }

 /**
  * 假设在方法中处理不了这个异常,就在方法上抛出异常,然后捕获异常
  * 在方法上抛出异常：throws
  * @param a
  * @param b
  * @throws arithmeticexception
  */
 public void test2(int a, int b) throws arithmeticexception{
  if (b == 0){
   throw new arithmeticexception();
  }
 }
}

以上就是浅析java中的异常处理机制的详细内容，更多关于java 异常处理机制的资料请关注其它相关文章！