Methods: Communicating with Objects
We communicate with objects using methods. Methods are executable code within each object, for which an interface has been established. Sometimes the interface is only for the object itself. Other times it is an interface accessible by other objects. This chapter discusses that topic in detail.
3.2 Passing Information to an Object
The Scope of Parameters, Variables, and Methods
The bodies of the mutator methods in the previous section make use of
both instance variables and parameters. It is important to note that there
is a difference in where these two types of variables can be used. The scope of a variable or method refers to where it can be used in a program.
A parameter’s scope is limited to the body of the method in which it is
declared. Variables that are declared in the body of a method have scope
which extends from the point where they are declared to the end of the
block of code in which they are declared. Parameters are local variables
which are declared in the parameter list of a method’s header and which
have initial values specified by the arguments in a method call. The scope
of a parameter is the same as the scope of a variable declared at the very
Local scope beginning of the body of a method. Once the flow of execution leaves a
method, its parameters and other local variables cease to exist. The scope
of local variables is referred to as local scope.
By contrast, instance variables, class variables, and all methods have
scope that extends throughout the entire class, that is, class scope. They
can be used in the body of any method and in the expressions that assign initial values to class level variables. There are two restrictions to
remember. First, instance variables and instance methods cannot be used
in the body of a class method, one modified with static, unless an instance of the class is created there and then the dot notation of qualified
Class scope names must be used to refer to the variable or method. This is because
class methods are called without reference to a particular instance of the
class. The main() method of the OneRowNim class that we defined in the
previous chapter is an example of such a class method. In that case, to test the instance methods of OneRowNim we first created an instance of
OneRowNim and used it to call its instance methods:
The second restriction involved in class scope is that one class level variable can be used in the expression that initializes a second class level variable only if the first is declared before the second. There is no similar
restriction on methods.
Except for the restrictions noted above, methods and class level variables can be referred to within the same class by their simple names,
with just the method (or variable) name itself, rather than by their qualified names, with the dot operator. Thus, in OneRowNim, we can refer to
nSticks and report() in the bodies of other instance methods. In a
class method, such as main(), we would have to create an instance of
OneRowNim with a name like game and refer to game.report().