In the Java programming language, the final keyword is used in several different contexts to define an entity which cannot later be changed.
Contents[hide] |
A final classcannot be extended. This is done for reasons of security andefficiency. Accordingly, many of the Java standard library classes arefinal, for example java.lang.System and java.lang.String. All methods in a final class are implicitly final.
Example:
public final class MyFinalClass {...}
Restricted subclasses are often referred to as "soft final" classes.[1]
A final method cannot be overriddenby subclasses. This is used to prevent unexpected behavior from asubclass altering a method that may be crucial to the function orconsistency of the class.[2]
Example:
public class MyClass {
public final void myFinalMethod() {...}
}
A common misconception is that declaring a class or method finalimproves efficiency by allowing the compiler to directly insert themethod inline wherever it is called. This is not completely true; thecompiler is unable to do this because the classes loaded at runtimemight not be the same versions of the ones that were just compiled.Further, the runtime environment and JITcompiler have the information about exactly what classes have beenloaded, and are able to make better decisions about when to inline,whether or not the method is final.[3]
A final variable can only be assigned once. This assignment does not grant the variable immutablestatus. If the variable is a field of a class, it must be assigned inthe constructor of its class. (Note: If the variable is a reference,this means that the variable cannot be re-bound to reference anotherobject. But the object that it references is still mutable, if it wasoriginally mutable.)
Unlike the value of a constant, the value of a final variable is not necessarily known at compile time.
Example:
public class Sphere {
public static final double PI = 3.141592653589793; // this is essentially a constant
public final double radius;
public final double xpos;
public final double ypos;
public final double zpos;
Sphere(double x, double y, double z, double r) {
radius = r;
xpos = x;
ypos = y;
zpos = z;
}
[...]
}
Any attempt to reassign radius, xpos, ypos, zposwill meet with a compile error. In fact, even if the constructordoesn't set a final variable, attempting to set it outside theconstructor will result in a compile error.
To illustrate that finality doesn't guarantee immutability: suppose we replace the three position variables with a single one:
public final Position pos;
where pos is an object with three properties pos.x, pos.y and pos.z. Then pos cannot be assigned to, but the three properties can, unless they are final themselves.
Like full immutability, finality of variables has great advantages, especially in optimization. For instance, Sphere will probably have a function returning its volume; knowing that its radius is constant allows us to memoize the computed volume. If we have relatively few Spheres and we need their volumes very often, the performance gain might be substantial. Making the radius of a Sphere final informs developers and compilers that this sort of optimization is possible in all code that uses Spheres.
The blank final, which was introduced in Java 1.1, is a final variable whose declaration lacks an initializer. [4][5]A blank final can only be assigned once and it must be unassigned whenan assignment occurs. In order to do this, a Java compiler runs a flowanalysis to ensure that, for every assignment to a blank final variable,the variable is definitely unassigned before the assignment; otherwise acompile-time error must occur.[6]
In general, a Java compiler will ensure that the blank final is notused until it is assigned a value and that once assigned a value, thenow final variable cannot be reassigned another value.[7]
联系客服
