首先让我们搞懂两组概念：try catch finally和return

1.try catch finally

首先说try catch,

（1）try语句 ,try语句用来包围可能出现异常的代码片段. try是发现问题的语句，发现异常后会跳入到catch{}中，如下：

try{

可能出现异常的代码片段

}

（2）catch语句 ,catch语句是用来捕获try语句中出现的异常,并针对该异常解决的.catch语句块可以出现多次.

catch(Exception_Type e){

解决问题的代码片段

}

（3）finally块 ,finally出现在try语句的最后 ,finally块中的语句是必然执行的,无论try中是否出现异常.
finally{

代码片段
}

2.return

两个作用：

（1）一般的就是用在有反回值的方法中，用来返回方法指定类型的值，同时结束方法执行；

（2）也可以用在返回值为void的方法中，用来终止方法运行；return ；

3.对于以上有个基本的认识就不怕搞不懂try catch finally return运行顺序，下面以代码为例：

public static void main(String[] args) {
  String str = null;
  System.out.println(demo(str));
 }

（1）无finally时：

（1.1）

public static String demo(String str){
    try {
        System.out.println(str.charAt(1)); //构造异常
        return "1";

} catch (Exception e) {
        return "2";
    }

}

运行结果：2（无异常返回1，程序结束；出现异常时，返回2，程序结束）

（1.2）

public static String demo(String str){
    try {
        System.out.println(str.charAt(1)); 
    } catch (Exception e) {
        return "2";

}
   return "4";

}

运行结果：2（无异常返回4，程序结束；出现异常时，返回2，程序结束）

（1.3）

public static String demo(String str){
  try {
   System.out.println(str.charAt(1)); 
   return "1";
  } catch (Exception e) {
  }
  return "4";
 }

运行结果：4（无异常返回1，程序结束；出现异常时，程序跳到catch中什么也没做，接着往下运行，return "4",程序结束）

(1.4)

public static String demo(String str){
  try {
   return "1";
  } catch (Exception e) {
  }
  return "4";
 }

运行结果：1（程序自上而下运行, return "1"，程序结束）

其他情况不再一一赘述。。。

（2）有finally时：

（2.1）

public static String demo(String str){

try {
        System.out.println(str.charAt(1)); 
        return "1";
    } catch (Exception e) {
        return "2";
    }
    finally{
       return "3";
    }
}

（2.2）

public static String demo(String str){
    try {
        return "1";
    } catch (Exception e) {
        return "2";
    }
    finally{
        return "3";
    }
}

注意：存在finally时，一单finally里面有return 语句，那么无论之前return过什么（是否出现异常），均被覆盖成finally里面的值(而且，finally里面一旦有return，马上返回，程序结束，不再运行以下的程序)，如上两个例子均返回3：只不过（2.1）是先2后3，（2.2）是先1后3

（3）其他情况：

（3.1）

public static String demo(String str){
    try {
        System.out.println(str.charAt(1)); //异常处
        return "1";
    } catch (Exception e) {
        try {
            throw new Exception(e);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return "2";
   }
}

运行结果：2，这是因为程序在异常处发生异常，直接跳到外层catch{}中，而在catch中尽管又进行了一次try catch,但是程序在catch{}中是自上而下可以运行到return "2";处，返回，程序结束

（3.2）

public static String demo(String str){
    try {
        System.out.println(str.charAt(1)); 
        return "1";
    } catch (Exception e) {
        try {
            throw new Exception(e);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return "2";
  }
  finally{
      return "3";
  }
}

运行结果：3，此运行过程前面与上个例子相同，知道return"2"后面，会跳出外层catch{},运行finally{},在此中遇到return "3",返回，程序结束

以上是我的简单总结，若有错误，欢迎批评指正，转载时请注明作者及来源，谢谢