知识点：
1、final关键字用于修饰类、变量和方法
2、有点类似C#里的 sealed 关键字，用于表示它修饰的方法、变量和类不可以再被改变
3、final修饰变量时，表示该变量一旦获取了初始值，就不可以再被改变
4、final可以修饰成员变量（包括类变量、实例变量），也可修饰局部变量、形参
5、有的书上说final修饰的变量不能被赋值，这是错误的，严格的说，fanal修饰的变量，一旦被赋值就不可再次赋值改变
6、因为final修饰的变量赋值后不可再被改变，所以final修饰的成员变量和局部变量有一些不同
一、final修饰成员变量：
1、成员变量是随类的初始化（类变量）或类对象实例的初始化（实例变量）而初始化的
2、当类初始化时，系统会为类变量分配内存，并赋初始值；当类对象初始化时，系统会为实例变量分配内存，并赋初始值
3、当执行类静态初始化块时，系统可以为类变量赋初始值，当执行类普通初始化块、构造器时，系统可以为实例变量赋初始值
4、因此，成员变量可以在定义变量时赋初始值，也可以在静态初始化快、普通初始化块、构造器内给赋初始值
5、对于final修饰的成员变量而言，一旦有了初始值，就不可再次赋值
6、如果既没有在定义成员变量时赋初始值，也没有在初始化块、构造器中赋初始值，那么这些成员变量就失去了意义，因为不能在普通方法中为final修饰的成员变量赋值
7、因此Java规定，final修饰的成员变量必须由程序员显示的赋初始值
final修饰成员变量赋初始值归纳如下：
类变量：必须在静态初始化块中赋初始值，或在声明该类变量时赋初始值，而且只能在这两个地方其中一个进行
实例变量：必须在普通初始化块、声明该实例变量时、构造器中赋初始值，而且只能在这三个地方其中的一个进行
实例变量不能在静态初始化块中赋初始值，原因参上
类变量不能在普通初始化块、构造器中赋初始值，原因参上
代码示例：
public class FinalVariableTest{
//-定义实例变量时赋初始值，合法
public final int a=6;
//-定义实例变量时，先不赋初始值，放在普通初始化块或构造器中赋初始值，合法
public final String str;
public final int c;
//-定义类变量时，先不赋初始值，放到静态初始化块中赋初始值，合法
public final static double d;
//-定义实例变量，先不赋初始值，但是后面的普通初始化块、构造器中都没有赋初始值，不合法
//public final char ch;
static{
//-静态初始化块内，给类变量赋初始值，合法
d=5.5;
}
{
//-普通初始化块内，给未付初始值的实例变量赋初始值，合法
str="hello";
//-普通初始化块内，给已经赋初始值的实例变量赋值，不合法
//a=9;
}
public FinalVariableTest(){
//-构造器内，对已经在普通初始化快内赋值的实例变量再次赋值，不合法
//str="java";
//-构造器内，给未赋初始值的实例变量赋初始值，合法
c=5;
}
public void changFinal(){
//-普通方法内，给final修饰符修饰过的成员变量赋值，违法
//d=1.2;
//ch='A';
}
public static void main(String[] args){
FinalVariableTest fin=new FinalVariableTest();
System.out.println(fin.a);
System.out.println(fin.c);
System.out.println(fin.d);
System.out.println(fin.str);
}
}
运行结果：
如果要在初始化块或构造器中给final成员变量赋初始值，则不能在初始化之前就访问该成员变量，否则会报错：
public class FinalErrorTest{
//-定义一个final修饰的实例变量，未付初始值，合法
//-而且系统不会为final修饰的变量赋初始值
public final int age;
{
//-age实例变量未赋初始值，直接输出不合法，会报错
//-如果把修饰符final去掉，则下面输出就合法了
//System.out.println(age);
//-在普通初始化块中，给未赋初始值的、final修饰的实例变量赋初始值，合法
age=3;
//-已经赋初始值，输出合法
System.out.println(age);
}
public FinalErrorTest(){
}
public static void main(String[] args){
FinalErrorTest fin=new FinalErrorTest();
}
}
二、final修饰局部变量：
1、系统不会为局部变量进行初始化
2、局部变量必须由程序员显式初始化
3、final修饰的局部变量，可以在声明时赋初始值，也可以在后面赋值，但只能赋值一次。
4、final修饰的形参，不能被赋值、修改，因为形参是方法在调用的时候，根据传入的参数来完成初始化，所以不能再次赋值
代码示例：
public class FinalLocalVariableTest{
public void test(final int a){
//-final修饰的形参，不能被赋值、修改
//-因为形参是方法在调用的时候，根据传入的参数来完成初始化，所以不能再次赋值,下面代码编译会报错
//a=5;
}
public static void main(String[] args){
final String str="hello";
//-final 修饰的 str 变量声明时已经赋值，不能再次被赋值，下面代码编译会报错
//str="java";
final double b;
b=3.6;
//-final 修饰的 b 变量已经赋值，不能再次被赋值，下面代码编译会报错
//b=6.5;
System.out.println(str);
}
}
运行结果：
final修饰基本类型变量，和引用类型变量的区别：
1、final修饰基本类型变量时，不能对基本类型变量重新赋值，因为基本类型变量不能被改变
2、对于引用类型变量而言，保存的仅仅是一个引用地址，final只是保证这个引用地址不被改变，而引用指向的对象完全可以改变
import java.util.Arrays;
class Penson{
private int age;
public Penson(){
}
public Penson(int age){
this.age=age;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
}
public class FinalReferenceVariable{
public static void main(String[] args){
//-final 修饰的 array 引用变量是一个数组
final int[] array={5,69,8,6};
//-输出数组
System.out.println(Arrays.toString(array));
//-给数组重新排序，没改变array引用的地址，还是指向这个数组对象，所以合法
Arrays.sort(array);
System.out.println(Arrays.toString(array));
//-改变数组内的某个值，没改变array引用的地址，还是指向这个数组对象，所以合法
array[2]=-8;
System.out.println(Arrays.toString(array));
//-改变了array引用变量的地址，所以非法，编译报错
//array=null;
//-final修饰的p对象，是一个Penson实例对象
final Penson p=new Penson(23);
//-修改了p对象中的age变量，但是p对象引用没改变，还是指向p对象，所以合法
p.setAge(30);
System.out.println(p.getAge());
//-修改了p对象的引用地址，所以非法，编译报错
//p=null;
}
}
运行结果：
总结：final 修饰的引用变量不能被重新赋值，但是引用变量所指向的对象内容完全可以改变
可执行宏替换的 final 变量：
1、final修饰的变量，不管是类变量、实例变量、局部变量，只要满足3个条件，该变量就不再是一个变量，而是一个直接量：
.1、使用final 修饰符修饰
.2、定义该 final 变量时使用了初始值
.3、该初始值可以在编译时就确定下来
public class FinalLocalVariable{
public static void main(String[] args){
//-定义一个final局部变量 并赋初始值
final int a=3;
System.out.println(a);
}
}
运行结果：
如上代码所示：对于这个程序来说，变量 a 根本不存在，当执行 System.out.println(a); 代码时，实际转换为执行：System.out.println(5);
由此产生了一个名字：宏变量：
1、final 修饰符的一个重要用途，就是定义 宏变量
2、当定义final变量的时候给定了初始值，并且该初始值在编译的时候就能确定下来，该变量实质上就是一个 宏变量
3、编译器会把程序中所有用到该变量的地方，直接替换成该变量的值
宏变量 的另一种情况：
public class FinalReplaceVariable{
public static void main(String[] args){
//-定义了 4个 final 局部变量,都是 宏变量
final int a=3+5;
final double b=1.5/3;
final String str1="张三"+"李四";
final String str2="张三"+"李四"+99.0;
//-final 修饰的 局部变量 str3 因为调用了方法，无法在编译的时候 把值确定下来 所以不是宏变量
final String str3=str1+ String.valueOf(99.0);
System.out.println(str1=="张三李四");
System.out.println(str2=="张三李四99.0");
System.out.println(str3=="张三李四99.0");
}
}
如上代码所示：
1、final变量赋值，如果被赋值的表达式只是基本的算术表达式，或基本的字符串连接运算，没有访问普通变量、调用方法，JVM在编译时依然可以把值确定下来，该变量依然可以当做 宏变量
2、当做宏变量的变量，在参与运算时，将直接用后面的值来代替 宏变量，关于这一点，原理其实就是 java 的常量池
宏替换：
public class FinalStringJoin{
public static void main(String[] args){
String a="张三李四";
String b="张三"+"李四";
String c="张三";
String d="李四";
//-将字符串直接量 c、d 进行连接运算
//-e变量的值，无法在编译时就确定下来，所以变量e无法指向常量池中缓存的 字符串直接量
String e=c+d;
//-true
System.out.println(a==b);
//-false
System.out.println(a==e);
}
}
运行结果：
如上代码所示：
1、在编译时值就能确定下来的 变量，可以直接指向常量池中缓存的直接量，指向常量池缓存中同一个直接量的变量，程序可以执行 宏替换， 是相等的
2、在编译阶段值无法确定下来的变量，不可以共享常量池中缓存的直接量，程序不能执行 宏替换， 不能判断相等
3、让上面代码中 a与e相等，只需要把 c和d定义为final变量，使他们称为 宏变量，这样在编译阶段，系统将会执行 宏替换，把c和d都替换成常量池缓存中对应值，所以在编译阶段e的值就能确定下来
修改后代码如下：
public class FinalStringJoinEquals{
public static void main(String[] args){
//-定义两个普通字符串直接量，编译时值就能确定下来
String a="张三李四";
String b="张三"+"李四";
//-定义两个final 宏变量，在用到 这两个宏变量的地方，可以直接执行 宏替换
final String c="张三";
final String d="李四";
//-e变量的值，在编译时就能确定下来，因为c和d是宏变量，编译时就可以执行 宏替换
String e=c+d;
//-true
System.out.println(a==b);
//-true
System.out.println(a==e);
}
}
运行结果：
总结：
1、对于实例变量而言，在声明时、普通初始化块中、构造器中，这三个地方赋初始值是一样的
2、对于final 实例变量而言，只有在定义该变量时赋初始值，才有 宏变量 的效果
上面代码在做修改，体会宏变量的本质：
public class FinalStringJoinEquals{
public static void main(String[] args){
//-定义两个普通字符串直接量，编译时值就能确定下来
String a="张三李四";
String b="张三"+"李四";
//-定义两个final 局部变量，未付初始值，合法
final String c;
final String d;
//-给两个final局部变量 赋初始值，合法
c="张三";
d="李四";
//-e变量的值，在编译时不能确定下来，因为c和d不再是宏变量，编译时不可以执行 宏替换
String e=c+d;
//-true
System.out.println(a==b);
//-false
System.out.println(a==e);
}
}
运行效果：
称为宏变量的条件总结：
1、必须 final 修饰符修饰
2、必须在声明时就赋初始值
3、必须在程序编译时，变量值就能确定下来
以上三个条件少一个，该变量就不是 宏变量 ，在后面的执行中，就不会执行宏替换
三、final修饰方法：
1、final修饰的方法不可被重写
2、如果不希望子类重写父类的某个方法，可以用 final 修饰该方法
3、Object类中的 getClass() 方法，就是 final 修饰的，不可被重写，toString()、equals()方法不是 final 修饰的，因此允许其子类 重写这两个方法
4、子类重写父类中 final 修饰的方法，编译会报错，如下代码就会编译报错：
class BaseClass{
public final void test(){
}
}
public class FinalMethodTest extends BaseClass{
public void test(){
}
}
编译时效果：
注意：
1、对于一个private方法，只在当前类中可见，子类中无法访问，所以子类也就无法重写该方法，这时如果子类中定义一个与父类private方法相同方法名、相同形参列表、相同返回类型的方法，这不算重写，只是子类自己新定义了一个方法而已
2、所以，即使使用 final 修饰了一个 private 的方法，其子类一样可以定义一个一样的方法，这不是重写，仅仅只是子类自己新定义的方法而已，如下代码：
class BaseClass{
//-本类私有的，子类不可见，更不可重写
private final void test(){
System.out.println("BaseClass类的 test() 方法 ");
}
}
public class PrivateFinalMethodTest extends BaseClass{
//-不会报错，不是重写，只是本类自己定义的方法而已
public void test(){
System.out.println("PrivateFinalMethodTest类的 test() 方法，不是重写！ ");
}
public static void main(String[] args){
new PrivateFinalMethodTest().test();
}
}
运行结果：
5、final修饰的方法仅仅是不能被重写，但可以被重载，如下代码是合法的：
public class FinalOverloadMethod{
public final void test(){
}
//-final修饰的方法，只是不能被重写，完全可以被重载
public final void test(String str){
}
public static void main(String[] args){
//-do sth
}
}
四、final 修饰类：
1、final 修饰的类不可以有子类，java.lang.Math类就是 final 修饰的类，它不可以有子类
2、如果想保证某个类不被继承，可以用 final 修饰这个类
下面代码将会编译报错：
final class BaseClass{
//-do sth
}
public class FinalOverrideClass extends BaseClass{
//-do sth
}
编译结果：
