1.final

final是java中的修饰符，用于修饰属性（变量）、方法、类。

1.被final修饰的变量不可以被改变,如果修饰引用,那么表示引用不可变,引用指向的内容可变. 被修饰的常量,在编译阶段会存入常量池中.

2.被final修饰的方法不可以被重写, 被修饰的方法,JVM会尝试将其内联,以提高运行效率

3.被final修饰的类不可以被继承

public class Solution {
    //1.修饰类变量：
    //如果final修饰的是类变量，只能在静态初始化块中指定初始值或者声明该类变量时指定初始值。
    final static int a = 1;//在声明的时候赋值

    final static int b;
    static {//或者静态代码块赋值
        b=2;
    }

    //2.修饰成员变量：
    //如果final修饰的是成员变量，可以在⾮静态初始化块、声明该变量或者构造器中执⾏初始值。
    final int num1=1;//声明时赋值

    final int num2;
    {//⾮静态初始化块中赋值
        num2=1;
    }

    final int num3;
    //构造方法中赋值
    Solution(){
        num3=5;
    }


    public static void main(String[] args){
    //3.修饰局部变量
        //局部变量必须由程序员显示初始化。因此使⽤final修饰局部变量时，
        // 可以在定义时指定默认值（后⾯的代码不能对变量再赋值），
        final int x=10;
        // 也可以不指定默认值，⽽在后⾯的代码中对final变量赋初值（仅⼀次）
        final int y;
        y=15;//只能被赋值零次或一次, 所以不写该行代码也不会报错
    }
}

//如果final修饰的是引⽤类型的变量，则在对其初始化之后便不能再让其指向另⼀个对象。
//但是引⽤的值是可变的。
public class FinalReferenceTest{
	public static void main(){
		final int[] iArr={1,2,3,4};
		iArr[2]=-3;//合法
		iArr=null;//⾮法，对iArr不能重新赋值
		final Person p = new Person(25);
		p.setAge(24);//合法
		p=null;//⾮法
	}
}

2.finally

finally是在异常处理中的使用的,搭配try, catch使用

try {
	//异常捕获
} catch (Exception e) {
	//处理异常
}finally{
	//必须执行的代码，如close方法等
}

1.如果 try 语句块正常,那么在 try 语句块中的语句都执行完之后,再执行 finally 语句块.
2.不管 try 语句块正常结束还是异常结束,finally 语句块都是会执行的.
3.当try和catch中有return时,finally仍然会执行;
4.finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,无论finally中的代码怎么样,返回的值都不会改变,仍然是之前保存的值),所以函数返回值是在finally执行前确定好的;
5.finally中最好不要包含return,否则程序会提前退出,返回值不是try或catch中保存的返回值.

1.如果 try 语句块正常,那么在 try 语句块中的语句都执行完之后,再执行 finally 语句块.

public static void main(String[] args){
        try {
            //异常捕获
            System.out.println("start");
            System.out.println("step1");
        } catch (Exception e) {
            //处理异常
            System.out.println("异常信息:"+e);
        }finally{
            //必定执行的代码
            System.out.println("ok");
        }
    }

2.不管 try 语句块正常结束还是异常结束,finally 语句块都是会执行的.

    public static void main(String[] args){
        try {
            //异常捕获
            System.out.println("start");
            int a=10/0;
            System.out.println("step1");
        } catch (Exception e) {
            //处理异常
            System.out.println("异常信息:"+e);
        }finally{
            //必定执行的代码
            System.out.println("ok");
        }
    }

3.当try和catch中有return时,finally仍然会执行;

4.finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值,而是先把要返回的值保存起来,无论finally中的代码怎么样,返回的值都不会改变,仍然是之前保存的值),所以函数返回值是在finally执行前确定好的;

5.finally中最好不要包含return,否则程序会提前退出,返回值不是try或catch中保存的返回值.

    public static int fun(){
        int a=10;
        try {
            //异常捕获
            return a;
        } catch (Exception e) {
            //处理异常
            System.out.println("异常信息:"+e);
        }finally{
            //必定执行的代码
            a=6;
            System.out.println("ok");
        }
        return 0;
    }

    public static void main(String[] args){
        int a=fun();
        System.out.println(a);
    }

3.finalize

finalize() 是Java中Object的一个protected方法.返回值为空,当该对象被垃圾回收器回收时,会调用该方法.

关于finalize()函数

1.finalize不等价于c++中的析构函数;
2.对象可能不被垃圾机回收器回收;
3.垃圾回收不等于析构;
4.垃圾回收只与内存有关;
5.垃圾回收和finalize()都是靠不住的,只要JVM还没有快到耗尽内存的地步,它是不会浪费时间进行垃圾回收的;
6.程序强制终结后,那些失去引用的对象将会被垃圾回收.(System.gc())

finalize()的用途:比如当一个对象代表了打开了一个文件,在对象被回收前,程序应该要关闭该文件,可以通过finalize函数来发现未关闭文件的对象,并对其进行处理.

public class FileOperator {

    private boolean closed = false;

    void close(){
        this.closed = true;
    }

    @Override
    protected void finalize(){//当垃圾回收器企图回收本对象时，会调用该方法,该方法是重写父类的方法的
        if(!closed){//如果文件没有被关闭，
            System.out.println("Error: A File was not closed . Name:" + this);
            this.closed = true;
        }
    }

    public static void main(String[] args) {
        FileOperator fileOperator = new FileOperator();//有引用的对象，不会被虚拟机回收
        new FileOperator();//匿名对象，会被虚拟机回收
        System.gc();//强制进行终结动作
    }
}