57

I'm learning java and now i've the following problem: I have the main method declared as

public static void main(String[] args) {

..... }

Inside my main method, because it is static I can call ONLY other static method!!! Why ?

For example: I have another class

 public class ReportHandler {       
     private Connection conn;   
     private PreparedStatement prep;
     public void executeBatchInsert() { ....
 } }

So in my main class I declare a private ReportHandler rh = new ReportHandler();

But I can't call any method if they aren't static.

Where does this go wrong?

EDIT: sorry, my question is: how to 'design' the app to allow me to call other class from my 'starting point' (the static void main).

Deepak Rai
  • 2,163
  • 3
  • 21
  • 36
stighy
  • 7,260
  • 25
  • 97
  • 157

10 Answers10

79

You simply need to create an instance of ReportHandler:

ReportHandler rh = new ReportHandler(/* constructor args here */);
rh.executeBatchInsert(); // Having fixed name to follow conventions

The important point of instance methods is that they're meant to be specific to a particular instance of the class... so you'll need to create an instance first. That way the instance will have access to the right connection and prepared statement in your case. Just calling ReportHandler.executeBatchInsert, there isn't enough context.

It's really important that you understand that:

  • Instance methods (and fields etc) relate to a particular instance
  • Static methods and fields relate to the type itself, not a particular instance

Once you understand that fundamental difference, it makes sense that you can't call an instance method without creating an instance... For example, it makes sense to ask, "What is the height of that person?" (for a specific person) but it doesn't make sense to ask, "What is the height of Person?" (without specifying a person).

Assuming you're leaning Java from a book or tutorial, you should read up on more examples of static and non-static methods etc - it's a vital distinction to understand, and you'll have all kinds of problems until you've understood it.

Jon Skeet
  • 1,421,763
  • 867
  • 9,128
  • 9,194
  • I have a basic understanding of the difference between a static (class) method and a non-static (instance) method. What I don't get is how it make sense for a class method to create an instance of its own type. – flies Oct 23 '14 at 00:49
  • @flies: Why would it make any more or less sense than for any other method to create an instance of the type? Indeed, for factory methods (e.g. `Integer.valueOf`) that's the whole *point* of the method. – Jon Skeet Oct 23 '14 at 05:44
  • If `class {...}` defines a class, then how does it make sense for the definition to instantiate the thing being defined? It hasn't been defined yet, right? – flies Oct 24 '14 at 02:34
  • @flies: It doesn't... it's not clear why you think it does... It's the static method (e.g. `Integer.valueOf()` that creates the instance. – Jon Skeet Oct 24 '14 at 05:47
  • the static method is part of the definition of the class, right? so the definition instantiates the thing defined? – flies Nov 11 '14 at 16:54
  • wait. The definition includes instructions to instantiate an object, but those instructions aren't carried out until the definition is compiled and the method is executed. The definition itself does not instantiate anything, it just includes methods that instantiate objects when executed. Is that right? – flies Nov 11 '14 at 16:57
  • @flies: No, calling a method doesn't instantiate an object. Calling a constructor does. You should separate instantiation from method calling in your mind - they really are very distinct operations. – Jon Skeet Nov 11 '14 at 17:30
  • I understand that calling a method per se doesn't instantiate an object. The issue I'm discussing is that there are static methods that include instructions to instantiate an object of their own class, e.g. `class MyClass { public static void main(...) { MyClass mc = new MyClass(); ... } }`. It just looks self-referential to me. – flies Nov 12 '14 at 17:24
  • @flies: Well it's "self-referential" in that it's creating a new instance of the class in which it's declared... but I don't see why that's a problem at all. – Jon Skeet Nov 12 '14 at 17:25
34

Please find answer:

public class Customer {

    public static void main(String[] args) {
        Customer customer=new Customer();
        customer.business();
    }

    public void business(){
        System.out.println("Hi Harry");
    }
}
OneCricketeer
  • 179,855
  • 19
  • 132
  • 245
Ankit
  • 593
  • 4
  • 12
6

Java is a kind of object-oriented programming, not a procedure programming. So every thing in your code should be manipulating an object.

public static void main is only the entry of your program. It does not involve any object behind.

So what is coding with an object? It is simple, you need to create a particular object/instance, call their methods to change their states, or do other specific function within that object.

e.g. just like

private ReportHandler rh = new ReportHandler();
rh.<function declare in your Report Handler class>

So when you declare a static method, it doesn't associate with your object/instance of your object. And it is also violate with your O-O programming.

static method is usually be called when that function is not related to any object behind.

TheOneTeam
  • 25,806
  • 45
  • 116
  • 158
3

You can't call a non-static method from a static method, because the definition of "non-static" means something that is associated with an instance of the class. You don't have an instance of the class in a static context.

Oliver Charlesworth
  • 267,707
  • 33
  • 569
  • 680
1

A static method means that you don't need to invoke the method on an instance. A non-static (instance) method requires that you invoke it on an instance. So think about it: if I have a method changeThisItemToTheColorBlue() and I try to run it from the main method, what instance would it change? It doesn't know. You can run an instance method on an instance, like someItem.changeThisItemToTheColorBlue().

More information at http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods.

wchargin
  • 15,589
  • 12
  • 71
  • 110
0

You cannot call a non-static method from the main without instance creation, whereas you can simply call a static method. The main logic behind this is that, whenever you execute a .class file all the static data gets stored in the RAM and however, JVM(java virtual machine) would be creating context of the mentioned class which contains all the static data of the class. Therefore, it is easy to access the static data from the class without instance creation.The object contains the non-static data Context is created only once, whereas object can be created any number of times. context contains methods, variables etc. Whereas, object contains only data. thus, the an object can access both static and non-static data from the context of the class

user8584649
  • 1
0

Since you want to call a non-static method from main, you just need to create an object of that class consisting non-static method and then you will be able to call the method using objectname.methodname(); But if you write the method as static then you won't need to create object and you will be able to call the method using methodname(); from main. And this will be more efficient as it will take less memory than the object created without static method.

user9885720
  • 131
  • 1
  • 2
  • 11
0

Useful link to understand static keyword https://www.codeguru.com/java/tij/tij0037.shtml#Heading79

Vicky Gupta
  • 576
  • 6
  • 13
0

You can think of a static member function as one that exists without the need for an object to exist. For example, the Integer.parseInt() method from the Integer class is static. When you need to use it, you don't need to create a new Integer object, you simply call it. The same thing for main(). If you need to call a non-static member from it, simply put your main code in a class and then from main create a new object of your newly created class.

zero_dev
  • 613
  • 9
  • 17
0

Let me guess, "ReportHandler" was written like an inner class inside of Main? I faced the same problem, and all the answers here seems to be inattentive. I moved my "ReportHandler" outside, and the error has gone

Varry
  • 1