java中 try return finally return

 finally塊里面的代碼一般都是會執行的，除非執行 System.exit(int)，停止虛擬機，斷電。

1.若try代碼塊里面有return ,假設要return 的值 是A，A為基本類型或者被final修飾的不可變類型（如：基本類型的包裝類型Integer,Double,String ）,並且finally語句塊里面 對try語句塊里面要return 的值A做了修改 比如A+1，但是最終返回的值是不受finally里面對A值操作的影響的。看下面的示例：

1.1范圍值為基本類型

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

    // 基本類型 try 中有return ,finally 中改變值 ,最終返回值 不受finally里代碼影響
    public static int test1(){
        int a =20;
        try {
            System.out.println("test1 try block");
            return a+25;
        } catch (Exception e) {
            System.out.println("test1 catch exception");
        } finally {
           a = a+10;
        }
        return a;
    }

控制台打印輸出：
test1 try block
45

1.2 返回值為基本類型的包裝類型（final）

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

    //final類型（不可變）此時是基本類型的包裝類型  try 中有return ,finally 中改變值 ,最終返回值 不受finally里代碼影響
    public static Integer test3(){
        Integer a =20;
        try {
            System.out.println("test3 try block");
            return a+25;
        } catch (Exception e) {
            System.out.println("test3 catch exception");
        } finally {
            a = a+10;
        }
        return a;
    }

控制台打印輸出：

test3 try block
45

1.3 返回值為String類型（final）

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

    //final類型（不可變）此時是String字符串類型  try 中有return ,finally 中改變值 ,最終返回值 不受finally里代碼影響
    public static String  test4(){
        String a ="中國";
        try {
            System.out.println("test4 try block");
            return a+"_強大繁榮";
        } catch (Exception e) {
            System.out.println("test4 catch exception");
        } finally {
            a = a+"== 強盛！";
        }
        return a;
    }

控制台打印輸出：

test4 try block
中國_強大繁榮

2.若try代碼塊里面有return ,假設要return 的值 是B，B為基本類型或者被final修飾的不可變類型（如：基本類型的包裝類型Integer,Double,String ）,並且finally語句塊里面 對try語句塊里面要return 的值A做了修改 比如A+1，並且返回了值A，但是最終返回的值是受finally塊里面對A值的操作的影響。看下面的示例：

2.1 返回值為基本類型

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

    // 基本類型 try 中有return ,finally 中改變值 並return改變后的值 ,最終返回值 受finally里代碼影響
    public static int test2(){
        int a =20;
        try {
            System.out.println("test2 try block");
            return a+25;
        } catch (Exception e) {
            System.out.println("test2 catch exception");
        } finally {
            return a+5;
        }
    }

控制台打印輸出：

test2 try block
25

2.2 返回值為基本類型的包裝類型（final）

    public static void main(String[] args) {
        System.out.println(test3());
    }
    //final類型（不可變）此時是基本類型的包裝類型  try 中有return ,finally 中改變值 並返回 ,最終返回值 受finally里代碼影響
    public static Integer test3(){
        Integer a =20;
        try {
            System.out.println("test3 try block");
            return a+25;
        } catch (Exception e) {
            System.out.println("test3 catch exception");
        } finally {
           return a+10;
        }
        //return a;
    }

控制台打印輸出：

test3 try block
30

2.3 返回值為String類型（final）

    public static void main(String[] args) {
        System.out.println(test4());
    }
    //final類型（不可變）此時是String字符串類型  try 中有return ,finally 中改變值 並返回,最終返回值 受finally里代碼影響
    public static String  test4(){
        String a ="中國";
        try {
            System.out.println("test4 try block");
            return a+"_強大繁榮";
        } catch (Exception e) {
            System.out.println("test4 catch exception");
        } finally {
            a = a+"== 強盛！";
            return a;
        }
        //return a;
    }

控制台輸出：

test4 try block
中國== 強盛！

3.若try代碼塊里面有return ,假設要return 的值是C，C為引用類型並且是沒有被final修飾的可變類型,並且finally語句塊里面 對try語句塊里面要return 的值A做了修改 ，那么不論finally塊里面是不是返回了C，函數最終的返回結果都會受到finally塊中對C操作的影響。

//定義了一個類型Cat ,引用類型，且是可變類型
class Cat{
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

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

    //對於引用類型對象（非final）的， try 中有return ,finally 中改變值 ,最終返回值 受finally里代碼影響
    public static Cat test5(){
        Cat cat = new Cat("tom",12);
        try {
            return cat;
        } catch (Exception e) {

        } finally {
           cat.setName("mouse");
            cat.setAge(13);
        }
        return cat;
    }

控制台輸出：

Cat{name='mouse', age=13}

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

    //對於引用類型對象（非final）的， try 中有return ,finally 中改變值 並return ,最終返回值 受finally里代碼影響
    public static Cat test6(){
        Cat cat = new Cat("tom",12);
        try {
            return cat;
        } catch (Exception e) {

        } finally {
 cat.setName("mouse");
            cat.setAge(13);
            return cat;
        }
        // return cat;
    }

控制台輸出：

Cat{name='mouse', age=13}

4.總結

當返回值為基本類型或者被final修飾的不可變類型時，基本類型返回的就是值，被final修飾的不可變類型，對其進行修改，就變成了另外一個對象了，對源對象沒有影響；

當返回值為引用類型並且是沒有被final修飾的類型時，返回的是該對象的地址，對該對象進行修改，那就真正的修改了；