final-finally-finalize

final

final为java关键字, 可以作用于成员变量、方法、类上
1.作用于成员变量上, 基本类型则值不可修改, 如果成员变量为对象, 则该对象的引用不可修改.
2.作用于方法, 该方法不可被重写
3.作用于类, 该类不可继承

finally

异常处理的关键字, 无论异常是否发生, finally内逻辑总会执行.

finally 和 return 的执行顺序

1.一般使用逻辑, return在try-catch-finally之后, 证明, 无论是否异常, finally都会执行

public class MainTest {
    public static void main(String[] args) {
        System.out.println(finallyTest());
    }
    private static String finallyTest() {
        try {
            System.out.println("处理逻辑");
            // int i = 1 / 0;
        } catch (Exception e) {
            System.out.println("异常逻辑");
        } finally {
            System.out.println("finally执行了");
        }
        return "最终return返回";
    }
}

2.在try/catch内添加return
try/catch内的return执行完后会继续执行finally, 但是从打印结果来开, finally的语句先打印, 原因是因为 return的

public class MainTest {
    public static void main(String[] args) {
        System.out.println(finallyTest());
    }
    private static String finallyTest() {
        try {
            System.out.println("处理逻辑");
            // int i = 1 / 0;
            return "try - return返回";
        } catch (Exception e) {
            System.out.println("异常逻辑");
            // return "catch - return返回";
        } finally {
            System.out.println("finally执行了");
        }
        return "最终return返回";
    }
}

输出结果

处理逻辑
finally执行了
try - return返回

3.finally里面添加return语句
finally里面return执行完后会直接返回, 不会再执行try块中的return语句

public class MainTest {
    public static void main(String[] args) {
        System.out.println(finallyTest());
    }
    private static String finallyTest() {
        try {
            System.out.println("处理逻辑");
            // int i = 1 / 0;
            return "try - return返回";
        } catch (Exception e) {
            System.out.println("异常逻辑");
            // return "catch - return返回";
        } finally {
            System.out.println("finally执行了");
            return "finally - return返回";
        }
        // return "最终return返回";
    }
}

执行结果

处理逻辑
finally执行了
finally - return返回

4.finally内添加逻辑改变变量值
1).try中的return值只是暂时放在栈中, 所以最终返回的还是 10, finally中并没有改变其值
2).try中的return值如果是对象, 栈中存放的是对象的引用, 对象属性值还是可以通过finally修改

public class MainTest {
    public static void main(String[] args) {
        System.out.println(finallyTest());
    }
    private static String finallyTest() {
        int temp = 10;
        try {
            System.out.println("处理逻辑");
            return "try - return返回: " + temp;
        } catch (Exception e) {
            System.out.println("异常逻辑");
            // return "catch - return返回";
        } finally {
            temp = 100;
            System.out.println("finally执行了");
        }
        return "最终return返回: " + temp;
    }
}

输出结果

处理逻辑
finally执行了
try - return返回: 10

public class MainTest {
    public static void main(String[] args) {
        Temp temp = new Temp();
        temp.temp = 1;
        System.out.println(finallyTest(temp).toString());
    }
    private static Temp finallyTest(Temp temp) {
        try {
            System.out.println("处理逻辑");
            return temp;
        } catch (Exception e) {
            System.out.println("异常逻辑");
            // return "catch - return返回";
        } finally {
            temp.temp = 100;
            System.out.println("finally执行了");
        }
        return temp;
    }
}
class Temp {
    int temp;
    @Override
    public String toString() {
        return "Temp{" +
                "temp=" + temp +
                '}';
    }
}

打印结果

处理逻辑
finally执行了
Temp{temp=100}

finalize方法

Object类的方法, 子类可重写, 主要是垃圾回收时使用.