精华内容
下载资源
问答
  • throws关键字

    2020-12-24 13:34:02
    那么此时就可以在方法声明上使用throws关键字来进行异常类型的标注。 范例:观察throws关键字的使用 class JavaDemo { public static void main(String[] args) { //调用处来处理异常 try{ System.out....

    thows关键字

    通过之前的程序可以发现,在执行程序的过程之中可能会产生异常,但是如果你现在定义了一个方法,实际上就应该明确告诉使用者这个方法可能会产生何种异常。那么此时就可以在方法声明上使用throws关键字来进行异常类型的标注。
    范例:观察throws关键字的使用

    class  JavaDemo
    {
    	public static void main(String[] args) 
    	{
    		//调用处来处理异常
    		try{
    		System.out.println(MyMath.div(10,2));
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    	}
    }
    class MyMath
    {
    	//这个代码执行的时候可能会产生异常,如果产生异常调用处(此程序为主方法中)处理
    	public static int div(int x,int y) throws Exception{
    		return x/y;
    	}
    }
    

    主方法本身也是个方法,那么实际上主方法也可以继续向上抛出。
    范例:在主方法上继续抛出异常

    class  JavaDemo
    {
    	public static void main(String[] args) throws Exception //主方法中继续抛出异常
    	{
    		System.out.println(MyMath.div(10,0));
    	}
    }
    class MyMath
    {
    	//这个代码执行的时候可能会产生异常,如果产生异常调用处(此程序为主方法中)处理
    	public static int div(int x,int y) throws Exception{
    		return x/y;
    	}
    }
    

    结果:
    Exception in thread “main” java.lang.ArithmeticException: / by zero
    at MyMath.div(throws关键字.java:12)
    at JavaDemo.main(throws关键字.java:5)

    如果主方法继续向上抛出异常,那么就表示此异常将交由JVM负责处理。

    展开全文
  • throw跟throws关键字

    2020-04-15 22:30:15
    throw跟throws关键字 throws关键字 定义一个方法的时候可以使用throws关键字声明。使用throws关键字声明的方法表示此方法不处理异常,而交给方法调用处进行处理。 throws关键字格式: public 返回值类型 方法名称...

    throw跟throws关键字

    throws关键字

    定义一个方法的时候可以使用throws关键字声明。使用throws关键字声明的方法表示此方法不处理异常,而交给方法调用处进行处理。

    throws关键字格式:

    public 返回值类型 方法名称(参数列表,,,)throws 异常类{};

    假设定义一个除法,对于除法操作可能出现异常,可能不会。所以对于这种方法最好将它使用throws关键字声明,一旦出现异常,

    则应该交给调用处处理。

    class Math{
        public int div(int i,int j) throws Exception{    // 定义除法操作,如果有异常,则交给被调用处处理
            int temp = i / j ;    // 计算,但是此处有可能出现异常
            return temp ;
        }
    };
    public class ThrowsDemo01{
        public static void main(String args[]){
            Math m = new Math() ;        // 实例化Math类对象
            try{
                System.out.println("除法操作:" + m.div(10,2)) ;
            }catch(Exception e){
                e.printStackTrace() ;    // 打印异常
            }
        }
    };
    

    因为div使用了throws关键字声明,所以调用此方法的时候,方法必须进行异常处理。通过try…catch;

    如果在主方法的声明也使用了throws关键字呢,那么是不是意味着主方法也可以不处理异常。

    class Math{
        public int div(int i,int j) throws Exception{    // 定义除法操作,如果有异常,则交给被调用处处理
            int temp = i / j ;    // 计算,但是此处有可能出现异常
            return temp ;
        }
    };
    public class ThrowsDemo02{
        // 在主方法中的所有异常都可以不使用try...catch进行处理
        public static void main(String args[]) throws Exception{
            Math m = new Math() ;        // 实例化Math类对象
            System.out.println("除法操作:" + m.div(10,0)) ;
        }
    };
    运行结果:
    
    Exception in thread "main" java.lang.ArithmeticException: / by zero
    	at methoud.Math.div(ThisDemo06.java:4)
    	at methoud.ThisDemo06.main(ThisDemo06.java:12)
    

    在本程序中,主方法不处理任何异常,而交给JAVA中最大头JVM,所以如果在主方法使用了throws关键字,则表示一切异常

    交给JVM进行处理。默认处理方式也是JVM完成。

    throw关键字

    throw关机字作用是抛出一个异常,抛出的时候是抛出的是一个异常类的实例化对象,

    在异常处理中,try语句要捕获的是一个异常对象,那么此异常对象也可以自己抛出。

    package methoud;
    public class ThisDemo06{
        public static void main(String args[]){
            try{
                throw new Exception("自己抛着玩的。") ;    // 抛出异常的实例化对象
            }catch(Exception e){
                System.out.println(e) ;
            }
        }
    };
    
    

    throw与throws的应用

    在一般开发中,try,,catch,,finally,throw,throws联合使用的情况是最多的。

    例如,现在要使用一个相除的方法,但是在操作之前必须打印“运算开始”的信息,结束之后必须打印“异常结束”。

    如果有异常,需要把异常交给异常调用处处理。面对这样要求,必须全部使用以上关键字。

    class Math{
        public int div(int i,int j) throws Exception{    // 定义除法操作,如果有异常,则交给被调用处处理
            System.out.println("***** 计算开始 *****") ;
            int temp = i / j ;    // 计算,但是此处有可能出现异常
            System.out.println("***** 计算结束 *****") ;
            return temp ;
        }
    };
    public class ThrowDemo02{
        public static void main(String args[]){
            Math m = new Math() ;
            try{
                System.out.println("除法操作:" + m.div(10,0)) ;
            }catch(Exception e){
                System.out.println("异常产生:" + e) ;
            }
        }
    };
    运行结果:
    
    ***** 计算开始 *****
    异常产生:java.lang.ArithmeticException: / by zero
    

    以上没有计算结束,因为没有异常发生了,直接中断程序操作。所以做以下操作。

    package methoud;
    class Math{
        public int div(int i,int j) throws Exception{    // 定义除法操作,如果有异常,则交给被调用处处理
            System.out.println("***** 计算开始 *****") ;
            int temp = 0 ;    // 定义局部变量
            try{
                temp = i / j ;    // 计算,但是此处有可能出现异常
            }catch(Exception e){
            }
             System.out.println("***** 计算结束 *****") ;
            return temp ;
        }
    };
    public class ThisDemo06{
        public static void main(String args[]){
            Math m = new Math() ;
            try{
                System.out.println("除法操作:" + m.div(10,0)) ;
            }catch(Exception e){
                System.out.println("异常产生:" + e) ;
            }
        }
    };
    运行结果:
    
    ***** 计算开始 *****
    ***** 计算结束 *****
    异常产生:java.lang.ArithmeticException: / by zero
    

    这里虽然貌似成功了,但是,这里的异常并没有抛出去,因为在方法中已经被自动处理了,没有抛出去。

    所以要抛出异常对象,给方法调用处处理,使用throw关键字。

    package methoud;
    class Math{
        public int div(int i,int j) throws Exception{    // 定义除法操作,如果有异常,则交给被调用处处理
            System.out.println("***** 计算开始 *****") ;
            int temp = 0 ;    // 定义局部变量
            try{
                temp = i / j ;    // 计算,但是此处有可能出现异常
            }catch(Exception e){
                throw e ;    //抛出异常。
            }finally{    // 不管是否有异常,都要执行统一出口
                System.out.println("***** 计算结束 *****") ;
            }
            return temp ;
        }
    };
    public class ThisDemo06{
        public static void main(String args[]){
            Math m = new Math() ;
            try{
                System.out.println("除法操作:" + m.div(10,0)) ;
            }catch(Exception e){
                System.out.println("异常产生:" + e) ;
            }
        }
    };
    

    img

    Exception与runtimeException区别

    是面试中经常出现的问题。

    观察以下代码:

    package methoud;
    public class ThisDemo06{
        public static void main(String args[]){
            String str = "123" ;    // 定义字符串,全部由数字组成
            int temp = Integer.parseInt(str) ; // 将字符串变为int类型
            System.out.println(temp * temp) ;    // 计算乘方
        }
    };
    
    public static int parseInt(String s) throws NumberFormatException
    

    此方法明明使用了throws关键字抛出异常,为什么不用处理,也可以编译通过?

    在JAVA异常处理机制中,

    1)如果抛出的是EXception的类型,则必须进行try …catch进行处理。

    2)如果抛出的是RuntimeException的类型,则可以不使用try。。catch处理,一旦发生异常之后,将由JVM处理。

    为了保证程序的健康性,在有可能出现异常的时候还是老实使用try …catch处理。

    自定义异常类

    只需要继承Exception类就可以自定义异常类。因为JAVA中提供的都是标准异常类(包括一些异常信息),如果需要自己想要

    的异常信息就可以自定义异常类。

    class MyException extends Exception{    // 自定义异常类,继承Exception类
        public MyException(String msg){
            super(msg) ;    // 调用Exception类中有一个参数的构造方法,传递错误信息
        }
    };
    public class DefaultException{    
        public static void main(String args[]){
            try{
                throw new MyException("自定义异常。") ;     // 抛出异常
            }catch(Exception e){
                System.out.println(e) ;      //打印错误信息
            }
        }
    }
    运行结果:
    
    methoud.MyException: 自定义异常。
    
    

    总结

    throw与throws关键字联合使用问题。

    1)throw:抛出异常。

    2)throws:在方法声明处使用,表示此方法不处理异常,而在调用此方法处处理异常。

    Exception是必须处理的,而RuntimeException异常是可以不处理的。但是为了保证程序正常运行,最好处理。

    ln(e) ;      //打印错误信息
    }
    }
    }
    运行结果:

    methoud.MyException: 自定义异常。

    
    # 总结
    
    throw与throws关键字联合使用问题。
    
    1)throw:抛出异常。
    
    2)throws:在方法声明处使用,表示此方法不处理异常,而在调用此方法处处理异常。
    
    Exception是必须处理的,而RuntimeException异常是可以不处理的。但是为了保证程序正常运行,最好处理。
    
    如果自定义异常,直接继承异常即可。
    
    展开全文
  • 主要介绍了Java异常处理与throws关键字用法,结合实例形式分析了java常见的异常、错误处理及throws关键字相关使用技巧、注意事项,需要的朋友可以参考下
  • 11.5throws关键字

    2020-03-08 15:57:51
    在程序执行的过程中往往会涉及不同类中方法的调用,而为了方便调用者进行异常的处理,往往会在这些方法声明时对可能产生的异常进行标记,此时就需要throws关键字实现 范例:观察throws关键字的使用 public class ...

    在程序执行的过程中往往会涉及不同类中方法的调用,而为了方便调用者进行异常的处理,往往会在这些方法声明时对可能产生的异常进行标记,此时就需要throws关键字实现
    范例:观察throws关键字的使用

    public class MyMath {
            /**
             * 除法可能出现异常
             */
    	public static int div(int x,int y) throws Exception {
    		return x/y;
    	}
    }
    
    public class Java249 {
           public static void main(String[] args) {
    		try {
    			System.out.println(MyMath.div(10, 2));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    

    执行结果
    5
    本程序在主类中调用MyMath.div()方法实现了除法操作,由于此方法上使用了throws抛出了异常,这样在调用此方法时就必须明确使用异常处理语句处理该语句可能发生的异常

    主方法本身也属于一个java中的方法,所以在主方法上如果使用了throws抛出,就表示在主方法里面可以不用强制性的进行异常处理。如果出现异常,将交给JVM进行默认处理,则会导致程序中断执行。所以在实际开发中,主程序往往是作为程序的起点存在,所有的异常应该在主方法中全部处理完成,而不应该向上抛出。

    展开全文
  • java中throws关键字用法

    千次阅读 2018-11-23 20:38:12
    定义一个方法的时候可以使用throws关键字声明。使用throws关键字声明的方法表示此方法不处理异常,而交给方法调用处进行处理。 throws关键字格式: public 返回值类型 方法名称(参数列表,,,)throws 异常类{}...

    定义一个方法的时候可以使用throws关键字声明。使用throws关键字声明的方法表示此方法不处理异常,而交给方法调用处进行处理。

    throws关键字格式:

    public 返回值类型 方法名称(参数列表,,,)throws 异常类{};

     假设定义一个除法,对于除法操作可能出现异常,可能不会。所以对于这种方法最好将它使用throws关键字声明,一旦出现异常,

    则应该交给调用处处理。

    class Math{
        public int div(int i,int j) throws Exception{    // 定义除法操作,如果有异常,则交给被调用处处理
            int temp = i / j ;    // 计算,但是此处有可能出现异常
            return temp ;
        }
    };
    public class ThrowsDemo01{
        public static void main(String args[]){
            Math m = new Math() ;        // 实例化Math类对象
            try{
                System.out.println("除法操作:" + m.div(10,2)) ;
            }catch(Exception e){        // 处理异常
                e.printStackTrace() ;    // 就打印了异常内容
            }
        }
    };

    展开全文
  • 异常 throws关键字

    2020-01-11 17:16:59
    throws关键字:异常处理的第一种方式,交给别人处理 作用 当方法内部抛出异常对象的时候,那么我们就必须处理异常对象 可以使用throws关键字处理异常对象,把异常对象抛出声明抛出给声明的调用者处理。(自己部处理,...
  • throws关键字和throw关键字的区别主要在于: 1.throws关键字在方法的声明上使用,表示此方法在调用的时候必须处理异常 2.throw关键字指的是在方法中,人为的抛出一个异常(这个异常对象可能是自己实例化,或者是抛出...
  • 工程师培训资料 标题Java培训系列课程-throws关键字精品培训 培训人xx 本章学习目标 了解异常的产生原理 掌握异常处理语句的基本格式 掌握throwthrows关键字的作用 可以自定义异常 了解Exception与RuntimeException...
  • Scala throw throws 关键字

    千次阅读 2018-09-17 03:45:27
    同时也提供了throws关键字来声明异常。可以使用方法定义声明异常。 它向调用者函数提供了此方法可能引发此异常的信息。 它有助于调用函数处理并将该代码包含在try-catch块中,以避免程序异常终止。在scala中,可以...
  • throws关键字 class Math{ public int div(int i,int j)throws Exception{ //throws Exception声明的方法不对此类异常进行处理,而由该方法的调用者负责处理 int temp=i/j; return temp; } } public ...
  • Java中的throws关键字

    千次阅读 2018-03-31 23:06:37
    1. throws关键字 throws关键字主要用于方法声明上,指的是当方法之中出现异常后交由被调用处处理。范例:使用throwsclass MyMath{ //由于存在throws,那么就表示此方法里面产生的异常交给被调用处处理 public ...
  • 主要介绍了详解Java异常处理中throw与throws关键字的用法区别,这也是Java面试题目中的常客,需要的朋友可以参考下
  • throw与throws关键字

    2019-06-05 15:14:15
    throw与throws关键字联合使用问题。 1)throw:抛出异常。 2)throws:在方法声明处使用,表示此方法不处理异常,而在调用此方法处处理异常。 Exception是必须处理的,而RuntimeException异常是可以不处理的。但是...
  • import java.io.FileNotFoundException; import java.io.IOException;...可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理–>中...
  • 10.Java–throws关键字

    2020-08-30 14:51:33
    10.Java–throws关键字 例30中,定义除法运算时,开发者通常会意识到可能出现的异常,可以直接通过try…catch对异常进行捕获处理,但有些时候,方法中代码是否会出现异常,开发者并不明确或者并不急于处理,为此,Java允许将...
  • throws关键字 1.在定义一个方法的时候可以使用throws关键字声明,使用throws声明的方法表示此方法不处理异常,抛给方法的调用者处理。 2.格式:  public void tell()throws Exception{} 例子: ...
  • throws的作用是声明抛出异常,在方法声明的位置上使用throws关键字向上抛出异常。例如下面程序演示了一般性异常,编译无法通过,需要对异常进行处理 import java.io.FileInputStream; public class ExceptionTest{ ...
  • java中throws关键字

    2017-08-31 11:03:25
    throws关键字声明抛出异常,格式如下: 修饰符 返回值类型 方法名(参数) throws ExcepionType1,ExceptionType2..{ } 注意的细节: 1 如果在一个方法内部抛出了一个异常(throw new 异常类型),那么必须在方法上声明...
  • throw关键字(注意区分throws关键字

    千次阅读 2018-05-05 20:01:09
    throw关键字(注意区分throws关键字)throw是直接编写在语句之中的,表示人为进行异常的抛出。例如,在之前使用过了一个10/0这样的语句,而这样的语句执行之后所产生的数学异常是由JVM负责进行异常类的对象实例化了...
  • Throw 与throws关键字

    2017-02-13 08:57:43
    Throw 与throws关键字 1.使用throw抛出一个异常对象:当程序出现异常时,系统会自动抛出异常,除此之外,java也允许程序使用代码自行抛出异常,自行抛出异常使用throw语句完成 2.使用throws声明抛出一个异常序列:...
  • 使用throws关键字声明异常

    千次阅读 2018-05-07 18:46:04
    捕捉,try...catch.. 以下程序演示第一种方式:声明抛出,在方法生命的位置上使用 throws关键字向上抛出异常*/import java.io.*;public class fuck2{ //public static void main(String[] args)thorws ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,668
精华内容 1,067
关键字:

throws关键字