Why is the main method in Java public?

Question

Amruta Jahagirdar · Answer

Let discuss access modifiers private and public in context of any method not just main() method.

1. When you declare a method public then it is accessible outside the class (By any other class)

2. when you declare a method private it means that method is visible/accessible only by that same class and not outside.

Now next point is, who is going to call your main() method? It is Run time environment (be it java or .net). Run time environment is something that is outside of your class and unless you grant it a permission to access your main() method by making it public, it will not be able to call it.

So, as you know that program's starting point is main() method, it has to be  public so that is accessible outside the class where you declare it.

Let me know if it is clear.

Mayank Srivastava · Answer

Static methods are conceptually the same as static variables, thus the reasons to use or not use them are similar. They belong to the class, not specific objects of that class. An example from the java [ https://coderanch.com/t/689380/careers/Hire-JavaScript-Ninja ] API is Math, all the variables are static. Does it make sense to have to create a Math object just to call a single method? Other then the fact that the methods perform some mathematical operation, there is little relation between them. In other words, there are no logical instance variables that would tie the math methods together. As an aside, you can't instantiate Math, so don't waste time trying.

A simple answer to why and when is 'whenever it makes sense". If a method needs to be in a class, but not tied to an object, then it makes sense. If the method is more logically part of an object, then it shouldn't be

Main is static because someone at Sun decided it would be better if the JVM could call main without creating an object first. It probably simplified the design of the JVM.

Now on why should be use :

To use a particular method in Java [ http://www.javaranch.com/ ] we first create a object to class which that method belongs to.Then by using object name.method name we call that method.

Example:
class Demo1
{
static dummyMethod1()
{
----------
-------
}
}

class Sample
{
public static void main()
{

//Use demo class method using classname.methodname
Demo1.dummyMethod1();

2.what all situations in which we can use static methods ?

The advantage of static method is we can use that method using classname.methodname without creating object to class to which it belongs.

Example: 
class Demo
{
int dummyMethod()
{
----------
-------
}
}

class Sample
{
public static void main()
{ 
//create object to demo class 
Demo obj=new Demo();

//Use demo class method using object
obj.dummyMethod();

3.why main is static?

To call a method in java we need an object.Program execution starts from main method we dont have a object to call main method in the begining.When JVM sees main method in program it starts execution from there.Since main method is static we can execute it without creating an object.

4.where should we must use static and where satic methods should not be used?

NOW YOU can answer this question i guess.

Girish Rawat · Answer

Everything that we define in a class is called a member of the class. Members of a class can be of two types:

* Instance Member
 * Class Member
Instance Member

A member which describe some property or behavior of an object of the defined class, is called an Instance Member. E.g. let India be a class then all the Indians are its objects. Each Indian has some properties such as name, age, qualification etc. Value of these properties differ from Indian to Indian i.e. object to object. These properties are examples of Instance members.

Class Member

A member which describe some property or behavior of the defined class as a whole, is called a Class Member. E.g. India as a class also has some properties such as currency, capital, flag etc. Value of these properties is common for all the Indians i.e all the objects. These properties are examples of class members.

By default each member of a class is assumed to be Instance Member. To define class members static keyword is used.

Infact behavior is not only associated with objects but it is also associated with classes and family of classes.

The main() method of a class denotes the entry point of the class. It is like opening a school. Once the school is opened, employees, teachers and students arrive as objects to manifest their behavior. As class members are associated to the class, no object is required to access them. By default each member is associated to object hence to associate the main() method to the class, it is qualified by static keyword.

In other words, main method represents the execution of the class not the execution of a particular objects of the class, bcz it represents execution of the class,it means it should be a class member, and class member won’t create automatically we have to specify them. That’s why static keyword is used.

Prithwiman Mazumdar · Answer

The reason main() method is static in Java is, so that you can call the main method without the need to create an object of the class in which main() method resides.

The main() method is the entry point of the program…it does not makes sense to create an object just for the sake of starting the execution of a program.

When you create a class like: -

[code]class Demo
{
   public static void main(String args[])
   {
      System.out.println("I am main method");
   }
}
[/code]In order to execute the above code the JVM would simply use the following statement to execute the main() method of the class: -

[code]Demo.main();
[/code]If the main method was non-static then the JVM would first have to create an object of Demo class and then using that object it would have to call the main() method.

[code]Demo obj=new Demo();
obj.main();
[/code]This certainly does not makes sense and is just an overhead.

The keyword static let's you call a method without the need to create an object of the class hence main method is always made static.

Hope this helps you!!!

Big Deals 24/7 · Answer

The [code ]main()[/code] method in Java is often declared as [code ]static[/code] because it needs to be accessible without creating an instance of the class. The [code ]static[/code] keyword allows the method to be called directly by the class itself, without needing to instantiate an object. This is essential for the entry point of a Java program, as it enables the Java Virtual Machine (JVM) to invoke the method without having an object of the class.

In other words, marking [code ]main()[/code] as [code ]static[/code] ensures that it can be executed without the need for an instance of the class, making it suitable for starting the program

Manish K Singh · Answer

Java program's main method has to be declared static because keyword static allows main to be called without creating an object of the class in which the main method is defined.

The public keyword is an access specifier, which allows the programmer to control the visibility of class members. When a class member is preceded by public, then that member may be accessed by code outside the class in which it is declared. In this case, main must be declared as public, since it must be called by code outside of its class when the program is started.

Example -

package com.kmanishsingh1.Quora;

[code]public class DriverClass {
		static void sayHello(){
			System.out.println("Hello");
		}
	  public static void main(String[] args) {
		  sayHello();
	}

}
[/code]Follow me Manish K Singh [ https://www.quora.com/profile/Manish-K-Singh-10 ]

Priya Kumari · Answer

Static members(like variables, methods, class) can be called in three ways:

1. Directly
2. Class name
3. Through object
whereas non-static members can be called only by object of the same class or other class(depending on access specifier used).

In Java JVM is responsible to call the main() method and it calls it only by class name so main() method is static in Java.

Suppose we have a class called demo and it is saved as demo.java, so to compile it we write:

javac demo.java

and to run the demo class, we write:

java demo (i.e., we are calling the main() method to execute the program by class name)

Rahul P Sathyan · Answer

Because.,,

public : “public” is an access specifier which can be used outside the class. when main method is declared public it means it can be used outside the class.

static : To call a method we require object. sometimes it may be require to call a method without the help of object. Then we declare a method as static. JVM calls the main() method without creating object by declaring keyword static.

void : void return type is used when a method doesn't return any value.main() method doesn't return any value,so main() is declared as void. Signature : public static void main(string[] args) {……}

Himanshu Agarwal · Answer

As you already must have figured out by now is that the 'main' method you are talking about is entry point of your code. Here is small example of little java class with main method :

[code]public class A //The class name is in you control
{
	public A(int param1, int param2) 
//Number of arguments and their data type is in your control 
	{
		
	}

public static void main(int[] args)
	{
	}
}

[/code]Now, have a look for the signature of 'main' method. Lets assume the method is not 'static' and JVM has to call that function. Than JVM has to create a object of class 'A' and that can only be done by knowing constructor of that class and now JVM has to decide what to pass as param1 and param2 in that constructor.

So, by above example it is clear that the method has to be accessible without creating the object of the class in which it resides and that can only be done by having it as 'static'

Himanshu Sardana · Answer

Thanks for A2A!

If we make main method private , JVM won't be able to call that main method so the code wont be executed to avoid this it will give you compile time error as follows.

The program compiled successfully, but main class was not found. Main class should contain method: public static void main (String[] args).

I hope my explanation helped you. Please feel free to correct me!

Nalin Savara · Answer

Nothing hard and fast about a "public static void main" -- it is merely a convention.
If you want even you can write wrapper for the JVM which uses a different method or calling convention or which does things totally differently.

The "AppletViewer" as well as the browser's "applet running functionality" and also browser's calling conventions for java Web apps are examples of wrappers that use different calling conventions than above.

Servlet containers etc are still other examples of other calling conventions.

Advantage of having a static method main is that there is just one indisputable entry point to code.
Having a class method that needed class instantiation would mean that possibly class variables would also get initialized before constructor and so many constructors could be the possible entry point making things harder to debug.

But like I said... it is merely a convention. .. If you want, write something different.

Himanshi Joshi · Answer

Reasons:

1. Since main method is static Java virtual Machine can call it without creating any instance of class which contains main method.

2. Since C and C++ also has similar main method which serves as entry point for program execution, following that convention will only help Java.

3. If main method were not declared static than JVM has to create instance of main Class and since constructor can be overloaded and can have arguments there would not be any certain and consistent way for JVM to find main method in Java.

4. Anything which is declared in class in java comes under reference type and requires object to be created before using them but static method and static data are loaded into separate memory inside JVM called context which is created when a class is loaded. If main method is static than it will be loaded in JVM context and are available to execution.

More refer from here: Why is the Java main method static? [ http://stackoverflow.com/questions/146576/why-is-the-java-main-method-static ]

Amandeep Kaur · Answer

The role of adding static before any entity is to make that entity a class entity. It means that adding static before methods and variables make them class methods and class variables respectively, instead of instance methods and instance variables.
Hence, static methods and variables can be directly accessed with the help of Class, which means that there is no need to create objects in order to access static methods or variables.

1. // Making a static function class GfG { static void func() {} } // Calling a static function GfG.func();
2. Static main() method: When the static keyword is added in the function definition of main() method, then it is known as static main() method.
3. class GfG {
// Making a static main function public static void main(String[] args) {}

}

Ivan Jadrić · Answer

It must be static due to how instancing works! In java static methods are loaded once in memory, and accessed from that point! Having multiple instances of a main method would obviously lead to severe problems!

Rishabh Kumar · Answer

First of all, main() is just a starting point of a program which tell the JVM where to start. Now if you want to the main() to be called via an object,then for it, a class needs to be made. Suppose you have a program having multiple classes in a single .java file, then how would JVM know where to start?  It is made static so that it is available to the JVM at koad time! Also, JVM needs to know where to start the execution! :)

Peeyush Pathak · Answer

jvm knows main method which is a public static method. so when run your java program then it will call the main method.
Making it public and static make is usable from anywhere.

in thread queue it calls the run method. so these things are defined while designing the language. 
Even c has public main method.

There can be different ways of doing it this was the best at the time of designing it.

Farhan Ghafoor · Answer

If it is not static and needs an instance then where will you create that instance ? it is kind of a chicken/egg situation on which comes first.

Making it static simply solves the issue and determines one (and always one) entry point in the class that you want your program to start with.

Simple !

Raja Rahul Ray · Answer

In java, the java compiler starts its execution from the main function (just like void main() in C an C++) .

To your question of why is it public static void main, I’ll separate the words :

* public : a keyword in java which is used to denote that the things after it are accessible anywhere in the program.
eg. public int x = 10; can be accessible to any method in the class

* static : a keyword which specifies that there is no need to create an instance of the method or variable which is declared static and it can be accessed anywhere in the program.
eg. if static int x = 10, and it is shared to two different functions A() and B(), then even if x gets changed to x= 20 in B() then it gets also gets changed in A().

* void : just like it means i.e. empty which is generally prefixed after a method which we don’t want to return anything.
 * main(): the main method is where the program actually starts to execute.
So, based on the above information you can conclude that the public static void main() means that main function (which is called foremost in every program) is accessible in all program, which does not needs to be instantiated and returns nothing .

/*Feel free to ask it again if you do not get it or not getting it properly.*/

Sudo Demon · Answer

Always remember ... there are no private or protected top level classes in java. (INNER classes can be private or protected).

A top-level class as private would be completely useless because nothing would have access to it. SO whether it has main method or any other method...we don't declare classes private. On the contrary inner classes can be accessed by outer classes so they can be private or protected.

Dave Wolf · Answer

Every Java program has one starting point:

public static void main(String args[])

Here's what that means....

* public: means the method is accessible to all classes
 * static: allows main() to be called without instantiating the class
 * void: means that no value is to be returned
 * main(): is the method name
 * String args[ ]: means an array of String objects that are passed from the command line