Putting an Object in a Safe State

The Concept of Scope

Multiple objects can be instantiated from a single class. Each of these objects has its own identity and state. This is an important point. Each object is constructed separately and is allocated its own memory. However, some attributes and methods may be shared by all the objects instantiated from the same class, thus sharing the memory allocated for these class attributes and methods.

A Shared Method

A constructor is a good example of a method that is shared by all instances of a class.

Although a method generally represents the behavior of an object, the state of the object is normally represented by attributes. There are three types of attributes:

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 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 deleted.

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 6, for example, three objects have been constructed from a single class. Consider the following code:

In this case, the 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 object, Number1, Number2, and Number3, is constructed separately and is allocated its own resources. There are actually three separate instances of the integer a. 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:

In this case there are actually three copies of count. The object has one copy, and method1() and method2() each have 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.