try catch 和throw以及throws的使用

转载：https://www.cnblogs.com/zhangdaicong/p/6127984.html

try-catch和throw,throws的区别

java里的异常多种多样，这是一种非常有用的机制，它能帮助我们处理那些我们未知的错误，在java里，关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。

1.throw

throw 就是抛出一个异常，并获取这个异常的引用，这个异常会被抛到外部的环境，由外部环境进行处理

class A{
    public void func() throws Exception{
        throw new Exception();
    }
}

这里抛出了一个Exception,Exception是throwable的子类，是所有异常的基类。与此同时,throwable还有另一个子类，也就是Error。

这里会把Exception这个引用抛到外部环境中去处理。

throw跟try...catch...finally的对比：

 

public class  ZeroTest {

    public static  void  main(String[] args) {

     try{

       int i = 100/ 0;

       System.out.print(i);

  }catch(Exception e){

       System.out.print(1);

       throw new  RuntimeException();

  }finally{

       System.out.print(2);

  }

      System.out.print(3);

  }

}

 

  try catch是直接处理，处理完成之后程序继续往下执行，throw则是将异常抛给它的上一级处理，程序便不往下执行了。

本题的catch语句块里面，打印完1之后，又抛出了一个RuntimeException，程序并没有处理它，而是直接抛出，

因此执行完finally语句块之后，程序终止了

 

   首先执行try，遇到算术异常，抛出，执行catch，打印1，然后抛出RuntimeException，缓存异常，执行finally，打印2，然后抛出RuntimeException。

  如果catch中没有抛出RuntimeException，则执行结果为123。

 

2.throws

那我们就不得不说一下throws，其实throws并不是抛出一个实际的Exception而是一个异常声明，它声明这个方法可能会抛出一个异常，注意是可能，所以在没有异常的情况下也是可以用throws的，而throws本身的作用也是用来提高程序的健壮性，反过来，如果这个方法的的确确的有一个异常，那么编译器会强制让你加上throws这个异常声明。

通常throws是写在参数列表的后面，这样就表明这个方法有可能会抛出一个异常

class A{
    public void func() throws Exception{
        throw new Exception();
    }
    
    public void g() throws Exception{
        
    }
}

3.try...catch

当我们在其环境中调用func 和 g的时候，编译器会通知我们需要用一个Try catch程序块来处理这个异常。

这个程序块分两块，第一块是try{} ,第二块是catch(exception的引用){}
try这个程序块很有意思，因为它的名字很易懂，就是尝试，尝试能不能正常的走完整个作用域，如果不能则抛出一个异常。所以我们在try块里经常放上可能会抛出异常的程序段。
而catch恰好就是处理try里抛出来的异常，其中catch的参数列表接收的是一个异常的引用，是throw抛出来的异常的引用，这样我们就可以得到这个异常的对象，倒不如说我们是得到来了这个异常对象的引用，因为在java里，通常我们也只能通过引用来操纵对象。

PS:当 throw new RuntimeException的时候，不用throws

public class Main {
    public static void main(String[] args){
        A a = new A();
        try{
            a.func();
            a.g();
        }
        catch(Exception e){
            System.out.println("捕获了一个异常");
        }
    }
}

我们捕获了func 的异常，因为我们明确的指明func 会抛出一个异常throw new Exception();所以我们这里也会捕获到，并去处理它，所以运行起来我们会看到控制台上会打印“捕获了一个异常”。

尽管g()没有抛出任何的异常，编译器还是要求我们要用try catch把它括起来，是因为它拥有一个throws 异常说明。

 

 

**下面是常见的几种异常，供大家参考：

输入输出异常：IOException
算术异常类：ArithmeticExecption
空指针异常类：NullPointerException
类型强制转换异常：ClassCastException

操作数据库异常：SQLException

文件未找到异常：FileNotFoundException
数组负下标异常：NegativeArrayException
数组下标越界异常：ArrayIndexOutOfBoundsException
违背安全原则异常：SecturityException
文件已结束异常：EOFException
字符串转换为数字异常：NumberFormatException
方法未找到异常：NoSuchMethodException

 

转载：https://www.cnblogs.com/zhao307/p/5560344.html

1：先写个简单的类：

package com.exception.demo;

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
    }

    public void methodTry() {

    }

    public void methodThrow() {

    }
}

初始环境就是这么简答。

2：下面给方法methodTry加上方法主体：

    public static void main(String[] args) {
        Main main = new Main();
        main.methodTry();
    }

    public void methodTry() {
        int a=10;
        int b=0;
        int c=a/b;
    }

刚开始学代码的时候都会写这个方法，会抛出一个异常：

　　

控制台很清楚的告诉我们，被除数不能为0.但是如果我们想自己获取这个异常，然后做些操作呢？比如说 如果这个方法体有问题，我就做一个输出。

    public void methodTry() {
        try {
            int a=10;
            int b=0;
            int c=a/b;
            System.out.println(c);
        } catch (Exception e) {
            System.out.println("这个方法体有问题:"+e.getMessage());
        }
        
    }

这个时候就用到了try-catch，手动的捕获这个异常，然后进行我们需要的操作。毕竟异常分很多种，并不是所有的异常都是我们不需要的。比如说对用户登录来说，登录成功 登录失败两种结果，登录失败又分为重复登录，账号密码不匹配等。我们可以把这些失败全都写成Exception。当成功的时候就直接返回，失败的时候抛出异常，这个可比我们写好多返回值简单多了。

接着说try-catch

　　

我们手动的捕获了这个异常。上面的代码告诉我们，当try-catch块中有异常时，异常后面的代码是不会执行的。try-catch还有什么好处？回滚。

3：throw

    public static void main(String[] args) {
        Main main = new Main();
        main.methodThrow();
    }



    public void methodThrow() {
        throw new Exception("这里有异常");
    }

其实当我简单的抛出个异常的时候，throw new Exception()这里会报错，现在看一个报错信息：

　　

显示让我们选择是throws 还是try-catch。

我们写好的throw是什么意思呢？ 其实跟a/0是一个意思，都是抛出一个异常，只不过一个是jdk已经定义好的异常，被除数不能为0.一个是我们手动抛出的异常。

先用try-catch试试看

　　

    public void methodThrow() {
        try {
            throw new Exception("这里有异常");
        } catch (Exception e) {
            System.out.println("MethodThrow:"+e.getMessage());
        }
    }

　　

重点在于手动抛出异常后，我们要在catch中进行处理，在catch中写我们的部门逻辑代码。

4：throws

刚才我们选择的是try-catch，现在选择throws

    public static void main(String[] args) throws Exception {
        Main main = new Main();
        main.methodThrow();
    }

    public void methodThrow() throws Exception {
        throw new Exception("这里有异常");
    }

方法methodThrow throws Exception之后，他的父类就面临着两种情况，要么try-catch 要么throws这个异常。这种情况跟methodThrow中手动抛出异常遇到的问题是一样的。

看来可以这么理解：

　　throw是手动抛出异常，跟 被除数不能为0 数组下标越界等异常一样，都是异常。

　　try-catch是在catch中手动捕获异常，然后进行一些操作。比如说输出异常信息，打印错误日志等。

　　throws是往上级抛出异常，我的方法methodThrow有异常，但是在这个方法中我不进行处理了，让上级进行处理吧。然后就跑到main函数那去了。对main函数来说，可以throws让系统进行处理，也可以自己处理这个异常啊。main.methodThrow()和a/0 、throw new Execption()没什么区别，都是有异常。

其实可以整体的写：

    public static void main(String[] args){
        Main main = new Main();
        try {
            main.methodThrow();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    public void methodThrow() throws Exception {
        throw new Exception("这里有异常");
    }

方法中的异常，到main函数中再进行处理。

 

 

总结：在程序中有异常的代码被try catch后，后边的代码能够继续执行，如果是throws 出来的，则运行到异常代码处就会停止执行，抛出异常