关于异常处理,try{}catch{}finally{}与try{} finally{}的区别?

Question

如题!区别就是try{}finally{}能捕获特定异常?另外println()会抛出什么类型的异常?

Answer 1

public static void main(String[] args) {
        try{
            int i=1/0;
        }
        catch(Exception e) {
            System.out.println("在catch里");
        }
        finally {
            System.out.println("在finally里");
        }
    }
//  输出结果：
//    在catch里
//    在finally里try的后面必须接catch或finally或者都接,但不能一个都不接; 
finally的主要作用是在出现异常后无论怎样都要执行finally里的语句. 
而且finally不捕获异常的，他的作用就是无论发不发生异常都会执行,
你可以看看你上面的代码，
刚看了下jdk好像里面没说会抛出什么异常，这个期待高人

Answer 2

没见过println()方法本身报异常有异常也是传入的语句报的。try{}finally{}能捕获特定异常？？就知道catch可以。

Answer 3

这个是不是复制好了的，我怎么老发现同一句话？try{}catch{}finally{}可能可以铺货异常，finally可以作为终结者。
try{}finally{}不能铺货异常，但是finally可作为终结者！

Answer 4

try{}finally{}不能捕获异常
println不抛出checked异常，不需要进行捕获

Answer 5

package javaJieHuo;import java.io.*;public class Arcanel { public static void main(String[] args) {
// TODO Auto-generated method stub
try {
System.out.println("Hello wrod");
} catch (Exception e) {// 
System.out.println("I've never seen println fail");
}// 改成catch(IOException e)则通不过编译
}}

Answer 6

package javaJieHuo;import java.io.*;public class Arcanel {    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            System.out.println("Hello wrod");
        } catch (Exception e) {// 
            System.out.println("I've never seen println fail");
        } 改成catch(IOException e)则通不过编译 怎讲?          }}

Answer 7

Unreachable catch block for IOException. This exception is never thrown from the try statement body

Answer 8

try{
  System.out.println("try");
  throw new Exception("customized exception");
}catch(Exception e){
  System.out.println("catch: " + e.getMessage());
  return; 
}finally{
  System.out.println("finally");
}//输出顺序是啥

Answer 9

1.try+catch
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块去处理。然后执行catch块后面的语句2.try+catch+finally
程序的流程是：运行到try块中，如果有异常抛出，则转到catch块,catch块执行完毕后，执行finally块的代码，如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行catch块后面的语句3.try+finally
程序的流程是：运行到try块中,如果有异常抛出的话，程序转向执行finally块的代码。那末finally块后面的代码还会被执行吗？不会！因为你没有处理异常，所以遇到异常后，执行完finally后，方法就已抛出异常的方式退出了。要注意的是，由于你没有捕获异常，所以要在方法后面声明抛出异常
public class Test1 { /**
 * @param args
 * @throws MyException 
 */
public static void main(String[] args) { //try+finally的方法声明
        //public static void main(String[] args) throws MyException { 
        
// TODO Auto-generated method stub
TestException te = new TestException();

/*
 * try+catch
 * 
try{
te.test();
}catch(MyException e){
e.printStackTrace();
}
System.out.println("after exception");
*/

/*
 * try+catch+finally
 * 
try{
te.test();
}catch(MyException e){
e.printStackTrace();
}finally{
System.out.println("entry finally block");
}
System.out.println("after exception");
*/


/*
 * try+finally
 * 
try{
te.test();
}finally{
System.out.println("entry finally block");
}

System.out.println("after exception");
*/  }}class TestException {
void test() throws MyException{
throw new MyException("illegal invoked");
}
}class MyException extends Exception{
MyException(String msg){
super(msg);
}
}还有一点，不要太在意输出结果的顺序，因为是采用不同的流在输出，所以可能每次执行程序的打印结果顺序都不太相同

Answer 10

我覺得學做程序，沒必要這樣鑽牛角尖吧，覺得他有用的時候再考慮，我看這個就算你知道了也不會在以後寫程序的時候用try  finally，你能指望別人都看得懂啊，誰叫這個寫法不通用
最後還不是用try catch沒多大意義

Answer 11

try{
//有异常
}
   catch(){
//这里抛出
}finally{
//这里不管怎么都会执行的！
}
假如只有try{}finally{}这样有异常会出错的！！

Answer 12

这个解释的比较清楚了，顶！就是在2.try+catch+finally中的最后一句：
如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行catch块后面的语句是不是应为：
如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行finally块后面的语句

Answer 13

try catch （不管有无finally）捕获catch的参数中类型的异常try finally 不捕获，如果有直接崩了，或者被方法throws了

Answer 14

1，顶楼主的钻研精神。
2，try{}一定执行，后面catch{}和finally{}至少跟一个。
3，有catch{}：（1）没有finally{}，有异常就抛出，没有不抛。接着执行catch{}后面的代码
               （2）有finally{}，有异常就抛出，没有不抛。然后执行finally{}然后执行finally{}后面代码            
4，没有catch{}，只有finally{}，如果有异常，抛出异常。执行finally{}，不再执行后面代码。
如果没有异常，不抛，执行finally{}，再执行后面代码。
5，你对println catch IOException报错，catch Exception不报错，不代表它就有一个Exception的子类异常要抛。事实上你对任何语句甚至空语句（即什么都不写，try{}这样）catch Exception都不会报错的，但我们知道并不是所有的语句都会抛出异常。同样，它不提示让你try catch也不代表它没有异常要抛，比如你做5/0，它不会报错，但是运行时会抛ArithmeticException除0异常，这是运行时异常，编译阶段它是检测不到的。

Answer 15

各位大侠：
请问：第二个catch为什么捕获不到第一个catch中抛出的Error呢？？

static void f(int i) {
try 
{
if (i == 0) {
s = s + "0";
System.out.println("try if:" + s);
throw new Exception();
}
s = s + "1";
System.out.println("try " + s); return;
} 
catch (Exception e) {
e.printStackTrace(); s = s + "2";
System.out.println("catch one " + s);
s = s + "3";
System.out.println("catch two" + s);

throw new Error();
}
catch(Error exs){
exs.printStackTrace();
System.out.println("catch第二个" + s); }

finally {

s = s + "4";
System.out.println("finally==" + s);
// throw new RuntimeException();
}
}

Answer 16

 当有多个catch时，
   JVM会先看下异常是否被捕获到，如果被捕获到，忽略下面的catch

Answer 17

throw new Error();
是把异常向上抛，是由上层调用它的代码中去捕获处理，如果也处理不了，可继续往上抛，直到被系统捕获。

Answer 18

CSDN里有一篇笑文，关于擦屁股的楼主可以去看下。