Programming Tutorials

Instance variable in java

By: aathishankaran in Java Tutorials on 2007-03-05  

As you know, it is illegal in java to declare two local variables with the same name inside the same or enclosing scopes. Interestingly, you can have local variables, including formal parameters to methods, which overlap with the names of the class instance variables. We can see the following example for this explanation.

class Sum {

    double item1;
    double item2;
    double item3;
    Sum ( double i1, double i2, doublei3) {
        item1 = i1;
        item2 = i2;
        item3 = i3;
    }

    double add() {
        return item1 + item2 + item3;
    }
}

class Sumcalc {

    public static void main(string args[]) {
        Sum sum1 = new Sum(10, 20, 15);
        double value;
        value = sum1.add();
        System.out.println("Value is" + value);
    }
}

However, when a local variable has the same name as an instance variable, the local variable hides the instance variable. This is why item1, item2, and item3 were not used as the names for the parameters to the Sum() constructor inside the Sum class. If they had been, then item1 would have referred to the formal parameter, hiding the instance variable item1.

While it is usually easier to simply use different names, there is another way around this situation. Because this lets you refer directly to the object, you can use it to resolve any name space collisions that might occur between instance variables and local variables.

For example, here is another coding of Sum(), which uses item1, item2, and item3 for parameter names and then uses this to access the instance variables by the same name:

Sum(double item1, double item2, double item3) {
   this.item1 = item1;
   this.item2 = item2;
   this.item3 = item3;
}

word of caution: The use of this in such a context can sometimes be confusing and some programmers are careful not to use local variables and formal parameter names that hide instance variables. Of course, other programmers believe the contrary that it is a good convention to use the same names for clarity, and use this to overcome the instance variable hiding. It is a matter of taste which approach you adopt.

Although this is of no significant value in the examples just shown, it is very useful in certain situations.