The Concept of Scope

Although methods generally represent the behaviors of an object, the state of the object is normally represented by attributes. There are three types of attributes:

• Local attributes

• Object attributes

• Class attributes

Local Attributes

Local attributes are local to a specific method. Consider the following code:

public class Number {



    public method1() {

        int count;



    }



    public method2() {



    }



}

The method method1 contains a local variable called count . This integer is accessible only inside method1 . The method method2 has no idea that the integer count exists.

At this point, we can touch on a very important concept: scope. Attributes exist within a particular scope. In this case, the integer count exists within the scope of method1 . In Java, C#, and C++, scope is delineated by curly braces ( {} ). In the Number class, there are several possible scopes ”just start matching the curly braces.

The class itself has its own scope. Each instance of the class (that is, each object) has its own scope. Both method1 and method2 have their own scopes as well. Because count lives within method1 's curly braces, when method1 is invoked, a copy of count is created. When method1 terminates, the copy of count is removed.

For some more fun, look at this code:

public class Number {



    public method1() {

        int count;

    }



    public method2() {

        int count;

    }



}

How can this be? There are two copies of an integer count in this class. Remember that method1 and method2 each has its own scope. Thus, the compiler can tell which copy of count to access simply by recognizing which method it is in. You can think of it in these terms:

method1.count;



method2.count;

As far as the compiler is concerned , the two attributes are easily differentiated, even though they have the same name. It is almost like two people having the same last name , but based on the context of their first names , you know that they are two separate individuals.

Object Attributes

There are many design situations in which an attribute must be shared by several methods within the same object. In Figure 3.6, for example, three objects have been constructed from a single class. Consider the following code:

public class Number {



    int count;    // available to both method1 and method2



    public method1() {

        count = 1;

    }



    public method2() {

        count = 2;

    }



}

In this case, the class attribute count is declared outside the scope of both method1 and method2 . However, it is within the scope of the class. Thus, count is available to both method1 and method2 . (Basically, all methods in the class have access to this attribute.) Notice that the code for both methods is setting count to a specific value. There is only one copy of count for the entire object, so both assignments operate on the same copy in memory. However, this copy of count is not shared between different objects.

To illustrate , let's create three copies of the Number class:

Number number1 = new Number();

Number number2 = new Number();

Number number3 = new Number();

Each of these objects ” number1 , number2 , and number3 ”is constructed separately and is allocated its own resources. There are actually three separate instances of the integer count . When number1 changes its attribute count , this in no way affects the copy of count in object number2 or object number3 . In this case, integer count is an object attribute .

You can play some interesting games with scope. Take a look at the following code:

public class Number {



    int count;



    public method1() {

        int count;

    }



    public method2() {

        int count;

    }



}

In this case, there are actually three separate memory locations of count for each object. The object owns one copy, and method1() and method2() each own a copy of their own.

To access the object variable from within one of the methods, say method1() , you can use the following code:

public method1() {

        int count;



        this.count = 1;

}

Notice that there is some code that looks a bit weird:

this.count = 1;

The selection of the word this as a keyword is perhaps unfortunate. However, we must live with it. The use of the this keyword directs the compiler to access the object variable count , and not the local variables within the method bodies.

The this Keyword

In Java, the keyword this is a reference to the current object.

public class Number {



    static int count;



    public method1() {

    }



}

Count Count1 = new Count();

Count Count2 = new Count();