[Java] keyword final, static usage summary

First, final
Depending on the context of the program, the Java keyword final has the meaning of "This cannot be changed" or "final state", which can be used to modify non-abstract classes, non-abstract class member methods, and variables. You may need to stop the change in two ways: design or efficiency.
The final class cannot be inherited, there are no subclasses, and the methods in the final class are final by default.
The final method cannot be overridden by a method of a class, but can be inherited.
The final member variable represents a constant, which can only be assigned once, and the value will no longer change after the value is assigned.
Final cannot be used to modify a construction method.
Note: The private member method of the parent class is not overridden by the class method, so the private type method defaults to the final type.

1. Final class
The final class cannot be inherited, so the member methods of the final class have no chance of being overwritten, and the default is final. In the design class, if the class does not need to have subclasses, the implementation details of the class are not allowed to change, and it is certain that the class will not be extended, then it is designed as the final class.

2. Final method
If a class does not allow its subclasses to overwrite a method, you can declare this method as the final method.
There are two reasons for using the final method:
First, lock the method to prevent any inherited classes from modifying its meaning and implementation.
Second, efficient. The compiler goes into an inline mechanism when it encounters a call to the final method, greatly improving execution efficiency.
For example:

public class Test1 {

public static void Main (string[] args) {
TODO automatically generate method stubs
}

public void F1 () {
System.out.println ("F1");
}
Methods that cannot be overridden by a quilt class
Public final void F2 () {
System.out.println ("F2");
}

public void F3 () {
System.out.println ("F3");
}

private void F4 () {
System.out.println ("F4");
}
}

public class Test2 extends Test1 {

public void F1 () {
System.out.println ("Test1 Parent class method F1 is overwritten!");
}

public static void Main (string[] args) {
Test2 t=new Test2 ();
T.F1 ();
T.f2 (); Call the final method inherited from the parent class.
T.F3 (); Call a method that inherits from the parent class.
T.f4 (); Call failed, cannot inherit from parent class

}
}


3. Final variable (constant)
A constant is represented by a final modified member variable, which cannot be changed once the value is given!
There are three final modified variables: Static variables, instance variables, and local variables, representing three types of constants, respectively.
As you can see from the example below, once the initial value is given to the final variable, it cannot be changed.
In addition, when the final variable is defined, it can be declared without giving the initial value, which is also called the final blank, and in any case the compiler ensures that the blank final must be initialized before it is used. However, final whitespace provides greater flexibility in the use of the final keyword final, so that the final data members in a class can be implemented differently depending on the object, but with the same characteristics that remain constant.

Package org.leizhimin;

public class Test3 {
Private final String s= "final instance variable S";
private final int a=100;
public final int b=90;

public static final int c=80;
private static final int d=70;

public final int E; Final blank, the initial value must be assigned when initializing the object

public Test3 (int x) {
E=x;
}

/**
* @param args
*/
public static void Main (string[] args) {
Test3 t=new Test3 (2);
t.a=101; Error, the value of the final variable cannot be changed once it is given
t.b=91; Error, the value of the final variable cannot be changed once it is given
t.c=81; Error, the value of the final variable cannot be changed once it is given
t.d=71; Error, the value of the final variable cannot be changed once it is given

System.out.println (T.A);
System.out.println (T.B);
System.out.println (T.C); accessing static fields using object mode is not recommended
System.out.println (T.D); accessing static fields using object mode is not recommended
System.out.println (TEST3.C);
System.out.println (TEST3.D);
System.out.println (TEST3.E); Error because E is final and differs depending on the value of the object.
System.out.println (T.E);

Test3 t1=new Test3 (3);
System.out.println (t1. E); Final blank variable e differs depending on the object
}

private void Test () {
System.out.println (New Test3 (1). A);
System.out.println (TEST3.C);
System.out.println (TEST3.D);
}

public void Test2 () {
final int A; Final blank, assign value when needed
final int b=4; Local constants--final cases for local variables
final int C; Final blank, has not been assigned.
A=3;
a=4; Error, the value has been assigned.
b=2; Error, the value has been assigned.
}
}


4. Final parameters
When the function parameter is the final type, you can read it using the parameter, but you cannot change the value of the parameter.

public class Test4 {
public static void Main (string[] args) {
New Test4 (). F1 (2);
}

public void F1 (final int i) {
i++; I is the final type, and the value is not allowed to change.
System.out.print (i);
}
}

Second, static

Static represents the meaning of "global" or "static", which modifies member variables and member methods, and can also form statically static blocks of code, but there is no concept of global variables in the Java language.

member variables and member methods that are modified by static are independent of any object of the class. That is, it does not depend on class-specific instances and is shared by all instances of the class. As long as this class is loaded, the Java virtual machine can find them based on the class name in the method area of the run-time data area. Therefore, a static object can be accessed before any of its objects are created, without referencing any objects.

Static member variables and member methods that are decorated with public are essentially global variables and global methods, and when declaring the object city of its class, do not generate a copy of the static variable, but all instances of the class share the same static variable.

The static variable can have a private adornment before it, indicating that the variable can be used in the static code block of the class, or in other static member methods of the class (which can also be used in non-static member methods-nonsense), but it is important that the class name cannot be referenced directly in other classes. In fact, you need to understand that private is the access permission limit, static means do not instantiate can be used, so it is easier to understand more. Static plus other access keyword effects and so on.

The static modified member variables and member methods are customarily referred to as static variables and static methods, which can be accessed directly through the class name, and Access syntax is:
Class name. static method Name (parameter list ...)
Class name. Static variable Name

A static code block is represented by a statically decorated block of code that executes when the Java Virtual Machine (JVM) loads the class (very useful, hehe).

1. Static variables
There are two ways to classify a class member variable statically: A variable that is statically modified, called a static variable or a class variable, and another variable that is not modified by static, called an instance variable. The difference between the two is:
For static variables there is only one copy in memory (memory saving), the JVM allocates only one memory at a time, completes the memory allocation of static variables during the loading of the class, can be accessed directly (conveniently) by the class name, and, of course, is accessible through objects (but this is not recommended).
For instance variables, when an instance is not created, the instance variable is allocated one memory, and the instance variable can have multiple copies in memory without compromising (flexibility).

2. Static method
Static methods can be called directly from the class name, and any instance can also be called, so a static method cannot use the This and Super keywords, and cannot directly access the instance variables and instance methods of the owning class (that is, member variables and member methods without static). Only static member variables and member methods of the owning class can be accessed. Because instance members are associated with specific objects! This need to understand, want to understand the truth, not the memory!!!
Because the static method is independent of any instance, the static method must be implemented, not abstract.

3. Static code block
A static block of code is also called a code block, which is an independent block of static blocks in a class that is separate from a class member, can have more than one position, it is not in any method body, and the JVM executes these static blocks of code when the class is loaded, and if there are multiple static blocks of code, The JVM executes them sequentially in the order in which they appear in the class, and each code block is executed only once. For example:

public class Test5 {
private static int A;
private int B;

static{
Test5.a=3;
System.out.println (a);
Test5 t=new Test5 ();
T.F ();
t.b=1000;
System.out.println (T.B);
}
static{
test5.a=4;
System.out.println (a);
}
public static void Main (string[] args) {
TODO automatically generate method stubs
}
static{
test5.a=5;
System.out.println (a);
}
public void F () {
System.out.println ("Hhahhahah");
}
}


Operation Result:
3
Hhahhahah
1000
4
5

Static code blocks allow you to assign values to some static variables, and finally take a look at these examples, all in a static Main method, so that the JVM can be called directly without creating an instance when it runs the main method.

4. What does static and final piece mean?
Static final is used to modify member variables and member methods, which can be simply understood as "global constants"!
For variables, this means that once a value is given it cannot be modified and is accessible through the class name.
For methods, the representation is not overwritten and can be accessed directly through the class name.

[Java] keyword final, static usage summary