CODEWITHSUNDEEP
javainheritancestatic
Bhavesh
Bhavesh

Reputation: 4677

Static methods and static fields in Java behave somewhat in a strange way

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?

Upvotes: 2

Views: 2932

Answers (5)

Jon Skeet
Jon Skeet

Reputation: 1500495

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#...)

Upvotes: 8

Michael Borgwardt
Michael Borgwardt

Reputation: 346290

Where do you see a non-static field or method being accessed by static code? Everything seems perfectly fine to me.

Perhaps what's confusing you is that static fields and methods can be accessed through instances as well as through the class name? It's certainly a big ugly and many consider it bad design, but that's all.

Upvotes: 2

LeleDumbo
LeleDumbo

Reputation: 9340

a static method specifically in Java can have access only to static fields or other static methods declared within the same class

Or its superclass.

I don't see any violation here, you can access static fields/methods via its concrete object or class name. both refer to the same thing.

Upvotes: 2

lukastymo
lukastymo

Reputation: 26809

The Sub.temp and s.temp are equivalent and you can use both, it means the same. But 1st is better one because suggests it's a static field.

Upvotes: 3

Mat
Mat

Reputation: 206689

There is no problem there. Static methods can only access static fields and call other static methods as you have stated. Nothing in your examples does otherwise.

Non-static methods can access both static and non-static methods and fields. Again, none of your examples violate that.

Upvotes: 5

Related Questions