代码如下
public class Untitled1 {

  public Untitled1() {
  }
  public String test() throws Exception {
    try {
      throw new Exception("Exception");
    }
    catch(Exception e) {
      System.out.println("in catch");
      throw e;
    }
    finally {
      System.out.println("in finally");
      return "return";
    }
  }
  public static void main(String[] args) {
    Untitled1 u1 = new Untitled1();
    try {
      String txttest = u1.test();
      System.out.println("return str is:"+txttest);
    }
    catch (Exception e) {
      System.out.println(e.getMessage());//这里没有执行
    }
  }
}

运行结果是
in catch
in finally
return str is:return

明显
      System.out.println(e.getMessage());//这里没有执行
此句没有被执行。
异常没有被抛出？？
是不是说明如果在finally里有return时异常是抛出不了的？？

finally里面肯定可以设定返回值的，我就习惯这么做
不过若使用了finally，它便会自动屏蔽系统抛出的第二次异常（即向外抛出的那些，在catch里面抛出的异常部分）
这时java系统的一个bug，可以看看关于thinking in java中对这个的解释：

9.6.2 缺点：丢失的违例
一般情况下，Java的违例实施方案都显得十分出色。不幸的是，它依然存在一个缺点。尽管违例指出程序里存在一个危机，而且绝不应忽略，但一个违例仍有可能简单地“丢失”。在采用finally从句的一种特殊配置下，便有可能发生这种情况：

//: LostMessage.java
// How an exception can be lost

class VeryImportantException extends Exception {
  public String toString() {
    return "A very important exception!";
  }
}

class HoHumException extends Exception {
  public String toString() {
    return "A trivial exception";
  }
}

public class LostMessage {
  void f() throws VeryImportantException {
    throw new VeryImportantException();
  }
  void dispose() throws HoHumException {
    throw new HoHumException();
  }
  public static void main(String[] args) 
      throws Exception {
    LostMessage lm = new LostMessage();
    try {
      lm.f();
    } finally {
      lm.dispose();
    }
  }
} ///:~

输出如下：

A trivial exception
        at LostMessage.dispose(LostMessage.java:21)
        at LostMessage.main(LostMessage.java:29)

可以看到，这里不存在VeryImportantException（非常重要的违例）的迹象，它只是简单地被finally从句中的HoHumException代替了。
这是一项相当严重的缺陷，因为它意味着一个违例可能完全丢失。而且就象前例演示的那样，这种丢失显得非常“自然”，很难被人查出蛛丝马迹。而与此相反，C++里如果第二个违例在第一个违例得到控制前产生，就会被当作一个严重的编程错误处理。或许Java以后的版本会纠正这个问题（上述结果是用Java 1.1生成的）。

finally里的方法，在throw方法之前执行，
在你的程序中，因为在finally里有return 语句，他返回了一个正确的结果，所以在MAIN（）里不会有异常。所以，无法看到执行第二个异常

这个很正常啊，test里面的异常已经被处理类，没有抛出到你的main函数了，所以就没有执行
      System.out.println(e.getMessage());//这里没有执行

了。这样才是正常的，要是执行了就不正常了，你对 异常处理机制还不是很了解。

but 异常被抛出两次.throw new Exception("Exception");
                   throw e;

test里面的异常已经被处理了，在main函数里面已经没有异常了，所以是catch 不到的异常的

finally字句阻止了异常的抛出
将finally去掉就正常了
public class Untitled1 {

  public Untitled1() {
  }
  public String test() throws Exception {
    try {
      throw new Exception("Exception");
    }
    catch(Exception e) {
      System.out.println("in catch");
      throw e;
    }
    //finally {
    //  System.out.println("in finally");
    //  return "return";
   // }
  }
  public static void main(String[] args) {
    Untitled1 u1 = new Untitled1();
    try {
      String txttest = u1.test();
      System.out.println("return str is:"+txttest);
    }
    catch (Exception e) {
      System.out.println(e.getMessage());//这里没有执行
    }
  }
}