If I understand the meaning of each keyword correctly, public means the method is accessible by anybody(instances of the class, direct call of the method, etc), while static means that the method can only be accessed inside the class(not even the instances of the class). That said, the public keyword is no use in this situation as the method can only be used inside the class. I wrote a little program to test it out and I got no errors or warnings without putting the public key word in front of the method. Can anyone please explain why public static methods are sometimes use? (e.g. public static void main(String[] args))
Thank you in advance!
4 Answers
Static methods mean you do not need to instantiate the class to call the method, it does't mean you cannot call it from anywhere you want in the application.
5 Comments
user3377437
so if I have a method say
public static void do() in a class named Foo, I can call the method in my main method using something like following? Foo foo = new Foo(); foo.do(); while if the do() method is not public, I can only call the method in the class scope?
slipperyseal
Foo.do() can be called from anywhere. If you call it from within Foo (from a static or non-static method) you can just call do() as it's in scope. You can do this.. Foo foo = new Foo(); foo.do(); but the compiler will actually just call Foo.do() - the instance of foo isn't required.
Pshemo
@user3377437
static methods should be called by class name Foo.do(). It is allowed to use references like Foo f = new Foo(); f.do(); but it is discouraged because it creates impression that you are invoking method on f instance, while in reality compiler changes f.do() into Foo.do() automatically, so you could even write Foo f = null; f.do(); and it will work. If you remove public from method modifiers you will end up with default modifier which is also called package-private. This means that you can call do() only from classes from same package as Foo.slipperyseal
lets not forget do is keyword and can't be used as a method name :)
user3377437
understand! Thank you guys!
Others have already explained the right meaning of static.
Can anyone please explain why public static methods are sometimes use?
public static void main method - the standard entry point for java programs.
It is public because it needs to be called from the outside world.
It is static because it won't make sanse to start a program from an object instance.
static.
That said, the static keyword is not always used because you want to have access to some members in a class without instantiating it, but rather because it makes sense. You keep a property that is shared among all instances in one place, instead of holding copies of it in each instance.
public static (or even public static final) - the definition of constants.
2 Comments
truongnm
"static keyword is not always used because you want to have access to some members in a class without instantiating it, but rather because it makes sense" I don't get this part
Elist
@truongnm I could have probably phrased it better 8 years ago... Let me put it this way:
static on a method only means that the method is accessible from the class rather than only from an instance of the class. static on a field means, additionally, that the field does not reside in memory multiple times (per instance), but only once. This meaning is not relevant for methods, since in Java they only reside in memory per class anyway, not per object.A public static method is a method that does not need an instance of the class to run and can be run from anywhere. Typically it is used for some utility function that does not use the member variables of a class and is self contained in its logic.
The code below chooses a path to store an image based on the image file name so that the many images are stored in a tree of small folders.
public static String getImagePathString(String key){
String res = key.substring(3, 4)+File.separator+
key.substring(2, 3)+File.separator+
key.substring(1, 2)+File.separator+
key.substring(0, 1);
return res;
}
It needs no other information (it could do with a safety check on the size of key)
Comments
A quick guide to some of the options...
public class Foo {
public static void doo() {
}
private static void dont() {
}
public Foo() {
doo(); // this works
dont(); // this works
Foo.doo(); // this works
Foo.dont(); // this works
this.doo(); // this works but is silly - its just Foo.doo();
this.dont(); // this works but is silly - its just Foo.dont();
}
public static void main(String[] args) {
doo(); // this works
dont(); // this works
Foo.doo(); // this works
Foo.dont(); // this works
Foo foo = new Foo();
foo.doo(); // this works but is silly - its just Foo.doo();
}
}
public class Another {
public static void main(String[] args) {
Foo.doo(); // this works
Foo.dont(); // this DOESN'T work. dont is private
doo(); // this DOESN'T work. where is doo()? I cant find it?
}
}
1 Comment
Elist
You skipped an important example: accessing non-static members from a static code will fail if you don't specify an instance for which you wan't to access the member. You also skipped the nice recursion:
public static void main(String[] args) {main(args);};
staticmeans.staticmeans it's a method of the class, not of an instance of the class, sostaticmethods can't access instance fields/methods directly.publicmeans any code can call it.staticmeans "belongs to class". This doesn't mean that it can be accessed only by class, but via class (Foo.staticMethod()).publicmeans that you can use it anywhere in your code (in different class, which can be even placed in different package, even it it doesn't extend this class).