Accessing Static Members

[Joe Lemmer]

Hi there,

I've always been a bit confused by when you can and can't access static methods.

Can I just confirm that this is correct:

You can access a static method or a static variable from a non-static method, but you can't access a non-static method or an instance variable from a static method. (Assuming all the relevant members are in scope)

Cheers

Joe

[Wouter Oet]

Why don't you try it? Just write some code and you'll find the correct answers.

[Joe Lemmer]

I have done and that's the conclusion I came to, but I just wanted to confirm and maybe get some other opinions / info from some Ranchers.

[Prasad Kharkar]

well
we cannot access the instance members directly from the static methods but we can access the static members from the non static methods
reason is

Static members are connected to class and not a particular instance so they can be accessed by any object

now let us see the following program

  class Sample {
    static int j;// static member
    int i; // instance member
    public static void main(String[] args){
        System.out.println(j);
        //method();
        //System.out.println(i);
        // above statements give error because we are accessing 
        // instance member from static method but this is not possble
        //because static methods are connected to class and have no 
        // relation with objects 

        // but when we create object and then access instance member
        // then it is valid

        Sample s = new Sample();
        s.method();
        System.out.println(s.i);
    }

    public void method(){
        System.out.println(j); // static can be called directly
        System.out.println(i); // instance member can acces other
        // instance members directly 
    }
}
  

hopes this makes sense

[Florin Florentin]

Joe it is correct what you think.

[Joe Lemmer]

Hi Prasad,

Yes that makes perfect sense. Thanks very much for the commented example. I was a bit thrown by a Whizlabs question which was something like the following:

class StaticExample {

    static void get1() {
        System.out.println("get1");
    }

    void get2() {
        System.out.println("get2");
    }

    void get() {
        get1(); // calls static method
        get2(); // calls non-static method
    }

    public static void main(String[] args) {
        StaticExample ex = new StaticExample();
        ex.get();
    }
}    

I had thought that this would fail at compile time because a non-static method (get) was accessing a static method (get1), but I can see now that it will compile fine because there will always only be one get1() method for a class (unless it's overloaded) so thee's no confusion as to which method will be accessed as there would be for non-static methods.

Cheers

Joe