Static keyword parsing in Java

I. Purpose of the STATIC keyword

In the Java programming thought P86 page, there is a passage:

　　The static method is the method without this. A non-static method cannot be called inside a static method, which in turn is possible. It is also possible to invoke the static method only through the class itself, without creating any objects. This is actually the primary use of the static method. ”

While this remark only illustrates the special character of the static method, it is possible to see the basic role of the static keyword, in short, one sentence to describe:

　　Makes it easy to invoke (method/variable) without creating an object.

Obviously, a method or variable modified by the static keyword does not have to rely on an object for access, as long as the class is loaded, it can be accessed through the class name.

Static can be used to modify member methods of a class, member variables of a class, and you can write static code blocks to optimize program performance

1) static method　

Static methods are commonly referred to as static methods, and because they can be accessed without relying on any object, there is no this for static methods because it is not attached to any object, and since there are no objects, this is not the case. And because of this feature, non-static member variables and non-static methods of the class cannot be accessed in a static method, because non-static member methods/variables must be dependent on a specific object to be able to be called.

It is important to note, though, that non-static member methods and non-static member variables cannot be accessed in static methods, but static member methods/variables are accessible in non-static member methods. To give a simple example:

In the above code, because the Print2 method is independent of the object, can be called in Print1 () directly through the class name, in Print2 () directly call Print1 () will be error, STR1, str2 call is the same reason .

If you can access a non-static method/variable in a static method, then if you have the following statement in the Main method:

　　Myobject.print2 ();

At this time the object is not, STR2 does not exist at all, so there will be contradictions. The same is true for methods, because you cannot predict whether non-static member variables are accessed in the Print1 method, and you also prohibit access to non-static member methods in static member methods.

For non-static member methods, it is clear that there is no limit to accessing static member methods/variables.

Therefore, if you want to call a method without creating an object, you can set this method to static. Our most common static method is the main method, and as for why the main method must be static, it is now clear. Because the program does not create any objects when it executes the main method, it is only accessible through the class name.

　　Also remember that the constructor of a class is actually a static method even if it is not declared as static.

2) Static variable

Static variables are also known as static variables, except that the static variables are shared by all objects, only one copy in memory, and are initialized only when the class is first loaded. Instead of static variables, which are owned by an object, are initialized when the object is created, there are multiple copies, and the replicas owned by each object do not affect each other.

The initialization order of static member variables is initialized in the order in which they are defined.

3) Static code block

Another key function of the static keyword is to form static blocks of code to optimize program performance. A static block can be placed anywhere in the class and can have more than one static block in the class. When the class is first loaded, each static block is executed in the order of the static blocks and is executed only once.

Why static blocks can be used to optimize the performance of a program because of its nature: it executes only once when the class is loaded. Let's look at an example:

1 classperson{2     PrivateDate birthDate;3      4      PublicPerson (Date birthDate) {5          This. birthDate =birthDate;6     }7      8     BooleanIsbornboomer () {9Date StartDate = date.valueof ("1946");TenDate endDate = date.valueof ("1964"); One         returnBirthdate.compareto (startdate) >=0 && Birthdate.compareto (endDate) < 0; A     } -}

Isbornboomer is used to determine if this person was born in 1946-1964, and each time Isbornboomer is called, it generates StartDate and birthdate two objects, resulting in a wasted space, which would be better if it was changed to such an efficiency:

classperson{PrivateDate birthDate; Private StaticDate startdate,enddate; Static{StartDate= Date.valueof ("1946"); EndDate= Date.valueof ("1964"); }          PublicPerson (Date birthDate) { This. birthDate =birthDate; }         BooleanIsbornboomer () {returnBirthdate.compareto (startdate) >=0 && Birthdate.compareto (endDate) < 0; }}

As a result, some initialization operations that only need to be performed once are placed in a static block of code.

Two. The error of the static keyword

Does the 1.static keyword change the access rights of members in a class?

Some beginner friends confuse the static in Java with the function of the static keyword in C + +. Here's just one thing to keep in mind: unlike static in C + +, the static keyword in Java does not affect the scope of a variable or method. The only private, public, protected (including package access rights) keywords that can affect access in Java. See the following example to understand:

The error "Person.age is not seen" indicates that the STATIC keyword does not alter the access rights of variables and methods.

2. Can I access static member variables through this?

Although there is no this for static methods, is it possible to access static member variables through this in a non-static method? Let's look at one of the following examples, what is the result of this code output?

　　

1  Public classMain {2     Static intValue = 33;3  4      Public Static voidMain (string[] args)throwsexception{5         NewMain (). Printvalue ();6     }7  8     Private voidPrintvalue () {9         intValue = 3;TenSystem.out.println ( This. value); One     } A}

The output is the result of

This is the understanding of the main expedition this and the static. What does this represent? This represents the current object, so the current object is the object generated through new main () by calling Printvalue with new Main (). The static variable is enjoyed by the object, so the value of This.value in Printvalue is undoubtedly 33. The value inside the Printvalue method is a local variable and cannot be associated with this at all, so the output is 33. Keep in mind here: Static member variables are independent of objects, but do not mean that they cannot be accessed through objects, and all static and static variables can be accessed through objects (as long as access rights are sufficient)

Can 3.static act on local variables?

Static is a scoped local variable in C + +, but in Java it is important to remember thatstatic is not allowed to decorate local variables . Do not ask why, this is the Java syntax of the provisions.

Three. Common written test questions

The following are some of the interview written in the frequently encountered on the static keyword of the topic, for reference only, if there are additional welcome comments below.

1. What is the output of the following code?

1  Public classTestextendsbase{2  3     Static{4SYSTEM.OUT.PRINTLN ("Test Static");5     }6      7      PublicTest () {8System.out.println ("Test constructor");9     }Ten       One      Public Static voidMain (string[] args) { A         NewTest (); -     } - } the   - classbase{ -       -     Static{ +System.out.println ("Base Static"); -     } +       A      PublicBase () { atSystem.out.println ("Base constructor"); -     } -}

Staticstaticbase Constructortest constructor

View Code

As to why this is the result, we do not discuss, first of all, to think about this code specific execution process, at the beginning of execution, the first to find the main method, because the main method is the entry of the program, but before executing the main method, you must first load the test class, When loading the test class, it is found that the test class inherits from the base class, so it will go first to load the base class, and when the base class is loaded, the static block is executed. After the base class is loaded, the test class continues to load, and then the static block is executed when the test class is found with a static block. After the required classes have been loaded, the main method is executed. When you execute new Test () in the main method, the constructor of the parent class is called first, and then the constructor for itself is called. As a result, the above output appears.

2. What is the output of this piece of code?

1  Public classTest {2Person person =NewPerson ("Test");3     Static{4SYSTEM.OUT.PRINTLN ("Test Static");5     }6      7      PublicTest () {8System.out.println ("Test constructor");9     }Ten       One      Public Static voidMain (string[] args) { A         NewMyClass (); -     } - } the   - classperson{ -     Static{ -SYSTEM.OUT.PRINTLN ("Person static"); +     } -      PublicPerson (String str) { +System.out.println ("person" +str); A     } at } -   -   - classMyClassextendsTest { -Person person =NewPerson ("MyClass"); -     Static{ inSystem.out.println ("MyClass Static"); -     } to       +      PublicMyClass () { -System.out.println ("MyClass constructor"); the     } *}

staticstatic staticperson testtest constructorperson myclassmyclass Constructor

View Code

Similarly, let's consider the specific implementation of this code. The test class is loaded first, so the static blocks in the test class are executed. Then the new MyClass () is executed, and the MyClass class is not loaded, so the MyClass class needs to be loaded. When loading the MyClass class, it is found that the MyClass class inherits from the test class, but because the test class has already been loaded, only the MyClass class needs to be loaded, then the static blocks in the MyClass class are executed. After loading, the object is generated from the constructor. When generating an object, the member variable of the parent class must be initialized, so the person person in test = new person () is executed, and the person class is not loaded, so the person class is loaded first and the static block in the person class is executed. Then executes the constructor of the parent class, completes the initialization of the parent class, and then initializes itself, then executes the person person in MyClass = new person () and finally executes the MyClass constructor.

3. What is the output of this piece of code?

1  Public classTest {2      3     Static{4SYSTEM.OUT.PRINTLN ("Test static 1");5     }6      Public Static voidMain (string[] args) {7          8     }9      Ten     Static{ OneSYSTEM.OUT.PRINTLN ("Test static 2"); A     } -}

static 1static 2

View Code

Although there is no statement in the main method, it will still be output, for reasons already described above, loading is executed. In addition, the static block can appear anywhere in the class (as long as it is not inside the method, remember that no method is internal), and execution is performed in the order of the static blocks.

Static keyword parsing in Java