Static explanation in Java

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).

As a result, static variables are typically used when you need to implement the following two functions:
? When a value is shared between objects
? Easy access to variables

2. Static method
Static methods can be called directly from the class name, and any instance can also be called.
Therefore, the this and Super keywords cannot be used in a static method, and you cannot directly access the instance variables and instance methods of the owning class (that is, member variables and member methods without static), only the static member variables and member methods of the owning class.
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.

For example, to facilitate the invocation of a method, all methods in the math class in the Java API are static, and the static method inside the generic class is convenient for other classes to call the method.

A static method is a special kind of method inside a class that declares the corresponding method static only when it is needed, and a method inside a class is generally non-static

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.

Sometimes you want to define a class member so that its use is completely independent of any object of that class. Typically, a class member must be accessed through the object of its class, but it can create a member that can be used by itself without referencing a particular instance. Such a member can be created by adding the keyword static (static) before the member's declaration. If a member is declared static, it is able to be accessed before any object of its class is created, without having to reference any object. You can declare methods and variables as static. The most common example of a static member is main (). Because main () must be called when the program starts executing, it is declared as static.

A variable declared as static is essentially a global variable. When declaring an object, the copy of the static variable is not produced, but all instance variables of the class share the same static variable. The method declared as static has the following limitations:
•
They can only invoke other static methods.
•
They can only access static data.
•
They cannot refer to this or super in any way (the keyword super is related to inheritance, as described in the next chapter).
If you need to initialize your static variable with a calculation, you can declare a static block that executes only once when the class is loaded. The following example shows a class that has a static method, some static variables, and a static initialization block:
Demonstrate static Variables,methods,and blocks.

Class Usestatic {
static int a = 3;
static int b;

static void meth (int x) {
System.out.println ("x =" + x);
System.out.println ("a =" + a);
System.out.println ("b =" + B);
}

static {
System.out.println ("Static block initialized.");
b = A * 4;
}

public static void Main (String args[]) {
Meth (42);
}
}

Once the Usestatic class is loaded, all static statements are run. First, A is set to 3, then the static block executes (prints a message), and finally, B is initialized to a*4 or 12. Then call Main (), main () call meth () and pass the value 42 to X. The 3 println () statements refer to two static variables A and B, and the local variable x.

Note: Referencing any instance variable in a static method is illegal.

The following is the output of the program:

Static block initialized.
x = 42
A = 3
b = 12
Outside of the classes that define them, static methods and variables can be used independently of any object. This way, you can just add the number operator to the name of the class. For example, if you want to invoke a static method from outside the class, you can use the following common format:

Classname.method ()

Here, ClassName is the name of the class, and the static method is defined in the class. As you can see, this format is similar to calling a non-static method through an object reference variable. A static variable can be accessed in the same format-the class name dot number operator. This is how Java implements a control version of global functionality and global variables.

Here is an example. In main (), the static method CallMe () and the static variable B are accessed outside their classes.

Class Staticdemo {
static int a = 42;
static int b = 99;
static void CallMe () {

System.out.println ("a =" + a);
}
}

Class Staticbyname {

public static void Main (String args[]) {
Staticdemo.callme ();
System.out.println ("b =" + STATICDEMO.B);
}
}

The following is the output of the program:

A = 42
b = 99

A static member cannot be accessed by an instance created by its class.

If the member without the static adornment is an object member, it is owned by each object.

The member of the static modifier is a class member, which can be called directly by a class, and is common to all objects.

Static explanation in Java