Accessing Static variables

Question

public class Bicycle {

    private int cadence;
    private int gear;
    private int speed;
    private int id;
    private static int numberOfBicycles = 0;

    public Bicycle(int startCadence, int startSpeed, int startGear){
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;

        id = ++numberOfBicycles;
    }
       // ...
}

I learned in my class that Static variables should be accessed by calling with class name. i.e. ClassName.VariableName

But in the code above, how is this statement id = ++numberOfBicycles; compiled without errors, even though the variable numberOfBicycles is static

From outside the class, "static variables should be accessed by calling with class name." From the inside, the class qualification is inferred by the compiler. — Dek Dekku, Jun 02 '13 at 06:19
Note that this line `id = ++numberOfBicycles;` is not thread safe — Steve Kuo, Jun 02 '13 at 16:41

score 22 · Accepted Answer · edited Nov 12 '16 at 21:35

Static variables are owned by class rather than by its individual instances (objects). Referring static variables outside the class is by ClassName.myStaticVariable but inside the class it is similar to other instance variables.

You can always use static variables in non-static methods but you cannot use non-static variables in static methods reason being when static methods are loaded other non-static instance variables are not created.

So your statement id = ++numberOfBicycles; is perfectly valid and will compile without errors.

Zim-Zam O'Pootertoot · Answer 2 · 2013-06-02T06:25:51.050

7

From within the class the Bicycle qualifier is optional on static variables, just like the this qualifier is optional on instance variables

edited Jun 02 '13 at 06:25

answered Jun 02 '13 at 06:19

Zim-Zam O'Pootertoot

17,888
4
41
69

But what's the Fully Qualified way of resolving this? It's like you _can_ omit `this.` but it's frowned upon. What's the actual way of referring to yourself in Java. In PHP you'd use `static::` or `self::`. – Elven Spellmaker Jul 26 '21 at 23:05

pinkpanther · Answer 3 · 2013-06-02T06:26:49.320

May be what your lecturer said is regarding accessing them from outside the class not from inside the class. static variables can be accessed outside the class like this ClassName.VariableName or object.VariableName. But however the first method is preferrable.

From inside the class it's not needed you may use this keyword or classname-qualifier to disambiguate with the local variables with the same name inside methods and constructors.

score 5 · Answer 4 · answered Jun 02 '13 at 06:21

Static variables are the shared variables. So you can access them using either the Classname.staticVariable or using an object of the class instance.staticVariable. In any case you will be referring to the single copy of the variable in memory, no matter how many objects you create.

score 2 · Answer 5 · answered Jun 02 '13 at 07:09

 public int getID(){
    return numberOfBicycles;
}

public static int getNOB(){
    return numberOfBicycles;
}

In the Bicycle class

    Bicycle bc = new Bicycle(30, 90, 1);
    System.out.println(Bicycle.getNOB());
    System.out.println(bc.getID());

    Bicycle bc2 = new Bicycle(30,90, 1);
    System.out.println(Bicycle.getNOB());
    System.out.println(bc2.getID());

    Bicycle bc3 = new Bicycle(30,90, 1);
    System.out.println(Bicycle.getNOB());
    System.out.println(bc3.getID());

    Bicycle bc4 = new Bicycle(30,90, 1);
    System.out.println(Bicycle.getNOB());
    System.out.println(bc4.getID());

In the main class of BicycleTest worked just fine for me

you don't need to make two answers.....you can just edit your first answer to include this code — pinkpanther, Jun 02 '13 at 07:20
yeah next time will do that...as long as you read it and understood. — Manny265, Jun 02 '13 at 17:22

score 1 · Answer 6 · answered Jun 02 '13 at 06:47

Given your class ..

public class Bicycle
{
    private int cadence;
    private int gear;
    private int speed;
    private int id;
    private static int numberOfBicycles = 0;

    // ..
}

When I create an objects of type Bicycle, it will be like this:

Bicycle a = new Bicycle (1,2,3);

Bicycle b = new Bicycle (2,3,4);

In memory, it's like this:

[a] --> { id:1, cadence:1, gear:2, speed:3 }

[b] --> { id:2, cadence:2, gear:3, speed:4 }

numberOfBicycles is static, so it's not part of any Bicycle object, it's related to the class not an object, and so it will be like this in memory:

[Bicycle] --> { numberOfBicycles:2 }

And so to access the static member, first we define a static getter for it:

public static int getNumberOfBicycles ()
{
    return numberOfBicycles;
}

then we call it from the class:

System.out.println(Bicycle.getNumberOfBicycles());

score 1 · Answer 7 · answered Jun 02 '13 at 07:05

Non static methods can access static members of a class because only a single copy of the static variable exists unlike instance variables which are only created once a new object of that type has been created.
I recommend you have another class to test,like BicycleTest which will have the main class and then create maybe 4Bicycle objects and using 2getters in the Bicycle class retrieve the numberofBicycles and ID everytime you create an object maybe that will give you a picture of what is happening.

score 1 · Answer 8 · answered Jul 09 '19 at 08:54

1

you didn’t write Bicycle.numberOfBicycles. It isn’t necessary because we are already in that class so the compiler can infer it.

answered Jul 09 '19 at 08:54

bassam

11
1

Accessing Static variables

8 Answers8

Linked