The difference between static methods and instance methods in java

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

When calling static methods externally, you can use "class name" .Method name" method, you can also use the "Object name.Method name" method. 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 restriction.

The following examples illustrate this difference.

1. Call static method instance

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.

public class invokeStaticMethod{
　　public static void main(String args[]){
　　hasStaticMethod.callMe(); //不创建对象，直接调用静态方法  
　　hasStaticMethod oa = new hasStaticMethod();  //创建一个对象
　　oa.callMe();   //利用对象来调用静态方法
}
}

It is allowed for the program to call static methods twice. 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 Java's way of reducing programmer calls. It eliminates the trouble of using some common methods and allows programmers to use methods in the traditional way of using functions in C language.

2. Example of static method accessing member variables

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.

Recommended tutorial: Java tutorial

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