Go Static keyword parsing in Java

Reproduced:

Http://www.cnblogs.com/dolphin0520/p/3799052.html

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 member 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, it can be called directly with the class name. 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:

class person{    private  Date birthDate;           Public Person (Date birthDate) {        this. birthDate = birthDate;    }           Boolean Isbornboomer () {        = date.valueof ("1946");         = Date.valueof ("1964");         return Birthdate.compareto (startdate) >=0 && Birthdate.compareto (endDate) < 0;}    }

Isbornboomer is used for this person is born 1946-1964, and each time Isbornboomer is called, will generate StartDate and birthdate two objects, resulting in space waste, if changed to such efficiency will be better:

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?

 Public class Main {     staticint value =;       Public Static void throws exception{        new  Main (). Printvalue ();    }      Private void Printvalue () {        int value = 3;        System.out.println (this. value);    }}

Operation Result:

33

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. Always keep in mind that static member variables, while independent of the object, do not mean that they cannot be accessed through objects, and that all static and static variables can be accessed through the object (as long as access is 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?

 Public classTestextendsbase{Static{System.out.println ("Test Static"); }          PublicTest () {System.out.println ("Test constructor"); }          Public Static voidMain (string[] args) {NewTest (); }} classbase{Static{System.out.println ("Base Static"); }          PublicBase () {System.out.println ("Base constructor"); }}

Staticstaticbase Constructortest constructor 


As to why this is the result, we do not discuss, first think about this code specific implementation process,
At the beginning of execution, find the main method first, because the main method is the entry of the program, but before executing the main method,
The test class must be loaded first, and when the test class is loaded it is found that the test class inherits from the base class, so it goes first to load the base class,
When the base class is loaded, a static block is found and a static block is executed. After the base class has finished loading,
continues to load the test class and then discovers that there is a static block in the test class that executes the static block. After the required classes have been loaded,
Starts executing the Main method. 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?

 Public classTest { person person=NewPerson ("Test"); Static{System.out.println ("Test Static"); }          PublicTest () {System.out.println ("Test constructor"); }          Public Static voidMain (string[] args) {NewMyClass (); }} classperson{Static{System.out.println ("Person Static"); }     PublicPerson (String str) {System.out.println ("Person" +str); }}  classMyClassextendsTest { person person=NewPerson ("MyClass"); Static{System.out.println ("MyClass Static"); }          PublicMyClass () {System.out.println ("MyClass Constructor"); }}

static staticstatic persontesttest Constructorperson Myclassmyclass constructor  


Similarly, let's consider the specific implementation of this code. Load the test class first,
Therefore, the static blocks in the test class are executed. Then execute new MyClass (), and the MyClass class has not yet been loaded,
Therefore, the MyClass class needs to be loaded. When loading the MyClass class, it is found that the MyClass class inherits from the Test class,
However, since 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 is executed = new person (),
The person class has not been loaded, so the person class is loaded first and the static block in the person class is executed, and then the constructor of the parent class is executed.
The initialization of the parent class is completed, and then it is initialized itself, so it executes the person person in MyClass = new person () and finally executes the MyClass constructor.

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

 Public class Test {         static{        System.out.println ("test static 1");    }      Public Static void Main (string[] args) {             }         static{        System.out.println ("Test static 2") );    }}

Static 1static 2


Although there is no statement in the main method, it is still output, as explained above.
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.

Resources:

http://lavasoft.blog.51cto.com/62575/18771/

Http://www.51cto.com/specbook/24/35011.htm

http://blog.csdn.net/zhu_apollo/article/details/1888219

Http://blog.sina.com.cn/s/blog_70b845780100n9zz.html

http://hi.baidu.com/yuiezt/item/b71ff5fbfe9c385cc8f3370d

http://bbs.csdn.net/topics/330251070

http://yezixingchen.iteye.com/blog/1597186

The idea of Java programming

The first time a Java class is loaded, a static member variable or method is initialized once, but the method is not invoked, and the static member variable is the same level as the static initialization block, and the non-static member variable and the non-static initialization block level are the same.

Initialize the static code of the parent class first---> Initialize the subclass's static code--
Initializes the non-static code of the parent class---> initializes the parent class constructor--->
Initialize subclass non-static code---> Initialize Subclass constructors

Go Static keyword parsing in Java