In this article, the editor will introduce Java Final to everyone. Friends in need can refer to it
The JAVA keyword final is used to modify data, methods or classes, which usually means "cannot be changed" , data cannot be changed, methods cannot be overridden, and classes cannot be inherited. There are generally two reasons for using final: design and efficiency. As the JAVA version is updated, some efficiency issues can be handled by the compiler and JVM. Therefore, using final to solve efficiency problems is not so important.
Final modifier is mostly used in the fields of primitive data types or immutable classes (if all methods in the class will not change its object, this class is an immutable class. String is an immutable class).
[final data]
There are two main situations in which the Final keyword is used to modify data:
1. Compile-time constants
2. Run-time initialization The value of
For compile-time constants, refers to a field that is both final and static (according to convention, compile-time constants are all named with uppercase letters and use underscores to separate each word), which only occupies a section that cannot Changed storage space. The compiler can substitute compile-time constants into any calculation formula that may use it. That is to say, the calculation formula can be executed at compile time, which relatively reduces the runtime burden. A compile-time constant must have a value assigned to it when it is defined (not necessarily a basic type).
The value initialized at runtime. For basic types, final makes the value unchangeable; for object references, final makes the reference unchangeable, that is, it cannot be changed to point to another object. However, the object itself cannot be changed. Can be modified (applies to arrays, which are also objects).
The code is as follows:
public class javaFinalData{
private static final String TESTD = "test";
public static final String TESTE = "test";
public static final String[] TESTF = {"1","2"}; //非基本类型
private static final String[] TESTG = new String[2];
public static void main(String args[]){
final int testA = 1;
final String testB = "test";
final int[] testC = {1,1,2,};
System.out.println(testC[1]);
testC[1] = 123;
System.out.println(testC[1]);
}
}[Unassigned final field]
JAVA allows the generation of unassigned final fields, but they must be in the definition of the field Assign the final field at or in each constructor (as many constructors as there are), make sure it is initialized before use. In this way, final can be used more flexibly. In the same class, different values can be assigned to different objects while maintaining immutable characteristics.
The code is as follows:
public class javaBlankFinal{
private final int blank;
public javaBlankFinal(){
blank = 2011;
}
public javaBlankFinal(int temp){
blank = 2012;
}
public javaBlankFinal(String temp){
blank = 2014;
}
public static void main(String args[]){
new javaBlankFinal();
}
}[final method]
There are two reasons for using the final method: one is to lock the method to prevent it from being overwritten and ensure that it is The method behavior in inheritance remains unchanged; the second is to convert method calls into inlining calls (inlining) to reduce the cost of method calls. However, in recent versions, the JVM can optimize itself, so there is no need to use final methods to deal with efficiency issues.
Regarding final methods, there is one more thing to note. All private methods in the class are implicitly designated as final methods (you can also add final modification to them, but it is meaningless). When you try to override a private method, the compiler does not report an error, but in fact you do not overwrite the method, you just generate a new method. Because the private method cannot be accessed by external classes, of course it cannot be overridden.
Use the @Override annotation to prevent the above problems. As shown in the program:
The code is as follows:
class finalFunction{
private void finalFunctionA(){
System.out.println("finalFunctionA");
}
private final void finalFunctionB(){
System.out.println("finalFunctionB");
}
final void finalFunctionC(){
System.out.println("finalFunctionC");
}
void functionD(){}
}
class overrideFinalFunction extends finalFunction{
//@Override 添加@Override注解可以识别是否是override
public void finalFunctionA(){
System.out.println("override finalFunctionA");
}
public final void finalFunctionB(){
System.out.println("override finalFunctionB");
}
//final void finalFunctionC(){} //Cannot override the final method from finalFunction
@Override
void functionD(){} //真正的override方法
}
public class javaFinalFunction extends finalFunction{
public static void main(String args[]){
finalFunction ff = new finalFunction();
//ff.finalFunctionA(); //无法调用private方法
//ff.finalFunctionB();
overrideFinalFunction off = new overrideFinalFunction();
off.finalFunctionA(); //public方法
off.finalFunctionB();
}
}[final class]
Using the final class is generally for design reasons and is not allowed. Classes are inherited. This ensures that the behavior of the class will not change, and may also avoid some security risks. All methods in the Final class are implicitly designated as final methods and therefore cannot be overridden (because the final class prohibits inheritance, methods in its class cannot be overridden). In the Java core API, there are many examples of applying final, such as java.lang.String. Specify final for the String class to prevent overwriting methods such as length().
For final fields, even if a class is declared final, the fields in the class will not automatically become final fields.
The code is as follows:
final class finalClass{
int testA = 2011;
}
//class extendFinalClassextends finalClass{} //can not extendthe final class finalClass
public class javaFinalClass{
public static void main(String args[]){
finalClass fc = new finalClass();
System.out.println(fc.testA);
fc.testA = 2012;
System.out.println(fc.testA);
}
}The above is the detailed content of Dive into Java Final. For more information, please follow other related articles on the PHP Chinese website!