July 5, 2020
Hot Topics:

Putting an Object in a Safe State

  • By Matt Weisfeld
  • Send Email »
  • More Articles »

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:

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

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:


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:

public class Number {   int count;   public method1() {      count = 1;   }   public method2() {      count = 2;   }}

Click here for a larger image.

Figure 6: Object attributes.

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:

public class Number {   int count;   public method1() {      int count;   }   public method2() {      int count;   }}

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.

The this Keyword

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

Page 4 of 6

This article was originally published on January 26, 2005

Enterprise Development Update

Don't miss an article. Subscribe to our newsletter below.

Thanks for your registration, follow us on our social networks to keep up-to-date