How to overcome limitations of Java's Static Main() Method

Question

I'm trying to work this out.

In my project, i have a file called 'Hello.java' which is the file with the main() argument and which is called when the program is compiled. And I have another file called MyObj.java which has got just a random class I made up to test java's OO features. I'm trying to do this:

class Hello
{
    public MyObj an_obj;
    public static void main(String[] args)
    { 
        setObj();
    }       

    public void setObj()
    {
        this.an_obj.set_size(7);
        say("size is " + this.an_obj.get_size());
    }    
}

In the MyObj.java class i have this code:

public class MyObj
{
    private int size;

    public MyObj()
    {
        //do nothing
    }

    public void set_size(int new_size)
    {
        this.size=new_size;
    }

    public int get_size()
    {
        return this.size;
    }   
}

This however gives the error:

"Cannot make a static reference to non-static method setObj() from the type Hello".

If I add 'static' to the declaration of setObj, i.e

public static void setObj()

Then I get:

Cannot make a static reference to non-static field an_obj.

My question is, how can I accomplish what I'm doing, i.e setting and retreiving an object's field if the only way to start a program is with the Main method, and the main Method can only call static methods?? In what, how can I do anything at all with this limitation of being able to call static methods only?????

Answer 1

You can either add "static" to the member variable as well, or instantiate the class from within your main method. Here is some example code for both approaches:

/* Static */
class Hello {
    public static MyObj an_obj;
    public static void main(String[] args) { 
        setObj();
    }           

    public static void setObj() {
        this.an_obj.set_size(7);
        say("size is " + this.an_obj.get_size());
    }
}

/* Non-Static */
class Hello {
    public MyObj an_obj;
    public static void main(String[] args) {
        Hello hello = new Hello(); 
        hello.setObj();
    }           

    public void setObj() {
        this.an_obj.set_size(7);
        say("size is " + this.an_obj.get_size());
    }
}

The primary difference between these two approaches is that in the first, "an_obj" is static--that is to say, there is only one variable for the entire program. If you were to instantiate multiple Hello objects, they would all have the same "an obj" reference. In the second, each Hello object has its own "an obj" reference, each of which can point to a different MyObj instance.

Obviously in this simple situation it doesn't make any difference one way or the other, but generally speaking, static members and methods should be avoided when possible.

Answer 2

Make both the setObj() method and the an_obj variable static, or do something like:

public static void main(String[] args) {
    new Hello().setObj();
}

Answer 3

You never created an instance of MyObj.

There are two logical places to create the necessary object.

1. Hello's initialization.

   public MyObj an_obj= new MyObj();
   public static void main(String[] args)
   { 
       setObj();
   }
   

2. Inside main()

   public MyObj an_obj;
   public static void main(String[] args)
   { 
       an_obj= new MyObj()
       setObj();
   }
   

Either way, you have to actually create an object.

Additionally, you can make setObj static. However, this is rarely what you intend.

The correct thing is for main to (1) create relevant objects, and (2) turn control over to those objects. This is what you should do.

class Hello
{
    public MyObj an_obj= new MyObj();
    public static void main(String[] args)
    { 
        Hello aHelloObject= new Hello();
        aHelloOject.setObj();
    }       

    public void setObj()
    {
        this.an_obj.set_size(7);
        say("size is " + this.an_obj.get_size());
    }    
}

Answer 4

In addition to all previous answers I’d like to mention that only because you don’t understand a concept of a language that doesn’t necessarily constitute a “limitation”.

Answer 5

You can only call an instance method (i.e. a non-static method) when you have an instance of a class.

Answer 6

From a simple perspective, there are two different things in Java:

• objects
• static variables/functions

Objects get created at runtime, when you cause them to be created. Static things (all of them) are always there, and are loaded as needed.

While you can mix and match these in your classes, you have to be careful how you use them. A static thing can call an object, but it must create a version of it first. An object, once created can call any static thing it likes.

We do tend to create classes that are objects AND have a few static bits as well, but you can have all static things in a class if you want, or you can just have all object-based things.

Static stuff is generally frowned upon, because it is essentially global, which opens up more possibilities for weird behavior. Objects with no static bits are best, and are usually thread safe if they are not calling things outside of there own internal data (make 95% of your code simple and safe, then deal with the complicate 5% in some special classes).

Paul.