referenc static variables with this in methods

[jason stark]

I'm preparing for the Sun Certified java exam. I've tried refencing a static variable from within a method using "this" and it worked. I didn't expect it to as the variables not attached to an object. Also I've managed to compile transient variables with the prefixed by the word static which I read was not possible.
Also some times I've seen this as legal:-
public static int main(String[] args)
will this be legal for the exam
thanks for any help Jason

[Svend Rost]

hi Jason
Conserning the 2nd question about
public static int main(String[] args) {}:
First of all.. in the exam you have to use what the JLS says - not what the compiler states. And acording to the JLS the "main method" (the one that's called with "java ClassName") has to be:
public static void main(String[] args)
(as a side note, it can also be final)
btw.
It's perfectly okay to make a class with the above public static int main(String[] args) signature.
Eg.

public class Class1
{
 public static int main(String[] args)
 {
  return 5;
 }
}

will compile with no errors - but if you try to execute the file you'll get a java.lang.NoSuchMethodError: main
Exception (cause it doesn't have a main method with the correct signature).
/Svend Rost

[david eberhardt]

I agree with Svend, also
If you put both methods in a file,
public static void main (String [] args) {}
public static int main (String [] args) {}
you'll get a compiler error:

public class Jason {
public static void main(String [] args) {
System.out.println("this is public static void main () method");
}
public static int main(String [] args) {
System.out.println(args[0]);
}
}
/* output
C:\BIN>javac Jason.java
Jason.java:11: main(java.lang.String[]) is already defined in Jason
        public static int main(String [] args) {
                          ^
1 error
*/

You cannot overload a method by changing the return type ONLY.

[Valentin Crettaz]

Regarding your first question, nothing prevents you from referencing a static variable with "this", that is, prefixing the variable id with this. The type of the object referenced by "this" (i.e. an object of the class in which "this" is used or any subclass) will be used to resolve the static variable. Nothing is wrong about it, although the practice is not that good. You should always reference a static variable with the type the variable is declared in.

[Alfred Kemety]

To add, what's not allowed is to try to use the this keyword in a static method since static methods are not passed the this object reference... right??
[ December 02, 2002: Message edited by: Alfred Kemety ]

[david eberhardt]

 class Dog6 extends Object {
public static int i2 = 5;
public int i3 = 7;
public static void main(String [] args) {
Dog6 david = new Dog6();
Dog6 terri = new Dog6();
System.out.println("david.toString() is " + david.toString());
System.out.println("terri.toString() is " + terri.toString());
terri.i3 = 9;
System.out.println("static int i2 = " + i2);
System.out.println("david.i3 = " + david.i3);
System.out.println("terri.i3 = " + terri.i3);
 // System.out.println(i3);
/* Dog6.java:11: non-static variable i3 cannot be referenced
from a static context System.out.println(i3);*/
        //  use this reference to access NON-static variable of this class
//  System.out.println(this.i3);
/* Dog6.java:19: non-static variable this cannot be referenced
from a static context System.out.println(this.i3);*/
        //  use this reference to access STATIC variable of this class
//  System.out.println(this.i2);
/* Dog6.java:19: non-static variable this cannot be referenced
from a static context System.out.println(this.i3);*/
    //  now call an instance method
        david.instanceMethod1();
        terri.instanceMethod1();
}
public void instanceMethod1() {
System.out.println("\n\nentering the instanceMethod1() method");
String whoIs = this.toString();
System.out.println("whoIs the caller ? " + whoIs);
System.out.println("static int i2 = " + i2);
System.out.println("Dog6.i2 = " + Dog6.i2);
//System.out.println(david.i2);
System.out.println("this.i2 = " + this.i2);
System.out.println("i3 = " + i3);
//System.out.println(Dog6.i3);
//System.out.println(david.i3);
//System.out.println(terri.i3);
System.out.println("this.i3 = " + this.i3);
System.out.println("exiting the instanceMethod1() method");
}
}
/* output is
C:\BIN>javac Dog6.java
C:\BIN>java Dog6
david.toString() is Dog6@601bb1
terri.toString() is Dog6@1ba34f2
static int i2 = 5
david.i3 = 7
terri.i3 = 9

entering the instanceMethod1() method
whoIs the caller ? Dog6@601bb1
static int i2 = 5
Dog6.i2 = 5
this.i2 = 5
i3 = 7
this.i3 = 7
exiting the instanceMethod1() method

entering the instanceMethod1() method
whoIs the caller ? Dog6@1ba34f2
static int i2 = 5
Dog6.i2 = 5
this.i2 = 5
i3 = 9
this.i3 = 9
exiting the instanceMethod1() method
C:\BIN>
*/ 

[Code reformatted by Val]
[ December 03, 2002: Message edited by: Valentin Crettaz ]

[david eberhardt]

within an instance method, called with david.instanceMethod1() for instance,
I can access other objects of the same class, say the terri instance by the following:

in the static main method:
//  now call an instance method
  david.instanceMethod1(terri);
  terri.instanceMethod1(david);
}
public void instanceMethod1(Dog6 other) {
   System.out.println("\n\nentering the instanceMethod1() method");
   String whoIs = this.toString();
   System.out.println("whoIs the caller ? " + whoIs);
   String whoWith = other.toString();
   System.out.println("whoWith the caller ? " + whoWith);
  

[Jose Botella]

The type of the object referenced by "this" (i.e. an object of the class in which "this" is used or any subclass) will be used to resolve the static variable.

A minor slip: variables are not resolved at runtime, the compile type of the variable used in the access expression is searched for declared or inherited fields, but not the type of the object pointed to by the variable.
This means this code prints 0 because the compile type of "this" is Test:

class Test {
static int field = 0;
int i = 0;
public void method(){
System.out.println(this.field + this.i);
}
}
public class Son extends Test
{static int field = 1;
int i = 1;
public static void main(String[] args)
{new Son().method();
}
}

[david eberhardt]

Originally posted by Jose Botella:

This means this code prints 0 because the compile type of "this" is Test:

class Test {
static int field = 0;
int i = 0;
public void method(){
System.out.println(this.field + this.i);
}
}
public class Son extends Test
{static int field = 1;
int i = 1;
public static void main(String[] args)
{new Son().method();
}
}

Jose:
Wow - if this had been a test question, I would have got it wrong!
I think what threw me off is that I am not used to seeing the same variables that are declared in the superclass, redeclared in the subclass as is in the case above.
So I am not sure what behaviour this would cause.
Anyways, since I plan on inheriting things in the subclass, I rewrote the code to the following:

 class Test {
static int field = 0;
int i = 0;
public void method() {
System.out.println(field);
System.out.println(i);
}
}
public class Son extends Test{
//static int field = 1;
//int i = 1;
public static void main(String[] args){
Son s = new Son();
s.field = 3;
s.i = 3;

                s.method();
}
}
/* output is
C:\BIN>javac Son.java
C:\BIN>java Son
3
3
C:\BIN>
*/ 

Your code and information was a real eye opener though!

[jason stark]

Originally posted by david eberhardt:

class Test {
static int field = 0;
int i = 0;
public void method(){
System.out.println(this.field + this.i);
}
}
public class Son extends Test
{static int field = 1;
int i = 1;
public static void main(String[] args)
{new Son().method();
}
}

<hr></blockquote>
Jose:
Wow - if this had been a test question, I would have got it wrong!
I think what threw me off is that I am not used to seeing the same variables that are declared in the superclass, redeclared in the subclass as is in the case above.
So I am not sure what behaviour this would cause.
Anyways, since I plan on inheriting things in the subclass, I rewrote the code to the following:

 class Test {
static int field = 0;
int i = 0;
public void method() {
System.out.println(field);
System.out.println(i);
}
}
public class Son extends Test{
//static int field = 1;
//int i = 1;
public static void main(String[] args){
Son s = new Son();
s.field = 3;
s.i = 3;

                s.method();
}
}
/* output is
C:\BIN>javac Son.java
C:\BIN>java Son
3
3
C:\BIN>
*/ 

Your code and information was a real eye opener though![/QB]

Hi I tried this bit of code and removed the this bit removed and it made no diffence to what was printed.
Thanks to everyone who replied Jason