- Constructors
- Error Handling
- The Concept of Scope
- Operator Overloading
- Multiple Inheritance
- Object Operations
- Conclusion
- References
This chapter is from the book
This chapter is from the book
This chapter is from the book
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 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;
}
}
)
Figure
3.6 Object attributes.
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.
Class Attributes
As mentioned earlier, it is possible for two or more objects to share attributes. In Java, C#, and C++, you do this by making the attribute static:
public class Number {
static int count;
public method1() {
}
}
By declaring count as static, this attribute is allocated a single piece of memory for the class. Thus, all objects of the class use the same memory location for count. Essentially, each class has a single copy, which is shared by all objects of that class (see Figure 3.7).
)
Figure
3.7 Class attributes.
There are many valid uses for class attributes; however, you must be aware of potential synchronization problems. Let's instantiate two Count objects:
Count Count1 = new Count(); Count Count2 = new Count();
For the sake of argument, let's say that the object Count1 is going merrily about its way and is using count as a means to keep track of the pixels on a computer screen. This is not a problem until the object Count2 decides to use attribute count to keep track of sheep. The instant that Count2 records its first sheep, the data that Count1 was saving is lost.