static variables - belong to the class.

[rama murthy]

If static variables belong to the class and NOT part of the object then how come we are able to invoke it with an object reference variable and also modify its value.

class AQ {
static int t = 6;
}


class Tr {
public static void main(String[] args) {
AQ q = new AQ();
System.out.println(q.t);
q.t = 5;
System.out.println(AQ.t);
new Tr().call();
}

void call() {
System.out.println(new AQ().t);
}
}

Output:

6
5
5

[Keith Lynn]

That is allowed in Java. But be careful.

If you use an object reference to call a static method in a class definition, then it does not matter which object reference you use, even if that reference is null.

Only the type of the reference is considered.

[rama murthy]

That is allowed in Java. But be careful.

Why it is allowed.

Then what's the difference between class variables and instance variables.

[Keith Lynn]

The difference is that no matter what instance of an object you use, you can change the class variables. It doesn't have anything to do with an instance.

However, you can only access an instance variable with a particular instance.

[rama murthy]

Ya you are correct.

I modified the program a little and your explanation helped me to understand the concept.

    
class AQ {
static int t = 6;
int g = 10;
}
 
class Tr {
public static void main(String[] args) {
AQ q = new AQ();
System.out.println(q.t);
System.out.println(q.g);
q.t = 5;
q.g = 123;
System.out.println(AQ.t);
System.out.println(q.g);
new Tr().call();
}
 
void call() {
System.out.println(new AQ().t);
System.out.println(new AQ().g);
}
}
 

Output:

6
10
5
123
5
10


Thanks Keith Lynn.

[Jeroen T Wenting]

it's allowed simply because a class instance knows its type.

[Stan James]

Some IDEs (like Eclipse) will mark this with a warning. I always make static references to the class and clear the warning. It does get a little odd sometimes. For example, I'd probably like to use the same reference twice here instead of the object once and the class once.

myObject.someMethod( MyClass.CONSTANT );

[Jesper de Jong]

Originally posted by rama murthy:

Why it is allowed.

Then what's the difference between class variables and instance variables.

Because the people who invented Java unfortunately decided to allow it. But accessing static member variables through an instance is never necessary and is to be avoided, because it is confusing.

It should not have been possible, but unfortunately it is. I regard this as a mistake in the Java language. The Java language is not perfect you know, it has been invented by human beings...

[Jeroen T Wenting]

I don't think it's a mistake. It makes it possible to access the static member by name from inside an instance of the enclosing class without explicitly mentioning the classname.
That's a good thing IMO, the capability to access the static member outside an instance of the class itself using an instance name is a mere side effect of it and a logical extension.

[Puneet Pathak]

We can access variable declared as static through object refference, but the changes made to the static variable will not be applicable only to the object through which we are accessing the variable but to the other class instances as well.
where as in case of non-static variable the changes would be instance specific.

[Orem Hun]

accessing static member variables through an instance is never necessary and is to be avoided, because it is confusing.

Agree, code is better readable when class variables are referred with class name to differentiate them from instance variables.

[rama murthy]

 
class AQ {
static int t = 6;
int g = 10;
}
 
class Tr {
public static void main(String[] args) {
AQ q = new AQ();
System.out.println(q.t);
q.t = 5;
System.out.println(q.t);
new Tr().call();
}
 
void call() {
System.out.println(new AQ().t);
}
}
 

Output:
 
6
5
5
 
class Ts {
public static void main(String[] args) {
AQ q = new AQ();
System.out.println(q.t);
}
}
 
Output:
 
6    
 

My question is in the call() method of Tr class output for static variable of class AQ is 5 whereas in Ts class output for the same static variable of class AQ is 6.

Why?

[Manhar Puri]

I believe you are running the Tr java program first and the running the Ts program.

Try doing this instead of creating a main method in Ts create some xyz method and then in the main method of Tr class create instance of Ts and call the method xyz.

That should help answer your question.

-Manhar.

[rama murthy]

Hello Manhar Puri

I just did as you said and got results like

    
 
    class AQ {
    static int t = 6;
    int g = 10;
    }
     
    class Tr {
    public static void main(String[] args) {
    AQ q = new AQ();
    System.out.println(q.t);
    q.t = 5;
    System.out.println(q.t);
    new Tr().call();
    }
     
    void call() {
    System.out.println(new AQ().t);
    new Ts().call();
    }
    }
     
    class Ts {
 
    public static void main(String[] args) {
    AQ q = new AQ();
    System.out.println(q.t);
    }
 
    public void call() {
        AQ q = new AQ();
        System.out.println(q.t);
    } 
    }
     
      
    Output:
     
    6
    5
    5
    5 
 

But my question is why am I NOT getting the same result(5) when I try to execute Ts class seperately.


class Ts {

public static void main(String[] args) {
AQ q = new AQ();
System.out.println(q.t);
}

}

Here output is 6

[Ramasubbhu Allur Kuppusamy]

Static Code is accessible through Non-Static Code. But the vice-versa is not possible, mind you.

[Ken Blair]

Originally posted by Ramasubbhu Allur Kuppusamy:
Static Code is accessible through Non-Static Code. But the vice-versa is not possible, mind you.

Yes it is.

static {
   new Blah().doSomething();
}

I know that's not what you had in mind, but it is still accessing non-static code from a static context. The significant difference is that with static methods the reference to the object it is invoked on is implicit.

[Tony Morris]

Originally posted by Jeroen T Wenting:
I don't think it's a mistake. It makes it possible to access the static member by name from inside an instance of the enclosing class without explicitly mentioning the classname.
That's a good thing IMO, the capability to access the static member outside an instance of the class itself using an instance name is a mere side effect of it and a logical extension.

It has been publicly admitted as a mistake, and it is poor practice to reference a static member with an implicit 'this' reference.

Here is some fun:

public final class Nullify
{
    private static String s;
 
    private Nullify()
    {
 
    }
 
    public static void main(String[] args)
    {
        Nullify n = null;
        n.s = "null!";
        System.out.println(n.s);
    }
}

Taken from http://jqa.tmorris.net/GetQAndA.action?qids=39

[Raghav K Aggarwala]

But my question is why am I NOT getting the same result(5) when I try to execute Ts class seperately.


class Ts {

public static void main(String[] args) {
AQ q = new AQ();
System.out.println(q.t);
}

}

Here output is 6
-----------------------------------------


Every time you run a program separately, the original value of static variable t is loaded (in your case 6).

Once you have changed this value using any instance, it will be changed for the rest of the run of that program.

Static variables belong to the class for that specific run of the program.

I hope this will help.

Raghav

[rama murthy]

Thanks Raghav Aggarwal.