final在Java中并不常用，然而它却为我们提供了诸如在C语言中定义常量的功能，不仅如此，final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能，这些特点使final在Java中拥有了一个不可或缺的地位，也是学习Java时必须要知道和掌握的关键字之一。
final成员
当你在类中定义变数时，在其前面加上final关键字，那便是说，这个变数一旦被初始化便不可改变，这里不可改变的意思对基本型别来说是其值不可变，而对于物件变数来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变数定义时直接给其赋值，二是在建构函式中。这两个地方只能选其一，要么在定义时给值，要么在建构函式中给值，不能同时既在定义时给了值，又在建构函式中给另外的值。下面这段程式码演示了这一点：
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class Bat{
final PI=3.14; 在定义时便给址值
final int i; 因为要在建构函式中进行初始化，所以此处便不可再给值
final List list; 此变数也与上面的一样
Bat(){
i=100;
list=new LinkedList();
}
Bat(int ii,List l){
i=ii;
list=l;
}
public static void main(String[] args){
Bat b=new Bat();
b.list.add(new Bat());
b.i=25;
b.list=new ArrayList();
System.out.println("I="+b.i+" List Type:"+b.list.getClass());
b=new Bat(23,new ArrayList());
b.list.add(new Bat());
System.out.println("I="+b.i+" List Type:"+b.list.getClass());
}
}
此程式很简单的演示了final的常规用法。在这里使用在建构函式中进行初始化的方法，这使你有了一点灵活性。如Bat的两个过载建构函式所示，第一个预设建构函式会为你提供预设的值，过载的那个建构函式会根据你所提供的值或型别为final变数初始化。然而有时你并不需要这种灵活性，你只需要在定义时便给定其值并永不变化，这时就不要再用这种方法。在main方法中有两行语句注释掉了，如果你去掉注释，程式便无法通过编译，这便是说，不论是i的值或是list的型别，一旦初始化，确实无法再更改。然而b可以通过重新初始化来指定i的值或list的型别，输出结果中显示了这一点：
I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList
还有一种用法是定义方法中的引数为final，对于基本型别的变数，这样做并没有什么实际意义，因为基本型别的变数在呼叫方法时是传值的，也就是说你可以在方法中更改这个引数变数而不会影响到呼叫语句，然而对于物件变数，却显得很实用，因为物件变数在传递时是传递其引用，这样你在方法中对物件变数的修改也会影响到呼叫语句中的物件变数，当你在方法中不需要改变作为引数的物件变数时，明确使用final进行宣告，会防止你无意的修改而影响到呼叫方法。
另外方法中的内部类在用到方法中的参变数时，此参变也必须宣告为final才可使用，如下程式码所示：
public class INClass{
void innerClass(final String str){
class IClass{
IClass(){
System.out.println(str);
}
}
IClass ic=new IClass();
}
public static void main(String[] args){
INClass inc=new INClass();
inc.innerClass("Hello");
}
}
final方法
将方法宣告为final，那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩充套件，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。另外有一种被称为inline的机制，它会使你在呼叫final方法时，直接将方法主体插入到呼叫处，而不是进行例行的方法呼叫，例如储存断点，压栈等，这样可能会使你的程式效率有所提高，然而当你的方法主体非常庞大时，或你在多处呼叫此方法，那么你的呼叫主体程式码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。
final类
当你将final用于类身上时，你就需要仔细考虑，因为一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩充套件。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。你也可以明确的给final类中的方法加上一个final，但这显然没有意义。
下面的程式演示了final方法和final类的用法：
final class final{
final String str="final Data";
public String str1="non final data";
final public void print(){
System.out.println("final method.");
}
public void what(){
System.out.println(str+"
"+str1);
}
}
public class FinalDemo { extends final 无法继承
public static void main(String[] args){
final f=new final();
f.what();
f.print();
}
}
从程式中可以看出，final类与普通类的使用几乎没有差别，只是它失去了被继承的特性。final方法与非final方法的区别也很难从程式行看出，只是记住慎用。
final在设计模式中的应用
在设计模式中有一种模式叫做不变模式，在Java中通过final关键字可以很容易的实现这个模式，在讲解final成员时用到的程式Bat.java就是一个不变模式的例子。如果你对此感兴趣，可以参考阎巨集博士编写的《Java与模式》一书中的讲解。
final类不能被继承，因此final类的成员方法没有机会被覆盖，预设都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩充套件，那么就设计为final类。 final方法不能被子类的方法覆盖，但可以被继承。 2、final方法 如果一个类不允许其子类覆盖某个方法，则可以把这个方法宣告为final方法。 使用final方法的原因有二： 第一、把方法锁定，防止任何继承类修改它的意义和实现。 第二、高效。编译器在遇到呼叫final方法时候会转入内嵌机制，大大提高执行效率。 3、final变数（常量） 用final修饰的成员变量表示常量，只能被赋值一次，赋值后值无法改变！ final修饰的变数有三种：静态变数、例项变数和区域性变数，分别表示三种类型的常量。 从下面的例子中可以看出，一旦给final变数初值后，值就不能再改变了。 另外，final变数定义的时候，可以先宣告，而不给初值，这种变数也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final资料成员就可以实现依物件而有所不同，却有保持其恒定不变的特征。 4、final引数 当函式引数为final型别时，你可以读取使用该引数，但是无法改变该引数的值。 注：父类的private成员方法是不能被子类方法覆盖的，因此private型别的方法预设是final型别的。 final不能用于修饰构造方法。
可以宣告成员变数、方法、类以及本地变数。一旦你将引用宣告作final，你就不能改变这个引用了。String 类就是一个 final 型别的类
final 放在类前面
如果某个类在定义时，前面有修饰词final，则该类不能被继承
final 放在属性前面
属性宣告时，如果前面有修饰词final关键字，则该属性值不能被更改，即此时该属性为常量
final放在方法前面
如果某个方法在定义时，前面有修饰词final，该方法可以被呼叫，不能重写
完全可以。但最好用“是”，以示尊敬、服从，老板听了更高兴。
final 类不能继承
final 方法不能重新override，可以继承
final 成员变数可以继承
这俩是没有区别的，只是final static的可读性比较强些。
比如：int arr[] 和 int[] arr 一样，int[] arr 的可阅读性比较强。
final 关键字：
1
final资料：对于基本型别前加以final修饰，表示被修饰的变数为常数，不可以修改。一个既是static又是final的栏位表示只占据一段不能改变的储存空间。
final用于物件应用时，final使应用恒定不变。一旦引用被初始化指向一个物件，就无法再把它改为指向另一个物件。
class Value {
int
i = 1;
}
public class
FinalData {
Can be
pile-time constants
final
int i1 =
9;
static
final int VAL_TWO = 99;
i1和VAL_TWO是编译期常量此类常量必须是基本数字型别，必须是以关键字
fianl进行修饰，定义该型别的常量的时候，必须给顶初值
public
static final int VAL_THREE = 39;
注意VAL_THREE的书写格式，通常把带有final,和static关键字修饰的常量
一大写，并以"_"隔开
final
int i4 =
(int)(Math.random()*20);
static
final int i5 =
(int)(Math.random()*20);
i4,i5并不是便宜期常量，而是执行期常量，因为他们的初值只有在执行的
时候才能确定，所以i5并没有大写，
i5是静态常量，而且i4不是，这就可以体现二者的不同，从测试的列印语
句来看，fd1和fd2的i4的值不同
而fd1和fd2的i5都是相同的，因为i5是static型别，只有在装载class的时
候才进行初始化，不会在每次
产生新的物件的时候都再初始化一次
Value v1 = new Value();
final Value v2 = new
Value();
static
final Value v3 = new Value();
Arrays:
final
int[] a = { 1, 2, 3, 4, 5, 6 };
public
void print(String id) {
System.out.println(
id + ": " +
"i4 = " + i4 +
", i5 = " +
i5);
}
public
static void main(String[] args) {
FinalData
fd1 = new FinalData();
! fd1.i1++; Error:
final型别的基本型别是不可以改变的
fd1.v2.i++;
v2是final型别但是可以改变起属性的值，但是不能将
v2重新指向另一个物件
fd1.v1 = new
Value(); OK -- not
final
for(int i =
0; i < fd1.a.length; i++)
fd1.a[i]++; Object isn't
constant!
! fd1.v2 = new Value(); Error:
Can't
! fd1.v3 =
new Value(); change reference
! fd1.a =
new int[3];
fd1.print("fd1");
System.out.println("Creating
new FinalData");
FinalData
fd2 = new FinalData();
fd1.print("fd1");
fd2.print("fd2");
}
}
2
final方法：一是把方法锁定，也许你希望确保某个函式的行为在继承的过程中保持不变，而且无法被覆写，以防止继承类修改它的含义，第二个原因可能是效
率，如果你将某个函式申明为final型别，等于告诉编译器将所有对此函式的呼叫转化为行内呼叫。类中所有的private方法都隐式地指定为是
final。因为你无法取用private方法，当然就无从覆写，你可以将关键字final加于private方法上，但是这样做不会带来任何额外的意
义.java中的所有方法，除了被申明为final者，皆采用后期系结，这么做是告诉编译器动态系结是不需要的，于是就产生效率叫佳的程式码，但这么做并不
会给你的程式带来整体效率的提升
class WithFinals
{
Identical to "private"
alone:申明为final型别即是该方法不能被覆写，
将关键字加于private函式上，实际上并没有任何的意义
private final void f() {
System.out.println("WithFinals.f()");
}
即使被覆写了，也就相当于子类重新定义了一个方法而已
Also automatically
"final":当一个方法申明为private的时候,自动为final型别
private void g() {
System.out.println("WithFinals.g()");
}
}
class
OverridingPrivate extends WithFinals {
private final void f() {
System.out.println("OverridingPrivate.f()");
}
private void g() {
System.out.println("OverridingPrivate.g()");
}
}
class
OverridingPrivate2 extends OverridingPrivate {
public final void f() {
System.out.println("OverridingPrivate2.f()");
}
public void g() {
System.out.println("OverridingPrivate2.g()");
}
}
public class
FinalOverridingIllusion {
public static void main(String[]
args) {
OverridingPrivate2 op2 = new OverridingPrivate2();
op2.f();
op2.g();
You can upcast:
OverridingPrivate op = op2;
But you can't call the
methods:
!
op.f();
!
op.g();
Same
here:
WithFinals
wf = op2;
! wf.f();
!
wf.g();
}
}
3
final引数：对于基本型别的变数，这样做并没有什么实际意义，因为基本型别的变数在呼叫方法时是传值的，也就是说你可以在方法中更改这个引数变数而不
会影响到呼叫语句，然而对于物件变数，却显得很实用，因为物件变数在传递时是传递其引用，这样你在方法中对物件变数的修改也会影响到呼叫语句中的物件变
量，当你在方法中不需要改变作为引数的物件变数时，明确使用final进行宣告，会防止你无意的修改而影响到呼叫方法。
4
final类：当将某个类的整体定义为final时，就表明了该类不允许被继承。
今天看到一段程式码，大意如下： import java.util.ArrayList; import java.util.List; public class FinalTest { private final List list; FinalTest(List list) { this.list = list; } public List appendList(List list) { this.list.addAll(list); 使用final修饰的this.list，还可以修改其内容么？ return this.list; } public void showList() { for (String s : this.list) { System.out.println(s); } } public static void main(String[] args) { List list1 = new ArrayList(1); list1.add("s1"); FinalTest test = new FinalTest(list1); test.showList(); List list2 = new ArrayList(1); list2.add("s2"); test.appendList(list2); test.showList(); } } 主要的疑问在注释行那里：使用final修饰的this.list，还可以修改其内容么？经查证，发现final关键字修饰的变数，如果为值型，则其值除了初始化之外，不可以被再次赋值；如果为引用型，则表示该引用不能指向其他的物件，但是该引用指向的物件本身是可以改变其值的。
final 修饰类 ：表示该类不能被继承，是顶级类。
修饰方法：表示不能重写。
修饰变数：表示不能修改，可在构造方法中赋值。