许多程序设计语言都有自己的办法告诉编译器某个数据是“常数”。常数主要应用于下述两个方面：
　　
　　(1) 编译期常数，它永远不会改变
　　
　　(2) 在运行期初始化的一个值，我们不希望它发生变化
　　
　　对于编译期的常数，编译器（程序）可将常数值“封装”到需要的计算过程里。也就是说，计算可在编译期间提前执行，从而节省运行时的一些开销。在java中，这些形式的常数必须属于基本数据类型（primitives），而且要用final关键字进行表达。在对这样的一个常数进行定义的时候，必须给出一个值。
　　
　　无论static还是final字段，都只能存储一个数据，而且不得改变。
　　
　　若随同对象句柄使用final，而不是基本数据类型，它的含义就稍微让人有点儿迷糊了。对于基本数据类型，final会将值变成一个常数；但对于对象句柄，final会将句柄变成一个常数。进行声明时，必须将句柄初始化到一个具体的对象。而且永远不能将句柄变成指向另一个对象。然而，对象本身是可以修改的。java对此未提供任何手段，可将一个对象直接变成一个常数（但是，我们可自己编写一个类，使其中的对象具有“常数”效果）。这一限制也适用于数组，它也属于对象。
　　
　　下面是演示final字段用法的一个例子：
　　
　　//: finaldata.java
　　// the effect of final on fields
　　
　　class value {
　　　int i = 1;
　　}
　　
　　public class finaldata {
　　　// can be compile-time constants
　　　final int i1 = 9;
　　　static final int i2 = 99;
　　　// typical public constant:
　　　public static final int i3 = 39;
　　　// cannot be compile-time constants:
　　　final int i4 = (int)(math.random()*20);
　　　static final int i5 = (int)(math.random()*20);
　　　
　　　value v1 = new value();
　　　final value v2 = new value();
　　　static final value v3 = new value();
　　　//! final value v4; // pre-java 1.1 error:
　　　　　　　　　　　　　// no initializer
　　　// 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: can't change value
　　　　fd1.v2.i++; // object isn't constant!
　　　　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 handle
　　　　//! fd1.a = new int[3];
　　
　　　　fd1.print("fd1");
　　　　system.out.println("creating new finaldata");
　　　　finaldata fd2 = new finaldata();
　　　　fd1.print("fd1");
　　　　fd2.print("fd2");
　　　}
　　} ///:~
　　
　　由于i1和i2都是具有final属性的基本数据类型，并含有编译期的值，所以它们除了能作为编译期的常数使用外，在任何导入方式中也不会出现任何不同。i3是我们体验此类常数定义时更典型的一种方式：public表示它们可在包外使用；static强调它们只有一个；而final表明它是一个常数。注意对于含有固定初始化值（即编译期常数）的fianl static基本数据类型，它们的名字根据规则要全部采用大写。也要注意i5在编译期间是未知的，所以它没有大写。
　　
　　不能由于某样东西的属性是final，就认定它的值能在编译时期知道。i4和i5向大家证明了这一点。它们在运行期间使用随机生成的数字。例子的这一部分也向大家揭示出将final值设为static和非static之间的差异。只有当值在运行期间初始化的前提下，这种差异才会揭示出来。因为编译期间的值被编译器认为是相同的。这种差异可从输出结果中看出：
　　
　　fd1: i4 = 15, i5 = 9
　　creating new finaldata
　　fd1: i4 = 15, i5 = 9
　　fd2: i4 = 10, i5 = 9
　　
　　注意对于fd1和fd2来说，i4的值是唯一的，但i5的值不会由于创建了另一个finaldata对象而发生改变。那是因为它的属性是static，而且在载入时初始化，而非每创建一个对象时初始化。
　　
　　从v1到v4的变量向我们揭示出final句柄的含义。正如大家在main()中看到的那样，并不能认为由于v2属于final，所以就不能再改变它的值。然而，我们确实不能再将v2绑定到一个新对象，因为它的属性是final。这便是final对于一个句柄的确切含义。我们会发现同样的含义亦适用于数组，后者只不过是另一种类型的句柄而已。将句柄变成final看起来似乎不如将基本数据类型变成final那么有用。
　　
　　2. 空白final
　　
　　java 1.1允许我们创建“空白final”，它们属于一些特殊的字段。尽管被声明成final，但却未得到一个初始值。无论在哪种情况下，空白final都必须在实际使用前得到正确的初始化。而且编译器会主动保证这一规定得以贯彻。然而，对于final关键字的各种应用，空白final具有最大的灵活性。举个例子来说，位于类内部的一个final字段现在对每个对象都可以有所不同，同时依然保持其“不变”的本质。下面列出一个例子：
　　
　　//: blankfinal.java
　　// "blank" final data members
　　
　　class poppet { }
　　
　　class blankfinal {
　　　final int i = 0; // initialized final
　　　final int j; // blank final
　　　final poppet p; // blank final handle
　　　// blank finals must be initialized
　　　// in the constructor:
　　　blankfinal() {
　　　　j = 1; // initialize blank final
　　　　p = new poppet();
　　　}
　　　blankfinal(int x) {
　　　　j = x; // initialize blank final
　　　　p = new poppet();
　　　}
　　　public static void main(string[] args) {
　　　　blankfinal bf = new blankfinal();
　　　}
　　} ///:~
　　
　　现在强行要求我们对final进行赋值处理――要么在定义字段时使用一个表达 式，要么在每个构建器中。这样就可以确保final字段在使用前获得正确的初始化。
　　
　　3. final自变量
　　
　　java 1.1允许我们将自变量设成final属性，方法是在自变量列表中对它们进行适当的声明。这意味着在一个方法的内部，我们不能改变自变量句柄指向的东西。如下所示：
　　
　　//: finalarguments.java
　　// using "final" with method arguments
　　
　　class gizmo {
　　　public void spin() {}
　　}
　　
　　public class finalarguments {
　　　void with(final gizmo g) {
　　　　//! g = new gizmo(); // illegal -- g is final
　　　　g.spin();
　　　}
　　　void without(gizmo g) {
　　　　g = new gizmo(); // ok -- g not final
　　　　g.spin();
　　　}
　　　// void f(final int i) { i++; } // can't change
　　　// you can only read from a final primitive:
　　　int g(final int i) { return i + 1; }
　　　public static void main(string[] args) {
　　　　finalarguments bf = new finalarguments();
　　　　bf.without(null);
　　　　bf.with(null);
　　　}
　　} ///:~
　　
　　注意此时仍然能为final自变量分配一个null（空）句柄，同时编译器不会捕获它。这与我们对非final自变量采取的操作是一样的。
　　
　　方法f()和g()向我们展示出基本类型的自变量为final时会发生什么情况：我们只能读取自变量，不可改变它。