Detailed explanation of the difference between Java static methods and instance methods

The difference between static methods and instance methods is mainly reflected in two aspects:

When calling static methods externally, you can use the "class name. method name" method, or you can use "object name.method name". Instance methods only have the latter method. In other words, calling static methods does not require creating an object.

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

The following examples illustrate this difference.

1. Example of calling static methods

//-----------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();   //利用对象来调用静态方法
}
}

The program calls the static method twice, both are allowed. The output of the program is as follows:
This is a static method.This is a static method.

Allowing static methods to be called without creating an object is a way for Java to reduce the trouble for programmers when calling certain common methods, and allows programmers to use methods in the traditional way of using functions in C language. A typical example is the use of "Math.ramdon()" in some previous programs to obtain random numbers.
Another typical representative is the array processing tool Arrays

2. Example of static method access to member variables

//-----------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();  //正确，可以调用静态方法
}
}

This example can actually be summarized in one sentence: static methods can only access static members, and instance methods can access static and instance members. The reason why static methods are not allowed to access instance member variables is because instance member variables belong to a certain object, and the object does not necessarily exist when a static method is executed. Similarly, because instance methods can access instance member variables, if a static method is allowed to call instance methods, it will indirectly be allowed to use instance member variables, so it cannot call instance methods. For the same reason, the keyword this cannot be used in static methods.

The main() method is a typical static method. It also follows the rules of general static methods, so it can be called by the system before creating the object.

The above is the entire content of this article. I hope it will be helpful to everyone's study. I also hope that everyone will support the PHP Chinese website.

For more detailed explanations of the differences between Java static methods and instance methods, please pay attention to the PHP Chinese website!