10.1Introduction

10.3 The Scope of Variables 345

dateCreated.setTime(200000); // Now dateCreated field is changed!

}

}

For a class to be immutable, it must meet the following requirements:

■all data fields private;

■no mutator methods;

■no accessor method that returns a reference to a data field that is mutable.

10.3The Scope of Variables

Chapter 5, “Methods,” discussed local variables and their scope rules. Local variables are declared and used inside a method locally. This section discusses the scope rules of all the variables in the context of a class.

Instance and static variables in a class are referred to as the class’s variables or data fields. A variable defined inside a method is referred to as a local variable. The scope of a class’s variables is the entire class, regardless of where the variables are declared. A class’s variables and methods can appear in any order in the class, as shown in Figure 10.1(a). The exception is when a data field is initialized based on a reference to another data field. In such cases, the other data field must be declared first, as shown in Figure 10.1(b). For consistency, this book declares data fields at the beginning of the class.

FIGURE 10.1 Members of a class can be declared in any order, with one exception.

You can declare a class’s variable only once, but you can declare the same variable name in a method many times in different nonnesting blocks.

If a local variable has the same name as a class’s variable, the local variable takes precedence and the class’s variable with the same name is hidden. For example, in the following program, x is defined as an instance variable and as a local variable in the method.

public class Foo {

private int x = 0; // Instance variable private int y = 0;

public Foo() {

}

public void p() {

int x = 1; // Local variable System.out.println("x = " + x); System.out.println("y = " + y);

}

}

What is the printout for f.p(), where f is an instance of Foo? The printout for f.p() is 1 for x and 0 for y. Here is why:

346Chapter 10 Thinking in Objects

■x is declared as a data field with the initial value of 0 in the class, but is also declared in the method p() with an initial value of 1. The latter x is referenced in the

System.out.println statement.

■y is declared outside the method p(), but is accessible inside it.

Tip

To avoid confusion and mistakes, do not use the names of instance or static variables as local variable names, except for method parameters.

10.4 The this Reference

The this keyword is the name of a reference that refers to a calling object itself. One of its hidden data fields common uses is to reference a class’s hidden data fields. For example, a data-field name is often used as the parameter name in a set method for the data field. In this case, the data field is hidden in the set method. You need to reference the hidden data-field name in the method in order to set a new value to it. A hidden static variable can be accessed simply by using the ClassName.StaticVariable reference. A hidden instance variable can be accessed by

using the keyword this, as shown in Figure 10.2(a).

FIGURE 10.2 The keyword this refers to the calling object that invokes the method.

The this keyword gives us a way to refer to the object that invokes an instance method within the code of the instance method. The line this.i = i means “assign the value of parameter i to the data field i of the calling object.” The keyword this refers to the object that invokes the instance method setI, as shown in Figure 10.2(b). The line Foo.k = k means that the value in parameter k is assigned to the static data field k of the class, which is shared by all the objects of the class.

call another constructor Another common use of the this keyword is to enable a constructor to invoke another constructor of the same class. For example, you can rewrite the Circle class as follows:

public class Circle { private double radius;

public Circle(double radius) { this.radius = radius;

public Circle() { this(1.0);

} this is used to invoke another constructor

public double getArea() {

return this.radius * this.radius * Math.PI; }

}Every instance variable belongs to an instance represented by this, which is normally omitted

10.5 Class Abstraction and Encapsulation 347

The line this(1.0) in the second constructor invokes the first constructor with a double value argument.

Tip

If a class has multiple constructors, it is better to implement them using this(arg-list) as much as possible. In general, a constructor with no or fewer arguments can invoke the constructor with more arguments using this(arg-list). This often simplifies coding and makes the class easier to read and to maintain.

Note

Java requires that the this(arg-list) statement appear first in the constructor before any other statements.

10.5 Class Abstraction and Encapsulation 349

The main method reads interest rate, payment period (in years), and loan amount; creates a Loan object; and then obtains the monthly payment (line 29) and total payment (line 30) using the instance methods in the Loan class.

The Loan class can be implemented as in Listing 10.2.

LISTING 10.2 Loan.java

1 public class Loan {

2 private double annualInterestRate;

3 private int numberOfYears;

4private double loanAmount;

5 private java.util.Date loanDate;

6

7/** Default constructor */

9this(2.5, 1, 1000);

12/** Construct a loan with specified annual interest rate,

13number of years, and loan amount

14*/

16double loanAmount) {

17this.annualInterestRate = annualInterestRate;

18this.numberOfYears = numberOfYears;

19this.loanAmount = loanAmount;

20loanDate = new java.util.Date();

21}

22

23/** Return annualInterestRate */

24public double getAnnualInterestRate() {

25return annualInterestRate;

26}