final 中文意思:最后的，最终的.

final关键字可用于修饰类，方法，变量（成员变量，局部变量，静态变量），被final修饰的类是一个最终类，不可以被继承。被final修饰的方法是一个最终方法，不可以被覆盖，但是可以被继承。被final修饰的变量只能是一个常量，只能赋值一次。内部类被定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。

使用到final的情况：
1)当不希望类被继承时,可以用final修饰.【 final class A】
2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。【访问修饰符 final 返回类型 方法名】
3)当不希望类的的某个属性的值被修改,可以用final修饰.【final double TAX RATE=0.08】
4)当不希望某个局部变量被修改，可以使用final修饰

final使用的注意事项：
1)final修饰的属性又叫常量一般用 XX_XX_XX来命名
2)final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】:
①定义时:如 public final double TAX RATE=0.08
②在构造器中
③在代码块中
3)如果final修饰的属性是静态的，则初始化的位置只能是:
①定义时
②在静态代码块 不能在构造器中赋值
4)final类不能继承，但是可以实例化对象。
5)如果类不是final类，但是含有final方法，则该方法虽然不能重写， 但是可以被继承
6)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
7)final不能修饰构造方法(即构造器)
8)final 和 static 往往搭配使用，效率更高，底层编译器做了优化处理
class Demo{
       public static final int i=16;
       static{
             System.out.printIn(“仪宝加油~"):
       }
}
8)包装类(Integer，Double，Float，Boolean等都是final，String也是final类

//final修饰的属性初始化
class A{//一、在定义时public final double TAX_RATE1 = 0.08;public final double TAX_RATE2;public final double TAX_RATE3;//二、在构造器中public A(){TAX_RATE2=1.1;}//三、在代码块{TAX_RATE3 = 1.8;}
}//若final修饰的属性是静态的，则初始化
class B{//一、在定义时public static final double TAX_RATE1=99.9;public static final double TAX_RATE2;//二、在静态代码块static{TAX_RATE2=3.3;}
}//final类不能继承，但是可以实例化对象
final class C{ }public class en {public static void main(String[] args){C c = new C();new E().cal();}
}//如果该类不是final类，但含有final方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制
class D{public final void cal(){System.out.println("cal()方法");}
}
class E extends D { }

思考：

Q：为什么当final修饰的属性为静态时，不可在构造器中初始化？

A:构造器在创建对象的时候才会被调用，而静态变量的初始化在类加载时就要给值。

User u = new User();
u.Login("a");
和new User().Login("a"); 是一样的.
只不过后者没有把User实例的引用付给一个实例而已.

User.Login("a");这是调用静态方法.静态方法不依赖于类实例，即静态方法不需要有对象，可以使用类名调用。但是在静态方法里不能操作类成员变量.

Q：为什么在静态方法里不能操作类成员变量？

A：因为要想访问成员变量你必须有个“已经实例化好的对象”，除非你在静态方法里创建一个当前类的实例对象，否则你是无法直接调用成员变量的，因为它不知道这个成员变量属于哪个实例对象的。而在成员方法里，所有属于成员的变量、方法已经可以确定是同一个对象的，并且可以用this表示当前对象。

static与final的区别:
static和final的意义是不同的，static修饰的时候代表对象是静态的，而final修饰的时候代表对象只能赋值一次，他们连用是因为定义的那个对象既要它是静态的，也要求它的值不能再被修改。
举例说明：
static int a=1;            static final b=1;
这里a和b的区别在于，a在程序里可以被重新赋值为2或3或等等的整数，而b在程序里不能被重新赋值，b永远都为1，也就是说b是一个常量。

final int c=1;              static final b=1;
这里c和b的区别在于，b存放在静态空间，不会在程序运行时被释放，它永远占着内存直到程序终止，而c在程序用完它而不会再用到它的时候就会被自动释放，不再占用内存。

当一个常数或字符串需要在程序里反复反复使用的时候，我们就可以把它定义为static final，这样内存就不用重复的申请和释放空间。

Q：一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法，为什么？

A：因为该类为final类，不能被继承，就不存在子类重写方法了，画蛇添足了属于是。因此也说，final类中的方法也都是final的。

Q：final为什么不能修饰构造方法(即构造器)？

A：java构造函数不能被final修饰
java中，构造函数是不能被继承的，也不能被重写。final修饰函数的主要目的是避免函数被重写。构造函数内在地具有不能被重写的特性，所以没必要用final修饰。
如果用fianl修饰构造函数，编译器会报modifier final not allowed的错误。

扩展+1：构造函数不能用abstract, static, final修饰

java构造函数不能被static修饰
static修饰函数时，可以说函数是属于类而不是属于一个具体的对象。而每个对象被创建时构造函数都会被调用，所以一个static的构造函数是没有用的。
如果用static修饰构造函数，编译器会报modifier static not allowed的错误。

java构造函数不能被abstract修饰
abstract修饰函数时，这个函数应当在子类中被实现。然而，在new被使用时，构造函数会被自动调用，因此必须要有一个函数体（而abstract函数没有函数体）。此外，构造函数不能被重写，因此也不可能在子类中被实现。
如果用abstract修饰构造函数，编译器会报modifier abstract not allowed的错误

public class en {public static void main(String[] args){System.out.println(F.num);}
}//final 和 static 往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理
final class F{public final static int num=10000;static{System.out.println("F 静态代码块被执行");}
}

代码运行结果为：  

public class en {public static void main(String[] args){System.out.println(F.num);}
}final class F{public static int num=10000;static{System.out.println("F 静态代码块被执行");}
}

 代码运行结果为：  

可以看到，第一个代码块与第二个代码块的区别在于final static 与 static

前者可以在常量时不会导致类的加载，称为编译期常量。