精华内容
下载资源
问答
  • throw和throws

    2021-01-01 19:41:44
    throw和throws 概述 Throw: 1、作用在方法内,表示抛出具体异常,由方法体内的语句处理。 2、具体向外抛出的动作,所以它抛出的是一个异常实体类。若执行了Throw一定是抛出了某种异常。 3、throw一旦进入被执行,...

    throw和throws

    概述

    Throw:

    1、作用在方法内,表示抛出具体异常,由方法体内的语句处理。

    2、具体向外抛出的动作,所以它抛出的是一个异常实体类。若执行了Throw一定是抛出了某种异常。

    3、throw一旦进入被执行,程序立即会转入异常处理阶段,后面的语句就不再执行,而且所在的方法不在返回有意义的值。

    Throws:

    1、作用在方法的声明上,表示如果抛出异常,则由该方法的调用者来进行异常处理。

    2、主要声明这个方法会抛出某种异常的类型,让它的使用者知到捕获异常的类型。

    3、异常可能出现,也可能不出现。

    区别

    Throws是用来声明一个方法可能抛出的所有异常信息,Throws是将异常声明倒是不处理,而是将异常往上传,谁调用就交给谁处理。

    Throw是指抛出一个具体的异常类型。

    Throws用法

    public void test() throws 异常1,异常2,异常3{

    }

    • 任何方法都可以使用throws关键字声明异常类型,包括抽象方法。
    • 子类重写父类中的方法,子类方法不能抛出比父类更大的异常。
    • 使用了throws的方法,调用时必须处理声明的异常,要么try-catch,要么继续使用throws声明。
    • 抽象方法也可以使用throws。

    Throw用法

    语法: throw new 异常构造类方法

    如:throw new RunTimeException();

    public static void someMethod(){

    if(1==1){

    throw new RuntimeException(“错误原因”);

    ​ }

    }

    • throw关键字用于显式抛出异常,抛出的时候是抛出一个异常类的实例化对象。

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

    自定义异常

    public class Demo6 {
        public static void main(String[] args) {
             /*
              throws
                   作为在方法的声明,此方法可能会出现异常
                   throws 后面声明多个异常类型, 多为编译期异常
    
              throw
                  在方法中主动抛出 异常对象, 相当于程序出现异常情况,后面的程序不执行
                  在不满足条件的情况下以抛出异常的形式告诉调用处.
    
              自定义异常
                  由于java中封装的异常类都是与语法相关的.
                  在我们业务中出现一些不满足条件的情况时,也可以自定义异常类,来表示某种情况
             */
    
            try{
                test(101);
            }catch(ScoreExpection e){
                e.printStackTrace();
                System.out.println(e.getMessage());
            }
    
        }
        public static int test(int s) throws ScoreExpection {
            if (s < 0 || s>100){
                throw new ScoreExpection("分数不合法");//在程序中主动抛出异常对象,在构造方法中可以传入异常原因
            }
            return s;
        }
    }
    
    
    public class ScoreExpection extends Exception {
    
        public ScoreExpection() {
    
        }
    
        public ScoreExpection(String message) {
            super(message);
        }
    }
    
    
    展开全文
  • Throw和Throws

    2019-09-28 05:36:15
    位置:Throw在方法体内部,Throws在方法名后 作用:Throw是用来抛出异常,Throws是用来声明异常 个数:Throw一次只能抛出一个异常,Throws一次可以声明多个异常 转载于:...
    • 位置:Throw在方法体内部,Throws在方法名后
    • 作用:Throw是用来抛出异常,Throws是用来声明异常
    • 个数:Throw一次只能抛出一个异常,Throws一次可以声明多个异常

    转载于:https://www.cnblogs.com/zbzb1/p/11531535.html

    展开全文
  • throw throws

    2019-11-13 19:17:14
    throws 抛出异常,让调用者处理 public class TestException { public static void main(String[] args) { method1(); } private static void method1() { try { method2(); ...

    throws

    抛出异常,让调用者处理

    public class TestException {
     
        public static void main(String[] args) {
            method1();
     
        }
     
        private static void method1() {
            try {
                method2();
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
     
        }
     
        private static void method2() throws FileNotFoundException {
     
            File f = new File("d:/LOL.exe");
     
            System.out.println("试图打开 d:/LOL.exe");
            new FileInputStream(f);
            System.out.println("成功打开");
     
        }
    }
    

    中 方法2 就抛出了 FileNotFoundException, 在方法1 调用 方法2 是就处理了该异常,当然,方法1 仍旧可以继续抛出

    public class TestException {
     
        public static void main(String[] args) throws FileNotFoundException {
            method1();
        }
     
        private static void method1() throws FileNotFoundException {
            method2();
        }
     
        private static void method2() throws FileNotFoundException {
     
            File f = new File("d:/LOL.exe");
     
            System.out.println("试图打开 d:/LOL.exe");
            new FileInputStream(f);
            System.out.println("成功打开");
     
        }
    }
    

    throw

    引发一个异常,一般用于创建自定义异常

    例如:如果年龄低于18 岁,则引发异常(“未成年人拒接访问”)。如果年龄在18岁或以上,输出“可以访问”:

    public class MyClass {
      static void checkAge(int age) {
        if (age < 18) {
          throw new ArithmeticException("未成年人拒接访问");
        }
        else {
          System.out.println("可以访问");
        }
      }
    
      public static void main(String[] args) {
        checkAge(15); 
      }
    }
    

    throw 和 throws 的区别

    从本质上来说,throw 和 throws 完全是两个东西

    throw 是引发一个异常,是指在此处会触发一个异常,比如上面的例子,年龄低于18岁就会触发一个异常,就像你在执行:

    public static void main(String[] args) 
        { 
            System.out.println(1/0); 
        } 
    

    会触发 ArithmeticException: / by zero 一样

    throws 是抛出异常,是指在一段可能会引发异常的代码中,不对异常进行处理而将异常交给调用者处理

    当然 throws 也能抛出 throws 引发的异常,如:

    public class Test {
    	static void checkAge(int age) throws ArithmeticException {
    		if (age < 18) {
    			throw new ArithmeticException("未成年人拒接访问");
    		} else {
    			System.out.println("可以访问");
    		}
    	}
    
    	public static void main(String[] args) {
    		try {
    			checkAge(15);
    		} catch (ArithmeticException e) {
    			System.out.print("你是未成年人");
    		}
    	}
    }
    

    中程序输入的是 你是未成年人, 而非 未成年人拒接访问 ,说明 我们在 checkAge 中引发的异常 ArithmeticException("未成年人拒接访问")main 方法中tyr catch 捕获

    展开全文
  • throw throws 的区别?

    万次阅读 多人点赞 2019-05-30 10:02:58
    throw throws 的区别? throw: 表示方法内抛出某种异常对象 如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出 即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常,否则...

    throw 和 throws 的区别?

    throw:

    • 表示方法内抛出某种异常对象
    • 如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出 即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常,否则编译报错
    • 执行到 throw 语句则后面的语句块不再执行

    throws:

    • 方法的定义上使用 throws 表示这个方法可能抛出某种异常
    • 需要由方法的调用者进行异常处理
    package constxiong.interview;
    
    import java.io.IOException;
    
    public class TestThrowsThrow {
    
    	public static void main(String[] args) {
    		testThrows();
    		
    		Integer i = null;
    		testThrow(i);
    		
    		String filePath = null;
    		try {
    			testThrow(filePath);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 测试 throws 关键字
    	 * @throws NullPointerException
    	 */
    	public static void testThrows() throws NullPointerException {
    		Integer i = null;
    		System.out.println(i + 1);
    	}
    	
    	/**
    	 * 测试 throw 关键字抛出 运行时异常
    	 * @param i
    	 */
    	public static void testThrow(Integer i) {
    		if (i == null) {
    			throw new NullPointerException();//运行时异常不需要在方法上申明
    		}
    	}
    	
    	/**
    	 * 测试 throw 关键字抛出 非运行时异常,需要方法体需要加 throws 异常抛出申明
    	 * @param i
    	 */
    	public static void testThrow(String filePath) throws IOException {
    		if (filePath == null) {
    			throw new IOException();//运行时异常不需要在方法上申明
    		}
    	}
    }
    

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • throw和throws的区别

    2020-03-15 15:41:53
    throw和throws的区别
  • 主要介绍了Java throw和throws使用区别分析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • throw和throws区别

    2020-05-13 16:24:54
    throw和throws区别 throw:生成一个异常对象,并抛出。使用在方法内部。对应自动抛出异常对象。 throws:处理异常的方式。使用在方法声明处的末尾。对应 try-catch-finally
  • Java throw和throws区别

    2020-08-05 15:18:38
    Java throw和throws区别 throw和throws的区别: throw用在函数内。throws用在函数上。 thorw抛出的是异常对象。throws用于进行异常类的声明,后面异常类可以有多个,用逗号隔开。 throw 异常对象(); public ...
  • Java之throw和throws的区别 Java中关键字throw和throws的区别
  • Throw和Throws详解

    2020-04-19 17:51:11
    Throw和Throws详解 ​ 1.throw是什么?有什么用? ​ throw是java中关于异常的一种操作,如果在try{}catch{}中使用了throw,就代表自己书写的这个方法,可以自己 处理异常了,就是抛出的一个动作,可以使程序停止并...
  • 详述throw和throws

    2019-08-07 18:48:16
    五.throw和throws比较 一.封装 详述见博客:java封装 我们先在vo包中创建一个vo类,它的机理是当超出赋值范围时输出“年龄无效”提示调用者: package com.jd.vo; public class Student { private int age...
  • 主要介绍了简单了解Java关键字throw和throws的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

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

throw和throws