Question

By convention, a static method specifically in Java can have access only to static fields or other static methods. The following simple code snippet however appears to violate the convention. Let’s consider the following simple code snippet in Java.

class Super
{
    protected static int x;
    protected static int y;

    public Super(int x, int y)
    {
        Super.x=x;
        Super.y=y;
    }

    public static int sum()
    {
        return(x+y);
    }
}

final class Sub extends Super
{
    public static int temp=100;
    public Sub(int x, int y)
    {
        super(x, y);
    }

    public void concreateMethod()
    {
        System.out.println("\nInstance variable x = "+x);
        System.out.println("Instance variable y = "+y);
    }
}

final public class Main
{
    public static void main(String[] args)
    {
        Sub s=new Sub(10, 5);
        System.out.println("\nAssociating with object x = "+s.x);
        System.out.println("Associating with object   y = "+s.y);

        System.out.println("\nAssociating with class name x = "+Sub.x);
        System.out.println("Associating with class name   y = "+Sub.y);

        System.out.println("\nSummation (Associating with object)   = "+s.sum());
        System.out.println("Summation (Associating with class name) = "+Sub.sum());

        System.out.println("\nAssociating with class name temp = "+Sub.temp);
        System.out.println("Associating with object temp =    = "+s.temp);

        System.out.println("\nConcreate method called.");
        s.concreateMethod();
    }
}

---

The above code produces the following output with the respective statements.

Associating with object x = 10
Associating with object y = 5

---

Associating with class name x = 10
Associating with class name y = 5

---

Summation (Associating with object) = 15
Summation (Associating with class name) = 15

---

Associating with class name temp = 100
Associating with object temp = = 100

---

Concreate method called.
Instance variable x = 10
Instance variable y = 5

---

The static fields s and x are being accessed through the following statements within the main() method using the object of the Sub class, though they are declared as static in the super class Super.

Sub s=new Sub(10, 5); 
System.out.println("\nAssociating with object x = "+s.x);
System.out.println("Associating with object   y = "+s.y);

---

The following statements of course, have no doubt.

System.out.println("\nAssociating with class name x = "+Sub.x);
System.out.println("Associating with class name   y = "+Sub.y);

Since x and y are static, they can certainly be accessed in this way.

---

The same is the method call, observe the following statements.

Sub s=new Sub(10, 5);
System.out.println("\nSummation (Associating with object)   = "+s.sum());
System.out.println("Summation (Associating with class name) = "+Sub.sum());

Both of the ways, the static method sum() is being accessed using the object of the class Super and also using the class name Sub.

---

Again the similar case with the static field temp declared within the Sub class

System.out.println("\nAssociating with class name temp = "+Sub.temp);
System.out.println("Associating with object temp =    = "+s.temp);

The static field temp is being accessed in both the ways.

---

Why is this happening here?

Answer 1

Basically it’s a flaw in the design of Java IMO which allows static members (methods and fields) to be referenced as if they were instance members. This can be very confusing in code like this:

Thread newThread = new Thread(runnable);
newThread.start();
newThread.sleep(1000);

That looks like it’s sending the new thread to sleep, but it actually compiles down into code like this:

Thread newThread = new Thread(runnable);
newThread.start();
Thread.sleep(1000);

because sleep is a static method which only ever makes the current thread sleep.

Indeed, the variable isn’t even checked for non-nullity (any more; it used to be, I believe):

Thread t = null;
t.sleep(1000);

Some IDEs can be configured to issue a warning or error for code like this – you shouldn’t do it, as it hurts readability. (This is one of the flaws which was corrected by C#…)