final、finally、finalize

final

final是一个修饰符，也是一个关键字

final关键字是最终的意思，可以修饰成员方法、变量、类。

final修饰的特点

• 修饰方法：表明该方法是最终方法，不能被重写。
• 修饰变量（成员变量，局部变量）：表明该变量是常量，不能再次被赋值。
• 修饰类：表明该类是最终类，不能被继承。

修饰局部变量

• 变量是基本类型：final修饰指的是基本类型的数据值不能发生改变。
• 变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的。

修饰方法

父类

public class Final {
     void method1() {
        System.out.println("method1");
    }

     final void method2() {
        System.out.println("method2");
    }
}

子类

public class FinalExtend extends Final {

    @Override
    void method1() {
        System.out.println("method11");
    }
    //错误！不能覆盖重写父类当中的方法
/*    @Override
    final void method2() {
        System.out.println("method22");
    }*/
}

测试

public class FinalClassDemo {
    public static void main(String[] args) {
        FinalExtend finalExtend = new FinalExtend();
        finalExtend.method1();
        finalExtend.method2();
    }
}

# 结果打印
//method11
//method2

修饰变量

局部变量

    public static void main(String[] args) {
        //基本数据类型
        final Integer id1;
        Integer id2;
        id1 = 1;
        //id1 = 2; 报错
        id2 = 3;
        id2 = 4;
        System.out.println(id1);
        System.out.println(id2);

        //引用类型
        final Student student = new Student();
        student.setName("name1");
        System.out.println(student.getName());
        System.out.println(student);
        student.setName("name2");
        System.out.println(student.getName());
        System.out.println(student);
    }

# 结果打印
1
4
name1
finalStudy.Student@1540e19d
name2
finalStudy.Student@1540e19d

成员变量

public class Student {
    private final Integer id=10;

    private String name ;

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

对于final修饰的变量，必须有默认值。要不直接赋值，要不使用构造方法赋值。不可写set方法。

修饰类

finally

finally是一个关键字，保证重点代码一定被执行的一种机制。

• finally在异常处理时提供finally来执行任何清除操作，不管有没有异常被抛出或者捕获，finally块都会执行，通常用于释放资源。
• finally块中如果有return语句，会覆盖try或catch中的return语句。
• 关闭JDBC连接、保证unlock锁操作等

public class FinallyTest {
    public static void main(String[] args) {
        method1();
        System.out.println("method1执行结束=========");
        System.out.println("-----------------------------");
        String s2 = method2();
        System.out.println("method2返回=========" + s2);
        System.out.println("-----------------------------");
        String s3 = method3();
        System.out.println("method2返回=========" + s3);
        System.out.println("-----------------------------");
    }
    private static void method1() {
        try {
            System.out.println("开始执行");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("出现异常");
        } finally {
            System.out.println("finally执行");
        }
    }

    private static String method2() {
        try {
            System.out.println("开始执行2");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("出现异常2");
            return "异常返回2";
        } finally {
            System.out.println("finally执行2");
        }
    }
    private static String method3() {
        try {
            System.out.println("开始执行3");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("出现异常3");
            return "异常返回2";
        } finally {
            System.out.println("finally执行3");
            return "finally返回2";
        }
    }
}

开始执行
出现异常
finally执行
method1执行结束=========
-----------------------------
开始执行2
出现异常2
finally执行2
method2返回=========异常返回2
-----------------------------
开始执行3
出现异常3
finally执行3
method2返回=========finally返回2
-----------------------------

不可执行的三种情况

1. try-cach 异常退出。
try{
system.exit(1)
}finally{
print(abc)
}

2. 无限循环
try{
  while(ture){
    print(abc)
  }
}finally{
print(abc)
}

3. 线程被杀死
当执行 try，finally 的线程被杀死时。finally 也无法执行。

finalize

finalize 是基础类 java.lang.Object 的一个方法，它的设计目的是保证对象在被垃圾收集前完成特定资源的回收。finalize 机制现在已经不推荐使用，并且在 JDK 9 开始被标记为 deprecated。