"action" is a very general term. You can do anything with a static method that can be done with non-static method. If anything, you are more restricted in a static method.
You cannot "access" any member variables of the class in a static method (that is any variables NOT declared as static).
The reason that you can do anything with a static method, is that non-static method can ALWAYS be transformed into static methods by simply passing the object to the static method (it WON'T look identical, but the same "actions" can be achieved):
Example:
public class Square{
private double x;//side length of square
public double getArea(){
return x*x;
}
public void setLength(double x){
this.x = x;
}
public double getX(){
return x;
public static double getArea(Square s){
return s.x * s.x;
}
public static void setLength(Square s, double x){
s.x = x;
}
public static void getLength(Square s){
return s.x;
}
}
So you can operate on member fields in static methods AND you can even change the value of member fields (as long as they aren't declared final). Therefore I really don't know what is meant by what action cannot be done by an instance method versus static method.
Notice that for the static methods you ALWAYS have to supply the object you want it to operate on...that is what makes static methods different. Generally speaking if the object is needed by the method, then it should be made as an instance method, if not, if the method can be done with NO knowledge of the object, then it should be made static. Generally, so-called "helper" functions are a good candidate to become static methods.
Edit:
To understand what I mean by "You cannot "access" any member variables of the class in a static method", notice that in my setLength method, I use the keyword "this". "this" refers to the object that called the method. For static methods, there is NO calling object, therefore using the "this" keyword in a static method is a compile time error. If you use "this" in EVERY single instance method, you will see the exact difference in the non-static methods versus the static ones that I supplied (where you always pass the object Square s as a parameter). If you take all of those static methods and remove the keyword static and the parameter Square s, and replace instances of s with the keyword "this", then they become the non-static equivalents.