Java know how many static keywords and Java static variables and static methods

The static modifier can be used with variables and methods, which means "static".

Static variables and static methods can be accessed through the class name and do not need to create a class object to access the static members of the class, so the static decorated members are also known as class variables and class methods. Static variables are different from instance variables, and instance variables are always accessed through objects because their values differ between objects and objects.

Take a look at the following example:

1  Public classDemo {2     Static inti = 10;3     intJ;4 Demo () {5          This. J = 20;6     }7      Public Static voidMain (string[] args) {8SYSTEM.OUT.PRINTLN ("Class variable i=" +demo.i);9Demo obj =NewDemo ();TenSYSTEM.OUT.PRINTLN ("instance variable j=" +OBJ.J); One     } A}

Operation Result:

Class variable i=10
Instance variable j=20
Static variables that are statically memory-allocated are classes that do not belong to any independent object, so you can access static variables without creating an instance of the class. The result is that the compiler creates only one copy of the static variable for the entire class, that is, allocating only one memory space, although there are multiple instances, the instances share the memory. Instance variables are different, each time an object is created, the memory space is allocated once, the memory of different variables is independent from each other, and changing the instance variable of a object does not affect the B object.

Take a look at the following code:

1  Public classDemo {2     Static inti;3     intJ;4      Public Static voidMain (string[] args) {5Demo obj1 =NewDemo ();6OBJ1.I = 10;7OBJ1.J = 20;8        9Demo Obj2 =NewDemo ();Ten         OneSystem.out.println ("obj1.i=" + obj1.i + ", obj1.j=" +OBJ1.J); ASystem.out.println ("obj2.i=" + obj2.i + ", obj2.j=" +obj2.j); -     } -}

Operation Result:

obj1.i=10, obj1.j=20
obj2.i=10, obj2.j=0

Note: Although static variables can also be accessed through objects, they are not advocated and the compiler generates warnings.

In the above code, I is a static variable, change the value of I by OBJ1, will affect the obj2;j is an instance variable, by obj1 change the value of J, will not affect the obj2. This is because obj1.i and obj2.i point to the same memory space, and OBJ1.J and OBJ2.J point to different memory spaces, see:
Figure 1 Static variable memory allocation
Note: Static variables are initialized when the class is loaded. That is, whenever a class is loaded, it will be initialized whether or not you use the static variable.

Summary: Class variables is modified with the keyword static, when the class is loaded, allocates the memory of the class variable, and later generates the class's instance object, the memory (class variable) will be shared, and any modification of the class variable by any object will affect other objects. There are two external access methods: Access by object or by class name. Static methods A static method is a method that cannot be manipulated to an object. For example, the POW () method of the Math class is a static method with the syntax of Math.pow (x, a), which computes the power of a in X, without creating any Math objects.

Because static methods cannot manipulate objects, instance variables cannot be accessed in static methods, only static variables of their own classes can be accessed.

Static methods can be used in the following situations:

• A method does not require access to the object state, and its required parameters are provided by explicit arguments (for example, Math.pow ()).
• A method only needs to access the static variables of the class.

The reader must note that main () is also a static method and does not operate on any object. In fact, there are no objects at the start of the program, and the main () method is the entry for the program, which is executed and the object required by the program is created.

A summary of static variables and static methods:

• A static method of a class can only access static variables;
• A static method of a class is not able to invoke a non-static method directly;
• Static variables and static methods can also be accessed through objects, but not recommended, as access control permissions allow;
• The current object does not exist in the static method and therefore cannot be used, nor can the super be used, of course;
• Static methods cannot be overridden by non-static methods;
• The construction method does not allow the declaration to be static;
• Local variables cannot use static adornments.

Examples of static methods:

1  Public classDemo {2     Static intSumintXinty) {3         returnX +y;4     }5      Public Static voidMain (string[] args) {6         intsum = Demo.sum (10, 10);7System.out.println ("10+10=" +sum);8     }9}

Operation Result:

10+10=20

The static method does not require any instances of the class it belongs to be called, so there is no this value and the instance variable cannot be accessed, otherwise it will cause a compilation error.

Note: Instance variables can only be accessed through objects and cannot be accessed through a class.
Static initializers (static block) blocks are a piece of code surrounded by curly braces. Static Initializer is a static block that exists in the class, outside of the method. Static initializers are only executed once when the class is loaded (the first time the class is used) and are often used to initialize static variables.

Example code:

1  Public classDemo {2      Public Static inti;3     Static{4i = 10;5System.out.println ("Now in Static block."));6     }7      Public voidTest () {8System.out.println ("Test method:i=" +i);9     }Ten      Public Static voidMain (string[] args) { OneSystem.out.println ("demo.i=" +demo.i); A         NewDemo (). Test (); -     } -}

The operating result is:

Now in static block.
demo.i=10
Test method:i=10
Static import static import is a new feature of Java 5 that imports static variables and static methods for classes.

In general, we import classes that write:

1 Import // to import a particular class

Or

1 Import // Import all classes in a package

Static imports can be written like this:

1 Import Static // to import a specific static method

Or

1 Import Static // Import all static members in a class

After importing, you can call a static method directly in the current class using the method name without having to use classname.methodname to access it.

For static variables and static methods that are used frequently, you can import them statically. The advantage of a static import is that it simplifies some operations, such as the output statement System.out.println (); The out in is the static variable of the System class, which can be java.lang.system.* by the import static; Import it, and the next time you call Out.println ().

Take a look at the following code:

1 Import Staticjava.lang.system.*;2 Import StaticJava.lang.Math.random;3  Public classDemo {4      Public Static voidMain (string[] args) {5Out.println ("generated by a random number:" +random ());6     }7}

Operation Result:

A random number generated: 0.05800891549018705

Series Articles:

Java know how much (1) Language overview

Java know how much (2) virtual machine (JVM) and cross-platform principle

Java know how much (3) employment direction

Java know how much (4) the difference between J2SE, Java EE, J2ME

Java know how much (5) Build Java development environment

Java know how much (6) The first example of a program

Java knows how many (7) classes and objects

Java know how much (8) class library and its organizational structure

Java know how much (9) Import and Java class search path

Java know how much (10) data types and variables

Java know how much (11) data type conversions

Java know how many (12) operators

Java know how much (13) Process Control

Java know how many (14) arrays

Java know how much (15) string

Java know how much (StringBuffer) and Stringbuider

Java know how much (17) emphasize the programming style

Java know how many (18) classes are defined and instantiated

Java know how many (19) access modifiers (access control characters)

Java knows how many (20) variables are scoped

Java know how much (+) This keyword is detailed

Java know how many (22) method overloads

Java know how much (23) the basic run order of classes

Java know how much (24) packaging class, unpacking and packing detailed

Java know how much (25) More about Java package

Java know how much (26) claim rules for source files

Java know how much (27) the concept and implementation of inheritance

Java know how many super keywords

Java know how much (29) Overwrite and reload

Java know how much (30) polymorphic and dynamic binding

Java know how many static keywords and Java static variables and static methods

Java know how many static keywords and Java static variables and static methods