The difference between static methods and non-static methods in java

1. Static method (static method)

Like static member variables, they belong to the class itself. They are loaded into the memory when the class is loaded and are not automatically destroyed. They will remain in the memory until the JVM is closed;

2. Non-static method

Also known as instantiation method, it belongs to the instance object. Memory will be allocated after instantiation and must be referenced through an instance of the class. When the instance object is recycled by the JVM, it also disappears

The difference between static methods and instance methods

1. Life cycle

The life cycle of a static method starts when the process is created and ends when the process ends. Therefore, the static method is global and runs through the entire process.

The life cycle of the instance method starts from the instantiation of the object and continues until the end of the process. The instantiated object ends after being unregistered and recycled

So the life cycle of the instance method is shorter than the life cycle of the static method. This is also the reason why static methods cannot be called in instance methods

2 .Calling method

When calling a static method externally, you can use the "class name. method name" method or the "object. method name" method, that is to say, when calling a static method No need to create an object

Instance methods can only use the "object.method name method"

//-----------hasStaticMethod.java-----------------
public class hasStaticMethod{
//定義一個(gè)靜態(tài)方法
public static void callMe(){
　　System.out.println("This is a static method.");
}
}

The following program uses two forms to call static methods.

//-----------invokeStaticMethod.java-----------------
public class invokeStaticMethod{
　　public static void main(String args[]){
　　hasStaticMethod.callMe(); //不創(chuàng)建對(duì)象，直接調(diào)用靜態(tài)方法 
　　hasStaticMethod oa = new hasStaticMethod();  //創(chuàng)建一個(gè)對(duì)象
　　oa.callMe();   //利用對(duì)象來(lái)調(diào)用靜態(tài)方法
}
}

3. Access restrictions

When static methods access members of this class, they are only allowed to access static members (i.e. static variables and static methods), not Access instance member variables and instance methods; instance methods do not have this restriction

Instance member variables belong to an object, and the object does not necessarily exist when the static method is executed; similarly, if static is allowed If the method accesses the instance member method, it can indirectly access the instance member variable, so it cannot access the instance member method; based on the same reason, the keyword this

//-----------accessMember.java-----------------
class accessMember{
private static int sa; //定義一個(gè)靜態(tài)成員變量
private int ia; //定義一個(gè)實(shí)例成員變量
//下面定義一個(gè)靜態(tài)方法
static void statMethod(){
　　int i = 0;  //正確，可以有自己的局部變量sa = 10;  
　　//正確，靜態(tài)方法可以使用靜態(tài)變量
　　otherStat(); 
　　//正確，可以調(diào)用靜態(tài)方法
　　ia = 20;  //錯(cuò)誤，不能使用實(shí)例變量
　　insMethod(); //錯(cuò)誤，不能調(diào)用實(shí)例方法
}
static void otherStat(){} 
//下面定義一個(gè)實(shí)例方法 
void insMethod(){
　　int i = 0;  //正確，可以有自己的局部變量
　　sa = 15;  //正確，可以使用靜態(tài)變量
　　ia = 30;  //正確，可以使用實(shí)例變量
　　statMethod();  //正確，可以調(diào)用靜態(tài)方法
}
}

4 cannot be used in the static method. 4. Execution Sequence

When a class file is loaded into the JVM by ClassLoader, the method instructions are saved in the Stack. At this time, there is no data in the Heap area. Then the program technician starts to execute the instruction. If it is a static method, the instruction code is executed directly in sequence. Of course, the instruction code cannot access the Heapshuju data area at this time; if it is an instance method (the instance method has an implicit incoming parameter, the parameter It is given to it by the JVM. This parameter is the memory address of the instance object in the Stack, so the instance method can find its own data in the Heap). The object must be instantiated before calling, allocate data in the Heap, and Pass the memory pointer in the Stack to the instance method through the JVM's implicit parameters. If you call it directly without instantiating it, an error will be reported because the implicit parameter has no value.

The above is the detailed content of The difference between java static methods and non-static methods. For more information, please follow other related articles on the PHP Chinese website!