js333 > 计算机互联网 > 异常处理,异常处理程序【金沙js333娱乐场】

原标题:异常处理,异常处理程序【金沙js333娱乐场】

浏览次数:169 时间:2019-10-11

Java基础(一)异常处理关键字:try catch finally throw throws,throwthrows

  嗨咯,大家晚上好,我的博客首篇开始了 ,我们一起加油吧!

都说java 语言是非常健壮性 如:垃圾回收机制、内存模型、异常处理,强类型转换、跨平台,等等,使得Java语言的受到青睐。今天我们先来聊聊java的异常处理机制try catch finally throw throws,平时我们貌似小瞧了这五个关键字。开发应用系统,良好异常的处理对系统后期的开发、维护、升级、用户的体验尤其重要。

异常有个非常重要的特征,从出现异常的位置 到 最顶端的main方法 如果你一直没catch到它,最终jvm会帮你抛出异常信息,糟糕的是该线程断掉,后续代码也不再执行,从此无声无息的消失在jvm这片汪洋大海。前面我公司的一个项目前端ajax请求control做支付,由于control的catch里面抛出了一个空指针,导致前端页面卡住不动了,解决方案:由于control层一般是顶层最好catch到任何有可能出现异常的地方,其他非顶层还可以继续throw 或者throws往上抛。还有就是最好为每个ajax设置超时时间。

 

先简单介绍下throw 跟throws:

throw :在方法体内抛出一个异常,实际存在的异常对象,一般用是自己扩展的异常实例,throws是放在方法名后面,表示该方法如果出现异常 , 我不想处理或者处理不了,交给调用者处理,可以thow抛出一个运行时异常(unchecked)如ClassNotFoundException,NumberFromartException,   也可以throws或throw+try或throw+throws 处理一个checked异常如:IOExcepion,SocketException、继承exception类之类的异常, 。区别是checked异常必须处理(要么try,要么throws继续往上抛,否则编译是通不过的),而运行时异常可以不处理,一直不处理的后果是出现异常后jvm报出异常信息然后线程断掉。 throw 跟throws关键字一般情况不建议在代码中使用,推荐所有异常就地解决。知道用就行了,不做过多的讲解。

try的组合规则:1, try{}catch(){}  2,try{}catch(){}finally{}  3,try{}finally{}    ,1跟2的方式 catch可以有多个

 

朋友,吃几颗栗子:

1,无try组合  

public class CatchExecuteJustOne {
  public void methodOne(){
    System.out.println("into methodOne method");
    int one=1/0;
    System.out.println("end methodOne method"); //不会输出  没有try组合,报错后线程已经断掉
}
  public static void main(String[] args) {
    CatchExecuteJustOneS cejo = new CatchExecuteJustOneS();
    cejo.methodOne();

    System.out.println("end  main method"); //不会输出  没有try组合 报错线程已经断掉
  }
}

输出:

Into methodOne method
Exception in thread "main" java.lang.ArithmeticException: / by zero
at priv.lilei.exception.example_1.CatchExecuteJustOneS.methodOne(CatchExecuteJustOneS.java:6)
at priv.lilei.exception.example_1.CatchExecuteJustOne.main(CatchExecuteJustOne.java:19)

 

2.1,有try组合案例1

public class CatchExecuteJustOne {
  public void methodOne(){
    System.out.println("into methodOne method");
  try{
    int one=1/0;
  }catch(Exception e){
    System.out.println("methodOne try到");
  }
  System.out.println("end methodOne method");
}

  public static void main(String[] args) {
    CatchExecuteJustOne cejo = new CatchExecuteJustOne();
    cejo.methodOne();
    System.out.println("end main method");
  }
}

 输出:

into methodOne method
methodOne try到
end methodOne method
end main method

2.2,有try组合案例2

public class CatchExecuteJustOne {
public void methodOne(){
  System.out.println("into methodOne method");
  int one=1/0;
  System.out.println("end methodOne method"); //不会执行线程上面报错断掉直接抛出了
}

public static void main(String[] args) {
  try{
    CatchExecuteJustOne cejo = new CatchExecuteJustOne();
    cejo.methodOne();
  }catch(Exception exception){
    System.out.println("into main method catch"); //会执行 try到上面方法报的异常
  }
    System.out.println("end main method"); //会执行 try到上面方法报的异常
 }
}

输出:

into methodOne method
into main method catch
end main method

 

2.3,有try案例组合3    异常只会被最近捕捉到它的catch 一次。像switch case 跟if() if else(){} if()else if{} 语法一样

 

public class CatchExecuteJustOne {
public void methodOne(){
System.out.println("into methodOne method");
try{
int one=1/0;
}catch(ArithmeticException e){
System.out.println("catch 1");
}catch (Exception e) {
System.out.println("catch 2");//不会执行 已经执行了上一个catch 1
}
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();

try {
cejo.methodOne();
} catch (Exception e) {
System.out.println("man catch");//不会执行已经执行了catch 1
}

System.out.println("end main method");
}
}

输出:

into methodOne method
catch 1
end main method

2.4 有try组合案例4,  try{}finally{}组合,finally没中有返回值得时候线程会断掉,但在finally中有返回值时候线程不会断掉只是后续代码不会执行, 这种组合建议少用。

 //没返回值

public class CatchExecuteJustOne {
  public void methodOne(){  //没返回值
    System.out.println("into methodOne method");
  try{
    int one=1/0;
  }finally{
    System.out.println("into methodOne finally");
  }
    System.out.println("end methodOne method"); //不会执行线程上面报错断掉直接抛出了
}

public static void main(String[] args) {
  CatchExecuteJustOne cejo = new CatchExecuteJustOne();
  cejo.methodOne();
  System.out.println("end main method");//不会执行线程上面报错断掉直接抛出了
  }
}

没返回值的输出:

into methodOne method
Exception in thread "main" into methodOne finally
java.lang.ArithmeticException: / by zero
at priv.lilei.exception.example_1.CatchExecuteJustOne.methodOne(CatchExecuteJustOne.java:14)
at priv.lilei.exception.example_1.CatchExecuteJustOne.main(CatchExecuteJustOne.java:23)

有返回值:

public class CatchExecuteJustOne {
public String methodOne(){
System.out.println("into methodOne method");
try{
System.out.println("1");
int one=1/0;
System.out.println("2");//不会执行线程上面报错断掉直接抛出了
}finally{
System.out.println("into methodOne finally");//会输出
return "1";
}
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
cejo.methodOne();
System.out.println("end main method");//会执行 因为上面有try到并且方法有返回值
}
}

有返回值的输出:

into methodOne method
1
into methodOne finally
end main method

 

2.5,带finally的组合  finally永远被执行,有返回值得情况在返回之前执行,  除非出现特别暴力的行为如 system.exit(0); 或者断掉了,或者内存溢出了等Error错误。

return 组合

2.5.1 下面两个案例  在没有异常 跟有异常的情况  ,在catch跟finally 中给变量再次赋值   存在差异。没有异常再次赋值失败,而有异常再次赋值成功。

 

1 没有异常的情况 

public class CatchExecuteJustOne {
public String methodOne(){
String a="";
System.out.println("into methodOne method");
try{
a="a";
return a;
}catch(ArithmeticException e){
System.out.println("catch 1");
}finally {
System.out.println(1);
a="a2";        //不报错的情况   不会赋值给a;
System.out.println(2);
}
System.out.println(3); //不会执行 上面return a方法已经返回了
return a;
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
System.out.println(cejo.methodOne());
}
}

try中return 没有异常的情况的输出:

into methodOne method
1
2
a

2 有异常的情况

public class CatchExecuteJustOne {
public String methodOne(){
String a="";
System.out.println("into methodOne method");
try{
a="a";
int i=1/0;
return a;
}catch(ArithmeticException e){
System.out.println("catch 1");
}finally {
System.out.println(1);
a="a2";   //有异常会重新赋值给a 变量
System.out.println(2);
}
System.out.println(3); //会输出 捕捉到了异常没有从上面第一个return a返回 而是从下面这个return返回
return a;
}

public static void main(String[] args) {
CatchExecuteJustOne cejo = new CatchExecuteJustOne();
System.out.println(cejo.methodOne());
}
}

try中return 有异常的情况输出:

into methodOne method
catch 1
1
2
3
a2

 

catch finally throw throws,throwthrows 嗨咯,大家晚上好,我的博客首篇开始了 ,我们一起加油吧! 都说jav...

异常处理,异常处理程序

一、请阅读并运行AboutException.java示例,然后通过后面的几页PPT了解Java中实现异常处理的基础知识。

import javax.swing.*;

class AboutException {

   public static void main(String[] a)

   {

   int i=1, j=0, k;

      //double i=1, j=0, k;

      k=i/j;

   //System.out.println(k);

try

{

k = i/j;    // Causes division-by-zero exception

//throw new Exception("Hello.Exception!");

}

catch ( ArithmeticException e)

{

System.out.println("被0除.  "+ e.getMessage());

}

catch (Exception e)

{

if (e instanceof ArithmeticException)

System.out.println("被0除");

else

{  

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

}

}

finally

     {

      JOptionPane.showConfirmDialog(null,"OK");

     }

  }

}

结果:

    金沙js333娱乐场 1

Java中实现异常处理的基础知识:

异常的对象有两个来源,一是Java运行时环境自动抛出系统生成的异常,而不管你是否愿意捕获和处理,它总要被抛出!比如除数为0的异常。二是程序员自己抛出的异常,这个异常可以是程序员自己定义的,也可以是Java语言中定义的,用throw 关键字抛出异常,这种异常常用来向调用者汇报异常的一些信息。

异常是针对方法来说的,抛出、声明抛出、捕获和处理异常都是在方法中进行的。

Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句,如果在try语句块内出现异常,则异常会被抛出,你的代码在catch语句块中可以捕获到这个异常并做处理;还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常,然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行,一般结构如下:
 try{
  程序代码
 }catch(异常类型1 异常的变量名1){
  程序代码
 }catch(异常类型2 异常的变量名2){
  程序代码
 }finally{
  程序代码
 }

二、阅读以下代码(CatchWho.java),写出程序运行结果:

public class CatchWho {

    public static void main(String[] args) {

        try {

             try {

                 throw new ArrayIndexOutOfBoundsException();

             }

             catch(ArrayIndexOutOfBoundsException e) {

                System.out.println(  "ArrayIndexOutOfBoundsException" +  "/内层try-catch");

             }

            throw new ArithmeticException();

        }

        catch(ArithmeticException e) { //算数

            System.out.println("发生ArithmeticException");

        }

        catch(ArrayIndexOutOfBoundsException e) { //越界

           System.out.println(  "ArrayIndexOutOfBoundsException" + "/外层try-catch");

        }

    }

}

结果:

金沙js333娱乐场 2

三、写出CatchWho2.java程序运行的结果

public class CatchWho2 {

    public static void main(String[] args) {

        try {

             try {

                 throw new ArrayIndexOutOfBoundsException();

             }

             catch(ArithmeticException e) {

                 System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch");

             }

            throw new ArithmeticException();

        }

        catch(ArithmeticException e) {

            System.out.println("发生ArithmeticException");

        }

        catch(ArrayIndexOutOfBoundsException e) {

            System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch");

        }

    }

}

结果:

金沙js333娱乐场 3

四、请先阅读 EmbedFinally.java示例,再运行它,观察其输出并进行总结。

public class EmbededFinally {    

public static void main(String args[]) {       

int result;        

try {            

System.out.println("in Level 1");           

  try {              

System.out.println("in Level 2");

  // result=100/0;  //Level 2            

  try {                

  System.out.println("in Level 3");                      

  result=100/0;  //Level 3                

}                 

catch (Exception e) {                    

System.out.println("Level 3:" + e.getClass().toString());               

}               

finally {                    

System.out.println("In Level 3 finally");               

}              

// result=100/0;  //Level 2          

}          

catch (Exception e) {              

  System.out.println("Level 2:" + e.getClass().toString());          

  }

  finally {                

System.out.println("In Level 2 finally");        

 }            

// result = 100 / 0;  //level 1        

}         

catch (Exception e) {          

System.out.println("Level 1:" + e.getClass().toString());        

}        

finally {           

  System.out.println("In Level 1 finally");        

}   

}

}

结果:

金沙js333娱乐场 4

当有多层嵌套的finally时,异常在不同的层次抛出 ,在不同的位置抛出,可能会导致不同的finally语句块执行顺序。

finally语句块不一定会执行。

请看SystemExitAndFinally.java示例

public class SystemExitAndFinally {  

public static void main(String[] args)

    {      

try{           

System.out.println("in main");        

throw new Exception("Exception is thrown in main");

             //System.exit(0);     

}      

catch(Exception e)

        {           

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

System.exit(0);        

}        

finally       

{            

System.out.println("in finally");        

}    

}

}

结果:

金沙js333娱乐场 5

当程序中出现异常时,JVM会依据方法调用顺序依次查找有关的错误处理程序。

可使用printStackTrace 和 getMessage方法了解异常发生的情况:

printStackTrace:打印方法调用堆栈。

每个Throwable类的对象都有一个getMessage方法,它返回一个字串,这个字串是在Exception构造函数中传入的,通常让这一字串包含特定异常的相关信息。

请通过 PrintExpressionStack.java示例掌握上述内容。依据对本讲多个示例程序的分析,请自行归纳总结出Java多层嵌套异常处理的基本流程。

// UsingExceptions.java

// Demonstrating the getMessage and printStackTrace

// methods inherited into all exception classes.

public class PrintExceptionStack {

   public static void main( String args[] )

   {

      try {

         method1();

      }

      catch ( Exception e ) {

         System.err.println( e.getMessage() + "n" );

         e.printStackTrace();

      }

   }

   public static void method1() throws Exception

   {

      method2();

   }

   public static void method2() throws Exception

   {

      method3();

   }

   public static void method3() throws Exception

   {

      throw new Exception( "Exception thrown in method3" );

   }

}

     结果:

金沙js333娱乐场 6

五、一个方法可以声明抛出多个异常

int g(float h) throws OneException,TwoException

{ …… }

ThrowMultiExceptionsDemo.java示例展示了相关特性。

注意一个Java异常处理中的一个比较独特的地方:

金沙js333娱乐场 7

import java.io.*;

public class ThrowMultiExceptionsDemo {

    public static void main(String[] args)

     {

      try {

            throwsTest();

       }

        catch(IOException e) {

            System.out.println("捕捉异常");

        }

    }

    private static void throwsTest()  throws ArithmeticException,IOException {

        System.out.println("这只是一个测试");

        // 程序处理过程假设发生异常

        throw new IOException();

        //throw new ArithmeticException();

    }

}

   结果:

金沙js333娱乐场 8

一个子类的throws子句抛出的异常,不能是其基类同名方法抛出的异常对象的父类。

OverrideThrows.java示例展示了Java的这个语法特性。

import java.io.*;

public class OverrideThrows

{

public void test()throws IOException

{

FileInputStream fis = new FileInputStream("a.txt");

}

}

class Sub extends OverrideThrows

{

//如果test方法声明抛出了比父类方法更大的异常,比如Exception

    //则代码将无法编译……

public void test() throws FileNotFoundException

{

            //...

}

}

六、编写一个程序,此程序在运行时要求用户输入一个 整数,代表某门课的考试成绩,程序接着给出“不及格”、“及格”、“中”、“良”、“优”的结论。

要求程序必须具备足够的健壮性,不管用户输入什 么样的内容,都不会崩溃。

import java.util.Scanner;

public class Grade {

public static void main(String[] args) throws NumberFormatException {

double score;

try{

Scanner in=new Scanner(System.in);

System.out.println("请输入成绩:");

score=in.nextDouble();

if((score>=0)&&(score<60)){

System.out.println("不及格");

}

else if((score>=60)&&(score<70)){

System.out.println("及格");

}

else if((score>=70)&&(score<80)){

System.out.println("中");

}

else if((score>=80)&&(score<90)){

System.out.println("良");

}

else if((score>=90)&&(score<=100)){

System.out.println("优");

}

else if(score<0||score>100)

System.out.println("输入数字过大或过小");          

else 

            throw new Exception();

}

catch(Exception e){

System.out.println("输入的不是数字,请重新输入正确的数字");

}

}

}

结果:

金沙js333娱乐场 9

金沙js333娱乐场 10

 

一、 请阅读并运行 AboutException.java 示例,然后通过后面的几页 PPT 了解 Java 中实现异常处理的基础知识。 import...

Java异常类型

所有异常类型都是Throwable的子类,Throwable把异常分成两个不同分支的子类Error和Exception。

金沙js333娱乐场 11

Error类型的异常表示运行应用程序中较严重问题。大多数错误表示代码运行时 JVM(Java 虚拟机)出现的问题。

Exception类型是程序本身可以处理的异常,它又分为非运行时异常和运行时异常(RuntimeException即运行期问题)。非运行时异常需要手动添加捕获及处理语句,如果不处理,编译则不通过;运行时异常是jvm正常运行期间抛出的错误,这些异常是不检查异常(编译器不会去检查它),一般由程序逻辑错误所引起,是代码本身有问题,这种问题我们不处理。

如果程序出了问题,并且我们没有做任何处理,最终会被默认处理程序处理,默认处理程序会把异常的信息打印在控制台,同时程序停止运行。

对于所有的可查异常,java规定:方法必须捕捉,如果不捕捉,则必须声明抛出异常

java内置异常类

非检查性异常


ArithmeticException:算数错误。如,一个整数"除以零"

ArrayIndexOutOfBoundsException:数组下标出界。

ArrayStoreException:数组元素赋值类型不兼容

ClassCastException:非法强制转换类型

IllegalArgumentException:向方法传递了一个不合法或不正确的参数

IllegalMonitorStateException:非法监控操作,如等待一个未锁定线程

IllegalStateException:环境应用状态不正确

IllegalThreadStateException:请求操作与当前线程状态不兼容

金沙js333娱乐场 ,IndexOutOfBoundsException:某些类型索引超出范围

NegativeArraySizeException:应用程序试图创建大小为负的数组

NullPointerException:当应用程序试图在需要对象的地方使用 null 时,抛出该异常

NumberFormatException:字符串到数字格式的非法转换

SecurityException:由安全管理器抛出的异常,指示存在安全侵犯

StringIndexOutOfBoundsException:索引为负,或者超出字符串的大小

UnsupportedOperationException:遇到不支持请求的操作

检查行异常


ClassNotFoundException:找不到相应的类

CloneNotSupportedException:试图克隆一个无法实现 Cloneable 接口的对象

IllegalAccessException:对一个类的访问被拒绝

InstantiationException:试图创建一个抽象接口或抽象类的对象

InterruptedException:一个线程被另一个线程中断

NoSuchFieldException:请求的变量不存在

NoSuchMethodException:请求的方法不存在

try...catch

try/catch关键字可以捕获异常

try{

可能出现问题的代码

}catch(异常名 变量){

针对问题的处理

}

一旦异常被引发,程序控制转到catch块,执行了catch语句后,程序控制从整个try/catch机制的下面一行继续。一个catch语句不能捕获另一个try声明所引发的异常(除非是嵌套的try语句情况)。不能单独使用try。构造catch语句的目的是不中断程序的运行。

try里面定义的属性只能在try块中使用

class Demo{

public static void main(String[] args){

int a,b;

try{

a=5;

b=0;

System.out.println(a/b);

}catch(ArithmeticException e){

System.out.println("Division by zero");

}

System.out.println("After catch exception");

}

}

结果为:Division by zero

After catch exception

某些情况下单个代码可能引起多个异常,处理这种情况可以定义更多的catch子句,每个子句捕获一种类型的异常。

当异常被引发,每一个catch子句被依次检查,匹配上异常类型的子句执行,然后代码从try/catch块后面开始继续。

注意:异常子类必须在它们父类前面(如果不这样,编译器会报错),这是因为运用父类的catch语句将捕获该类型及其所有子类类型的异常。

class Demo{

public static void main(String[] args){

int[] a={1,2};

try{

a[34]=5;

}catch(ArrayIndexOutOfBoundsException e){

     System.out.println("ArrayIndexOutOfBoundsException catch");

}catch(Exception e){

     System.out.println("Exception catch");

}

System.out.println("After catch exception");

}

}

结果为:ArrayIndexOutOfBoundsException catch

After catch exception

try语句可以被嵌套,也就是说一个try语句可以在另一个try语句内部。

建议最好不要嵌套

public class Demo {

 public static void main(String[] args) {

   try{

     int a=args.length;

     int b=42/a;

     System.out.println("a="+a);

    try{

       if(a==1)

       a=a/(a-a);

       if(a==2){

         int c[]={1};

         c[43]=9;

       }

     }catch(ArrayIndexOutOfBoundsException e){

       System.out.println("ArrayIndexOutOfBounds:"+e);

     }

   }catch(ArithmeticException e){

     System.out.println("Divide by:"+e);

   }

 }

}

结果:Divide by:java.lang.ArithmeticException: / by zero

如果a=1,则结果为:a=1

Divide by:java.lang.ArithmeticException: / by zero

如果a=2,则结果为:a=2

ArrayIndexOutOfBounds:java.lang.ArrayIndexOutOfBoundsException: 43

粗体的try语句嵌套在了外面这个大的try块中,内部的try块不含有处理这个异常的catch语句,它将把异常传给外面的try块,在那里异常被检查是否与之匹配,这个过程将继续直到匹配成功。如果没有catch语句与之匹配,java运行时系统将自动处理这个异常。

finally

finally块无论有没有异常抛出都会执行,所以finally一般用来关闭资源。每个try语句至少,需要一个catch或finally字句。finally块可有可无,不作强制要求。

当在try块或catch块中遇到return语句时,finally语句块将在方法返回之前被执行。如果finally语句块中也有return语句,那么直接从finally中返回了,而且finally中的return会使抛出的异常丢失,所以不建议在finally中ruturn.。finally中抛出的异常会覆盖catch中抛出的异常。

在以下4种特殊情况下,finally块不会被执行:

1)在finally语句块中发生了异常。

2)在前面的代码中用了System.exit()退出程序。

3)程序所在的线程死亡。

4)关闭CPU。

public class Demo {

public static void main(String[] args) {

int[] a={1,2};

try{

a[34]=5;

}catch(ArrayIndexOutOfBoundsException e){

System.out.println("Exception catch");

}finally{

System.out.println("finally");

}

}

}

结果为:Exception catch

finally

throw

有时候有些错误在jvm看来不是错误,系统就不会抛出异常(如输入的年龄小于0),这时候我们需要手动引发异常。程序可以用throw语句抛出一个明确的异常。程序在throw语句之后立即停止,后面的任何语句不被执行,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块

异常是异常类的实例对象,我们可以创建异常类的实例对象通过throw语句抛出

用法:throw 异常对象;

有两种获得异常对象的方法:在catch子句中捕获到的异常对象或者用new操作符创建

public class Demo {

static void demo(){

try{
throw new ArithmeticException("demo");//新实例化的异常对象
}catch(ArithmeticException e){
System.out.println("Caught inside demo");
throw e; //捕获到的异常对象e
}
}

public static void main(String[] args) {
try{
demo();
 }catch(ArithmeticException e){
System.out.println("Caught"+e);
}
}
}

结果为:Caught inside demo

Caughtjava.lang.ArithmeticException:demo

注意:throw new ArithmeticException();中new用来构造ArithmeticException实例。所有java内置的运行异常有两个构造方法:一个没有参数,一个带有一个字符串参数。当用第二种形式时,参数描述指定异常的字符串(抛出异常的原因),如果对象用作print()或println()输出时,该字符串被显示(打印异常原因)。

throw是语句抛出异常。它不可以单独使用,要么与try…catch配套使用,要么与throws配套使用。

throws

throws 是方法抛出异常,在一个方法中可能出现了某些异常,我们没法去处理它,然后就将这个异常向上抛出。如果一个方法中没有捕获某个检查性异常的语句,则该方法必须使用 throws 关键字来声明,异常的处理则交由它的调用者。throws 关键字放在方法声明的尾部。例如汽车出现了故障时,汽车不会自己去处理这个异常,而是交给开车的人来处理。

如果一个方法声明了throws,然后方法里面有try...catch块,直接catch异常的引用不再throws(即上层调用者不会去处理这个异常)。

Throws抛出异常的规则:

1) 如果是不可查异常(unchecked exception),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出。

2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误

3)当抛出了异常,该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出。

4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法,则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

一个方法可以声明抛出多个异常,多个异常之间用逗号隔开。

public class Demo {

public static void test() throws ArithmeticException {

   throw new ArithmeticException();

}

public static void main(String[] args) {

try{

test();

}catch(ArithmeticException e){

System.out.println("Caught:"+e);

}

}

}

结果为:Caught:java.lang.ArithmeticException: / by zero

在test()后面声明throws来引发ArithmeticException异常,在main方法中必须定义一个try/catch语句来捕获该异常

通过throw抛出异常后,如果想在上一级代码中捕获并处理异常,需要在抛出异常方法中使用throws关键字在方法声明中指明要跑出的异常。如果要捕获throw抛出的异常,必须使用try/catch语句

自定义异常

系统中有些错误是符合Java语法的,但不符合逻辑,此时就可以自定义异常。如果异常中没有我们想要的异常,也剋有自定义一个异常。比如人的性别是中性时需要抛出异常,但是一直异常中没有这个异常,这时候我们可以自定义一个异常抛出。

在 Java 中可以自定义异常。所有异常都必须是 Throwable 的子类。如果希望写一个检查性异常类,则需要继承 Exception 类。如果你想写一个运行时异常类,那么需要继承 RuntimeException 类。

一般情况下我们都会直接继承Exception类

Exception类没有定义任何方法,它继承了Throwable提供的一些方法。

Throwable 类的主要方法:


String getMessage():返回关于发生的异常的详细信息

Throwable getCause():返回一个Throwable 对象代表异常原因

String toString():使用getMessage()的结果返回类的串级名字

void printStackTrace():打印toString()结果和栈层次到System.err,即错误输出流。

StackTraceElement [] getStackTrace():返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。

Throwable fillInStackTrace():用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。

Java自定义异常的使用要经历如下四个步骤:

1、定义一个类继承Throwable或其子类。

2、添加构造方法(当然也可以不用添加,使用默认构造方法)。

3、在某个方法类抛出该异常。

4、捕捉该异常。

public class MyException extends Exception { //自定义的MyException异常

}

public class Demo {

static void compute(int a) throws MyException{

System.out.println("Called compute("+a+")");

if(a>10)

throw new MyException();

System.out.println("Normal exit");

}

public static void main(String[] args) {

try{

compute(1);

compute(20);

}catch(MyException e){

System.out.println("Caught:"+e);

}

}

}

结果为:Called compute(1)

Normal exit

Called compute(20)

Caught:com.DE.MyException

本文由js333发布于计算机互联网,转载请注明出处:异常处理,异常处理程序【金沙js333娱乐场】

关键词:

上一篇:没有了

下一篇:没有了