Detailed explanation of the use of final in Java

concept

Final has the meaning of "unchanged" and can modify non -abstract class, non -abstract members' methods and variables.

• The class modified class cannot be inherited and no subclasses.
• The method modified method cannot be covered (rewritten) by the method of subclass.
• The variable modified variables represent the constant, and it can only be given a value (when the variable is declared).

Note:

FINAL cannot be used to modify the structure method, because the concept of "method coverage" only applies to the member method of class, not to the constructive method of the class. Relationship, so it is meaningless to modify the constructor.

The method of modified by Private in the parent class cannot be covered by the method of the subclass, so it can be understood as the Private type method by default.

final class

Define the class as final so that this class cannot be inherited. The specific use scenarios are as follows:

• It is not a class designed for inheritance. There is a complex call relationship between the methods of the class itself. If the subclasses of these classes are created at will, the subclass may correctly modify the implementation details of the parent class.
• In the cause of safety, the implementation details of the class are not allowed to be expanded.
• When creating an object model, I am convinced that this class will not be extended again.

For example: Java.lang.String class in JDK is defined as Final type.

public final class string {...}

final method

In some cases, due to safety reasons, the parent class does not allow subclasses to cover a certain method. At this time, this method can be declared as a final type.

For example: In the java.Lang.object class in JDK, the getClass () method is the final type, and the equals () method is not the final type.

All Object subclasses can cover the EQUALS () method, but cannot cover the getClass () method.

final variable

The variable modified variables indicate the constant where the value is not changed.

For example: two constants are defined in JDK java.lang.integer classes.

Public static final into min_value = 0x80000000;

Public static final int max_value = 0x7ffffffff;

FINAL variable has the following characteristics:

• FINAL modifier can modify static variables, member variables, and local variables, which represent static constant, instance constant, and local constant.

 Public Class Demo {Public Static Final INT MAX_VALUE = 23; // Static constant Public Static Final Int MIN_Value = 10; // Static constant PRIVATE FINAL DATE BITHDAY = NEW DATE (); // Member constant}

Static constants are generally named after capital letters, and the words are separated by "_" symbols.

• FINAL modified member variables must be initialized.

 Public Class Finaltest {Final Int A = 1; // Member constant defaults to initialize the static final into; // Static constant default Final Int C; // Member constants Test () {C = 3; // The members' constant constant is not initialized by default, and it can initialize the constructor} Static {d = 4; // Static constant is not initialized by default, and initialize it in static code blocks}}}}

Final variables can only be given one value. If the reference type variable is modified with final, the variable can always be referenced by one object, but it can change the content of the object.

 public class finalTest {string str = "" "" "" "" "" "" "" "" "" "" "" "; LTEST = New Finaltest (); Finaltest.str = "xixihaha"; finalTest.print ();}}

Summarize:

In the actual program, the constant is defined through the final modifier. The purpose is:

• Improve the security of the program.
• Improve code maintenance.
• Provide code readability.

The above is all the contents of this article. I hope it will be helpful to everyone's learning.