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{
//定义一个静态方法
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(); //不创建对象，直接调用静态方法
hasStaticMethod oa = new hasStaticMethod(); //创建一个对象
oa.callMe(); //利用对象来调用静态方法
}
}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; //定义一个静态成员变量
private int ia; //定义一个实例成员变量
//下面定义一个静态方法
static void statMethod(){
int i = 0; //正确，可以有自己的局部变量sa = 10;
//正确，静态方法可以使用静态变量
otherStat();
//正确，可以调用静态方法
ia = 20; //错误，不能使用实例变量
insMethod(); //错误，不能调用实例方法
}
static void otherStat(){}
//下面定义一个实例方法
void insMethod(){
int i = 0; //正确，可以有自己的局部变量
sa = 15; //正确，可以使用静态变量
ia = 30; //正确，可以使用实例变量
statMethod(); //正确，可以调用静态方法
}
}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!