Why can other methods be “static” but a constructo

Question

I do not understand why the main method has to be static. I understand static variables but static methods are difficult for me to grasp. Do static method exists so that one can create two methods with the same name in two different classes that won't clash with each other?

Also, I don't understand why I can't create a static constructor.

Could anyone help explain this concept?

Answer 1

Static methods belong to a class, not an object. The main method must be static because it is called first, before any other code has executed to instantiate any objects. It provides an entry point to the program. Static methods are called from outside of the container of an object. The same is true of static class variables. Only one copy exists for the entire class, as opposed to a member variable, which is created once for each object created from a class. They are used to store data for the class, such as the number of object instances have been created and not destroyed. This data belongs with the class. A good example of a static method is in the singleton pattern, where the constructor is private and can only be accessed by a static member function. A function outside the class would be unable to replicate this functionality. This method acts on class data and objects, so logically belongs to the same class. This all boils down to encapsulation. A class is responsible only for itself and knows only itself.

On the other hand, object methods are meant to operate on the data associated with a single instance of a class, an object. Constructors are the code that is used to initialize an object and set it's data to an initial state. They are executed immediately (and automatically) after the memory has been allocated to store a new object. Even if you do not explicitly define a constructor, a kind of "default constructor" is executed in order to map the object's member variables and the object's method code to the new object.

Hope this helps.

Answer 2

Just take a look on this link, it will definately help you to understand: Why can't make a constructor static?

AND

Constructor is called at Run-time when we create Objects. Static is same for all objects but all objects have their own state and properties. So, if we have had static constructors creation of one object would affect all the other existing objects. Note: static is class level while constructors related to the objects.

e.g.

  public class Foo
    {
       String name;
       int id;
        // define constructors
           Foo (String name, int id)
        {
            this.name = name;
            this.id = id;
        }

          p s v m(String[] arg)
      {
          Foo f1 = new Foo("Amit",001);
          Foo f2 = new Foo("Rahul",002);
      }
    }

If we create static constructor then both objects(f1 also) will contain the last updated value regarding name and id as Rahul and 002.

Answer 3

Constructor is the property of an object while static has nothing to do with object. That's why there is nothing like static constructor. But we have static block to do the similar task as constructor i.e. initialization of fields etc.

Answer 4

The method declared as static requires no object creation .As we don't create object for the main method it is declared as static.

constructor is implicitly called to initialize an object, so there is no purpose in having a static constructor.

Answer 5

I am sharing one of the reason "why not a java constructor be static".

Simply to say, "A java constructor is always non static" because,

The purpose of the constructor is only to initialize/construct the object, and to make inheritance possible. To do these we need to use the two useful java keywords (cum non-static variables) such as this and super. We will use 'this' to initialize the object. We/Java will use super(ofcourse super()) to invoke super class constructor so that super object(or Object class) created first then the child object(hence the inheritance) If the constructor is static then we cant use that two keywords(non-static variables) inside the constructor(As we know non-static stuff cant be referenced from static context)

So java constructors should not static.

Answer 6

I wrote a simple example as an answer to a related question yesterday which may help make things more understandable: what's the point of java constructor?

The point of Static methods is that they can be called without creating an instance of a class, while "normal" instance methods are related to an instance, and can not be called without one.

Since the Main method of the Main class is the entry point of the program, no instance can possibly have been created yet, so naturally, you can not access it via an instance. Therefore, it is Static, so it can be run as the start of the program.