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.3 The 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.

public class Circle { public class Foo {

public double findArea() { private int i;
return radius * radius * Math.PI; private int j = i + 1;
} }
private double radius = 1;
}

(a) variable radius and method findArea() can be (b) i has to be declared before j because j’s initial
declared in any order value is dependent on i.

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 prece-
dence 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:
346 Chapter 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).

public class Foo { Suppose that f1 and f2 are two objects of Foo.
int i = 5;
static double k = 0; Invoking f1.setI(10) is to execute
this.i = 10, where this refers f1
void setI(int i) {
this.i = i ; Invoking f2.setI(45) is to execute
} this.i = 45, where this refers f2

static void setK(double k) {

Foo.k = k;
}
}

(a) (b)

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;
} this must be explicitly used to reference the data
field radius of the object being constructed
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 construc-
tor 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

In Chapter 5, “Methods,” you learned about method abstraction and used it in program devel-
opment. Java provides many levels of abstraction. Class abstraction is the separation of class class abstraction
implementation from the use of a class. The creator of a class describes it and lets the user
know how it can be used. The collection of methods and fields that are accessible from outside
the class, together with the description of how these members are expected to behave, serves as
the class’s contract. As shown in Figure 10.3, the user of the class does not need to know how
the class is implemented. The details of implementation are encapsulated and hidden from the
user. This is known as class encapsulation. For example, you can create a Circle object and class encapsulation
find the area of the circle without knowing how the area is computed.
Class implementation Class Contract
is like a black box Clients use the
(signatures of
hidden from the clients Class class through the
public methods and
contract of the class
public constants)

FIGURE 10.3 Class abstraction separates class implementation from the use of the class.
Class abstraction and encapsulation are two sides of the same coin. Many real-life exam-
ples illustrate the concept of class abstraction. Consider, for instance, building a computer
system. Your personal computer has many components—a CPU, memory, disk, motherboard,
fan, and so on. Each component can be viewed as an object that has properties and methods.
To get the components to work together, you need know only how each component is used
and how it interacts with the others. You don’t need to know how the components work inter-
nally. The internal implementation is encapsulated and hidden from you. You can build a
computer without knowing how a component is implemented.
The computer-system analogy precisely mirrors the object-oriented approach. Each com-
ponent can be viewed as an object of the class for the component. For example, you might
have a class that models all kinds of fans for use in a computer, with properties such as fan
size and speed and methods such as start and stop. A specific fan is an instance of this class
with specific property values.
As another example, consider getting a loan. A specific loan can be viewed as an object of
a Loan class. Interest rate, loan amount, and loan period are its data properties, and comput-
ing monthly payment and total payment are its methods. When you buy a car, a loan object is
created by instantiating the class with your loan interest rate, loan amount, and loan period.
You can then use the methods to find the monthly payment and total payment of your loan. As
a user of the Loan class, you don’t need to know how these methods are implemented.
Listing 2.8, ComputeLoan.java, presented a program for computing loan payments. The
program cannot be reused in other programs. One way to fix this problem is to define static
methods for computing monthly payment and total payment. However, this solution has limi- Video Note
tations. Suppose you wish to associate a date with the loan. The ideal way is to create an The Loan class
348 Chapter 10 Thinking in Objects

Loan

-annualInterestRate: double The annual interest rate of the loan (default: 2.5).
-numberOfYears: int The number of years for the loan (default: 1).
-loanAmount: double The loan amount (default: 1000).
-loanDate: java.util.Date The date this loan was created.

+Loan() Constructs a default Loan object.

+Loan(annualInterestRate: double, Constructs a loan with specified interest rate, years,
numberOfYears: int,loanAmount: and loan amount.
double)
+getAnnualInterestRate(): double Returns the annual interest rate of this loan.
+getNumberOfYears(): int Returns the number of the years of this loan.
+getLoanAmount(): double Returns the amount of this loan.
+getLoanDate(): java.util.Date Returns the date of the creation of this loan.
+setAnnualInterestRate( Sets a new annual interest rate to this loan.
annualInterestRate: double): void
+setNumberOfYears( Sets a new number of years to this loan.
numberOfYears: int): void
+setLoanAmount( Sets a new amount for this loan.
loanAmount: double): void
+getMonthlyPayment(): double Returns the monthly payment of this loan.
+getTotalPayment(): double Returns the total payment of this loan.

FIGURE 10.4 The Loan class models the properties and behaviors of loans.

object that ties the properties for loan information and date together. Figure 10.4 shows the
UML class diagram for the Loan class.
The UML diagram in Figure 10.4 serves as the contract for the Loan class. Throughout
this book, you will play the roles of both class user and class developer. The user can use the
class without knowing how the class is implemented. Assume that the Loan class is available.
We begin by writing a test program that uses the Loan class (Listing 10.1).

LISTING 10.1 TestLoanClass.java

1 import java.util.Scanner;
2
3 public class TestLoanClass {
4 /** Main method */
5 public static void main(String[] args) {
6 // Create a Scanner
7 Scanner input = new Scanner(System.in);
8
9 // Enter yearly interest rate
10 System.out.print(
11 "Enter yearly interest rate, for example, 8.25: ");
12 double annualInterestRate = input.nextDouble();
13
14 // Enter number of years
15 System.out.print("Enter number of years as an integer: ");
16 int numberOfYears = input.nextInt();
17
18 // Enter loan amount
19 System.out.print("Enter loan amount, for example, 120000.95: ");
 10.5 Class Abstraction and Encapsulation 349
20 double loanAmount = input.nextDouble();
21
22 // Create a Loan object
23 Loan loan =
24 new Loan(annualInterestRate, numberOfYears, loanAmount) ; create Loan object
25
26 // Display loan date, monthly payment, and total payment
27 System.out.printf("The loan was created on %s\n" +
28 "The monthly payment is %.2f\nThe total payment is %.2f\n",
29 loan.getLoanDate().toString(), loan.getMonthlyPayment(), invoke instance method
30 loan.getTotalPayment()); invoke instance method
31 }
32 }

Enter yearly interest rate, for example, 8.25: 2.5

Enter number of years as an integer: 5
Enter loan amount, for example, 120000.95: 1000
The loan was created on Sat Jun 10 21:12:50 EDT 2006
The monthly payment is 17.74
The total payment is 1064.84

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;
4 private double loanAmount;
5 private java.util.Date loanDate;
6
7 /** Default constructor */
8 public Loan() { no-arg constructor
9 this(2.5, 1, 1000);
10 }
11
12 /** Construct a loan with specified annual interest rate,
13 number of years, and loan amount
14 */
15 public Loan(double annualInterestRate, int numberOfYears, constructor
16 double loanAmount) {
17 this.annualInterestRate = annualInterestRate;
18 this.numberOfYears = numberOfYears;
19 this.loanAmount = loanAmount;
20 loanDate = new java.util.Date();
21 }
22
23 /** Return annualInterestRate */
24 public double getAnnualInterestRate() {
25 return annualInterestRate;
26 }
350 Chapter 10 Thinking in Objects
27
28 /** Set a new annualInterestRate */
29 public void setAnnualInterestRate(double annualInterestRate) {
30 this.annualInterestRate = annualInterestRate;
31 }
32
33 /** Return numberOfYears */
34 public int getNumberOfYears() {
35 return numberOfYears;
36 }
37
38 /** Set a new numberOfYears */
39 public void setNumberOfYears(int numberOfYears) {
40 this.numberOfYears = numberOfYears;
41 }
42
43 /** Return loanAmount */
44 public double getLoanAmount() {
45 return loanAmount;
46 }
47
48 /** Set a newloanAmount */
49 public void setLoanAmount(double loanAmount) {
50 this.loanAmount = loanAmount;
51 }
52
53 /** Find monthly payment */
54 public double getMonthlyPayment() {
55 double monthlyInterestRate = annualInterestRate / 1200;
56 double monthlyPayment = loanAmount * monthlyInterestRate / (1 -
57 (Math.pow(1 / (1 + monthlyInterestRate), numberOfYears * 12)));
58 return monthlyPayment;
59 }
60
61 /** Find total payment */
62 public double getTotalPayment() {
63 double totalPayment = getMonthlyPayment() * numberOfYears * 12;
64 return totalPayment;
65 }
66
67 /** Return loan date */
68 public java.util.Date getLoanDate() {
69 return loanDate;
70 }
71 }

From a class developer’s perspective, a class is designed for use by many different customers.
In order to be useful in a wide range of applications, a class should provide a variety of ways
for customization through constructors, properties, and methods.
The Loan class contains two constructors, four get methods, three set methods, and the
methods for finding monthly payment and total payment. You can construct a Loan object by
using the no-arg constructor or the one with three parameters: annual interest rate, number of
years, and loan amount. When a loan object is created, its date is stored in the loanDate field.
The getLoanDate method returns the date. The three get methods, getAnnualInterest,
getNumberOfYears, and getLoanAmount, return annual interest rate, payment years, and
loan amount, respectively. All the data properties and methods in this class are tied to a specific
instance of the Loan class. Therefore, they are instance variables or methods.
 10.6 Object-Oriented Thinking 351

Important Pedagogical Tip

The UML diagram for the Loan class is shown in Figure 10.4. Students should begin by writing a
test program that uses the Loan class even though they don’t know how the Loan class is imple-
mented. This has three benefits:
■ It demonstrates that developing a class and using a class are two separate tasks.
■ It enables you to skip the complex implementation of certain classes without interrupting
the sequence of the book.
■ It is easier to learn how to implement a class if you are familiar with the class through using it.
For all the examples from now on, you may first create an object from the class and try to use its
methods and then turn your attention to its implementation.

10.6 Object-Oriented Thinking

Chapters 1–7 introduced fundamental programming techniques for problem solving using
loops, methods, and arrays. The study of these techniques lays a solid foundation for object-
oriented programming. Classes provide more flexibility and modularity for building reusable
software. This section improves the solution for a problem introduced in Chapter 3 using the
object-oriented approach. From the improvements, you will gain insight on the differences
between procedural and object-oriented programming and see the benefits of developing
reusable code using objects and classes.
Listing 3.5, ComputeBMI.java, presented a program for computing body mass index. The
code cannot be reused in other programs. To make it reusable, define a static method to com-
pute body mass index as follows:
public static double getBMI(double weight, double height)

This method is useful for computing body mass index for a specified weight and height. How-
ever, it has limitations. Suppose you need to associate the weight and height with a person’s
name and birth date. You may declare separate variables to store these values. But these val-
ues are not tightly coupled. The ideal way to couple them is to create an object that contains
them. Since these values are tied to individual objects, they should be stored in instance data Video Note
fields. You can define a class named BMI, as shown in Figure 10.5. The BMI class

The get methods for these data fields

are provided in the class, but omitted in the
UML diagram for brevity.
BMI

-name: String The name of the person.

-age: int The age of the person.
-weight: double The weight of the person in pounds.
-height: double The height of the person in inches.

+BMI(name: String, age: int, weight: Creates a BMI object with the specified
double, height: double) name, age, weight, and height.
+BMI(name: String, weight: double, Creates a BMI object with the specified
height: double) name, weight, height, and a default age 20.

+getBMI(): double Returns the BMI

+getStatus(): String Returns the BMI status (e.g., normal,
overweight, etc.)

FIGURE 10.5 The BMI class encapsulates BMI information.

352 Chapter 10 Thinking in Objects
Assume that the BMI class is available. Listing 10.3 gives a test program that uses this
class.

LISTING 10.3 UseBMIClass.java

1 public class UseBMIClass {
2 public static void main(String[] args) {
create an object 3 BMI bmi1 = new BMI("John Doe", 18, 145, 70);
invoke instance method 4 System.out.println("The BMI for " + bmi1.getName() + " is "
5 + bmi1.getBMI() + " " + bmi1.getStatus() );
6
create an object 7 BMI bmi2 = new BMI("Peter King", 215, 70);
invoke instance method 8 System.out.println("The BMI for " + bmi2.getName() + " is "
9 + bmi2.getBMI() + " " + bmi2.getStatus() );
10 }
11 }

The BMI for John Doe is 20.81 normal weight

The BMI for Peter King is 30.85 seriously overweight

Line 3 creates an object bmi1 for John Doe and line 7 creates an object bmi2 for Peter King.
You can use the instance methods getName(), getBMI(), and getStatus() to return the
BMI information in a BMI object.
The BMI class can be implemented as in Listing 10.4.

LISTING 10.4 BMI.java

1 public class BMI {
2 private String name;
3 private int age;
4 private double weight; // in pounds
5 private double height; // in inches
6 public static final double KILOGRAMS_PER_POUND = 0.45359237;
7 public static final double METERS_PER_INCH = 0.0254;
8
constructor 9 public BMI(String name, int age, double weight, double height) {
10 this.name = name;
11 this.age = age;
12 this.weight = weight;
13 this.height = height;
14 }
15
constructor 16 public BMI(String name, double weight, double height) {
17 this(name, 20, weight, height);
18 }
19
getBMI 20 public double getBMI() {
21 double bmi = weight * KILOGRAMS_PER_POUND /
22 ((height * METERS_PER_INCH) * (height * METERS_PER_INCH));
23 return Math.round(bmi * 100) / 100.0;
24 }
25
getStatus 26 public String getStatus() {
27 double bmi = getBMI();
28 if (bmi < 16)
29 return "seriously underweight";
30 else if (bmi < 18)
 10.7 Object Composition 353
31 return "underweight";
32 else if (bmi < 24)
33 return "normal weight";
34 else if (bmi < 29)
35 return "overweight";
36 else if (bmi < 35)
37 return "seriously overweight";
38 else
39 return "gravely overweight";
40 }
41
42 public String getName() {
43 return name;
44 }
45
46 public int getAge() {
47 return age;
48 }
49
50 public double getWeight() {
51 return weight;
52 }
53
54 public double getHeight() {
55 return height;
56 }
57 }

The mathematic formula for computing the BMI using weight and height is given in §3.10.
The instance method getBMI() returns the BMI. Since the weight and height are instance
data fields in the object, the getBMI() method can use these properties to compute the BMI
for the object.
The instance method getStatus() returns a string that interprets the BMI. The interpre-
tation is also given in §3.10.
This example demonstrates the advantages of the object-oriented paradigm over the
procedural paradigm. The procedural paradigm focuses on designing methods. The object- Procedural vs. Object-
oriented paradigm couples data and methods together into objects. Software design using the Oriented Paradigms
object-oriented paradigm focuses on objects and operations on objects. The object-oriented
approach combines the power of the procedural paradigm with an added dimension that inte-
grates data with operations into objects.
In procedural programming, data and operations on the data are separate, and this method-
ology requires sending data to methods. Object-oriented programming places data and the
operations that pertain to them in an object. This approach solves many of the problems inher-
ent in procedural programming. The object-oriented programming approach organizes pro-
grams in a way that mirrors the real world, in which all objects are associated with both
attributes and activities. Using objects improves software reusability and makes programs
easier to develop and easier to maintain. Programming in Java involves thinking in terms of
objects; a Java program can be viewed as a collection of cooperating objects.

10.7 Object Composition

An object can contain another object. The relationship between the two is called composition.
In Listing 10.4, you defined the BMI class to contain a String data field. The relationship
between BMI and String is composition.
Composition is actually a special case of the aggregation relationship. Aggregation models
has-a relationships and represents an ownership relationship between two objects. The owner