面试之final、finally 和finalize区别

面试回答总结：
（1）被 final 修饰的类不可以被继承
（2）被 final 修饰的方法不可以被重写
（2）被 final 修饰的变量不可以被改变：

• 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改， final 修饰的常量,在编译阶段会存入常量池中；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象,引用变量所指向的对象中的内容还是可以改变的

---

---

---

在java中，final表示最终的，不可更改的。final关键字可以用来修饰类、方法、变量（包括成员变量和局部变量.

final关键字主要用在三个地方：类、方法、变量：

1.对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改， final 修饰的常量,在编译阶段会存入常量池中；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象,引用变量所指向的对象中的内容还是可以改变的.

2.当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

3.使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

Final修饰有啥好处：
1.final的关键字提高了性能，JVM和java应用会缓存final变量；
2.final变量可以在多线程环境下保持线程安全；
3.使用final的关键字提高了性能，JVM会对方法变量类进行优化；

（1）被 final 修饰的类不可以被继承：

2.final 用来修饰一个类：表明这个类不能被继承，（表示此类是最终的一个类，不能有孩子了）。
final类中的成员变量可以根据需要设为final，但是final类中的所有成员方法都会被隐式地指定为final方法。注意：在使用final修饰类的时候，一定要谨慎选择，除非这个类以后不会用来继承或者出于安全考虑，尽量不要将类设计为final类。
比如：String,System类，StringBuffter类。

（2）被 final 修饰的方法不可以被重写：

final修饰的方法不能被重写：表示是最终的方法，不能去延续拓展了（即不能被重写修改了）

如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。即父类的final方法是不能被子类所覆盖的，也就是说子类是不能够存在和父类一模一样的方法的。

final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。（注：类的private方法会隐式地被指定为final方法）

class Animal{
    /**
     * 因为private修饰，子类中不能继承到此方法，因此，子类中的getName方法是重新定义的.
     * 属于子类本身的方法，编译正常.
     */
    private final void getName() {}

    /**
     *  因为pblic修饰，子类可以继承到此方法，导致重写了父类的final方法，编译出错.
     */
//  public final void getName() {}
}

class Cat extends Animal {
    public static void main(String[] args) {

    }

    public void getName() {}
}

注意一些方法是native:表明底层要调用c/c++的一些代码

（3）被 final 修饰的变量不可以被改变：

对于final修饰的变量来说，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的，也就是说在对其初始化之后便不能再让其指向另一个对象。

final用来修饰一个变量：此时的“变量”就称为是一个常量。

Java语言支持的变量类型有：

类变量：在java中，类变量（也叫静态变量）是类中独立于方法之外的变量，用static 修饰
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

情况 一.final 修饰类变量：

对于final类变量而言，同样必须显示指定初始值，而且final类变量只能在2个地方指定初始值：

1. 定义final类变量时指定初始值；
2. 在静态初始化块中为final类变量指定初始值；

这两种方式都会被抽取到静态初始化块中赋初始值。定义final类变量时指定初始值和在静态初始化块中为final类变量指定初始值，本质是一样的。除此之外final类变量将不能被再次赋值。

@Data
public class Student {

    // 类变量
    private static final Integer id = 1;
    // 学生姓名
    private String stuName;
}

测试代码：

public class Fun {
    public static void main(String[] args) {
        // 获取对象
        Student student = new Student();
        System.out.println(student);
    }
}

我们测试后能正常输出。

情况二.final 修饰实例变量：

1. 被final修饰的实例变量必须显示的指定初始值。
2. 对于普通实例变量，Java程序可以对它执行默认的初始化，也就是将实例变量的值指定为默认的初始值0或null，但对于final修饰的实例变量，则必须由程序员显示的赋予初始值。
3. final实例变量必须显示地被赋初始值，而且本质上final实例变量只能在构造器中被赋初始值。

在定义final实例变量时指定初始值，和在初始化块中为final实例变量指定初始值本质上是一样的。除此之外，final实例变量将不能被再次赋值。

final修饰一个实例变量，必须要显示初始化。这里有三种初始化方式，一种是在变量声明的时候初始化；第二种是在代码块中进行初始化，第三种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。

可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化。

情况 三.final 修饰局部变量：

final修饰的局部变量一样需要被显式地赋初始值，因为Java本来就要求局部变量必须被显式地赋初始值。与普通变量不同的是，final修饰的局部变量被赋初始值之后，将不能再被重新赋值。

2.1方法内定义的局部变量是final修饰的：不能再使用变量进行赋值操作等。

2.2方法形参是final修饰的：则在方法中只能对此参数进行调用，不能再做其他操作了。否则编译不通过。

尤其是使用final修饰形参时，表明此形参是一个常量，当我们调用此方法的时候，给常量形参赋一个实参，一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

（了解）final修饰变量另解：

一、修饰变量
修饰变量是final用得最多的地方.
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。

final修饰一个成员变量（属性），必须要显示初始化。这里有三种初始化方式，一种是在变量声明的时候初始化；第二种是在代码块中进行初始化，第三种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。

代码演示：

class Animal {
    private final int count = 0;
    public Animal() {
        count = 1; //报错
        final Object object = new Object();
        object = new Object(); //报错
    }
}

1、类的final变量和普通变量有什么区别？

当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。
那么final变量和普通变量到底有何区别呢？下面请看一个例子：

public class Test {
    public static void main(String[] args) {
        String a = "helloworld";
        final String b = "hello";
        String c = "hello";
        String x = b + "world";
        String y = c + "world";
        System.out.println(a == x);
        System.out.println(a == y);
    }
}

输出结果：true ; false

大家可以先想一下这道题的输出结果。为什么第一个比较结果为true，而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中，由于变量b被final修饰，因此会被当做编译器常量，所以在使用到b的地方会直接将变量b 替换为它的值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了，final 修饰的常量,在编译阶段会存入常量池中，不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化，，比如下面的这段代码就不会进行优化：

public class Test {
    public static void main(String[] args) {
        String a = "helloworld";
        final String b = getHello();
        String x = b + "world";
        System.out.println(a == x);
    }
    public static String getHello() {
        return "hello";
    }
}

这段代码的输出结果为false。这里要注意一点就是：不要以为某些数据是final就可以在编译期知道其值，通过变量b我们就知道了，在这里是使用getHello()方法对其进行初始化，他要在运行期才能知道其值。

finally 和finalize 和final的区别

• final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。

• finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码放在finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。

• finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，在垃圾回收器执行时会调用回收对象的finalize方法，一旦垃圾回收器准备好释放对象占用的空间，将会首先调用其finalize方法，并且在下一次垃圾回收动作发生时，才会真正的回收对象占用的内存。

static final的区别使用

可以用来修饰属性：称为全局常量/静态常量；
static final修饰方法比较少；

static表示随着类的加载而加载，并且只加载一次，只存在一份，为所有对象所共享。
final修饰的表示最终的不可更改的。
比如身份证。我们每个人的都不一样(非static)，但是我们每个人的身份证号不能去修改（final修饰）,这时候我们就可以通过构造器给每个人赋值不同的身份证号。

案例说明：