To become familiar with the process of implementing classes
To be able to implement simple methods
To understand the purpose and use of constructors
To understand how to access instance variables and local variables
To be able to write javadoc comments
To implement classes for drawing graphical shapes
Instance Variables
Example: tally counter
Simulator statements:
Counter tally = new Counter();
tally.count();
tally.count();
int result = tally.getValue(); // Sets result to 2
Each counter needs to store a variable that keeps track of how many times the counter has been advanced
Instance Variables
Instance variables store the data of an object
Instance of a class: an object of the class
The class declaration specifies the instance variables:
public class Counter
{
private int value;
...
}
Instance Variables
An instance variable declaration consists of the following parts:
access specifier (private)
type of variable (such as int)
name of variable (such as value)
Each object of a class has its own set of instance variables
You should declare all instance variables as private
Instance Variables
Syntax 3.1 Instance Variable Declaration
Accessing Instance Variables
The count method advances the counter value by 1:
public void count()
{
value = value + 1;
}
The getValue method returns the current value:
public int getValue()
{
return value;
}
Private instance variables can only be accessed by methods of the same class
Self Check 3.1
Supply the body of a method public void reset() that resets the counter back to zero.
Answer:
public void reset()
{
value = 0;
}
Self Check 3.2
Suppose you use a class Clock with private instance variables hours and minutes. How can you access these variables in your program?
Answer: You can only access them by invoking the methods of the Clock class.
Encapsulation
Encapsulation is the process of hiding object data and providing
methods for data access
To encapsulate data, declare instance variables as private and declare public methods that access the variables
Encapsulation allows a programmer to use a class without having to know its implementation
Information hiding makes it simpler for the implementor of a class to locate errors and change implementations
Self Check 3.3
Consider the Counter class. A counter’s value starts at 0 and is advanced by the count method, so it should never be negative. Suppose you found a negative value variable during testing. Where would you look for the error?
Answer: In one of the methods of the Counter class.
Self Check 3.4
In Chapters 1 and 2, you used System.out as a black box to cause output
to appear on the screen. Who designed and implemented System.out?
Answer: The programmers who designed and implemented the Java library.
Self Check 3.5
Suppose you are working in a company that produces personal finance software.
You are asked to design and implement a class for representing bank accounts.
Who will be the users of your class?
Answer: Other programmers who work on the personal finance application.
Specifying the Public Interface of a Class
Behavior of bank account (abstraction):
deposit money
withdraw money
get balance
Specifying the Public Interface of a Class: Methods
Methods of BankAccount class:
deposit
withdraw
getBalance
We want to support method calls such as the following:
Specifying the Public Interface of a Class: Method Declaration
A method declaration contains a header and a body consisting of statements that are executed when the method is called
public void deposit(double amount)
{
implementation - filled in later
}
Specifying the Public Interface of a Class: Method Header
access specifier (usually public)
return type (such as void or double)
method name (such as deposit)
list of parameter variables (such as double amount)
Examples:
public void deposit(double amount)
public void withdraw(double amount)
public double getBalance()
Specifying the Public Interface of a Class: Constructor Declaration
A constructor initializes the instance variables
Constructor name = class name
public BankAccount() { // body--filled in later
}
Constructor body is executed when new object is created
Statements in constructor body set the internal data of the object that is
being constructed
All constructors of a class have the same name
Compiler can tell constructors apart because they take different parameters
BankAccount Public Interface
The public constructors and
methods of a class form the public interface of the class:
public class BankAccount
{
// private variables--filled in later
// Constructors
public BankAccount()
{
// body--filled in later
}
public BankAccount(double initialBalance)
{
// body--filled in later
}
// Methods
public void deposit(double amount)
{
// body--filled in later
}
public void withdraw(double amount)
{
// body--filled in later
}
public double getBalance()
{
// body--filled in later
}
}
Syntax 3.2 Class Declaration
Self Check 3.6
How can you use the methods of the public interface to empty the harrysChecking
bank account?
BankAccount harrysChecking = new BankAccount(10000);
System.out.println(harrysChecking.withdraw(500));
Answer: The withdraw method has return type void. It doesn’t return a value. Use the getBalance method to obtain the balance after the withdrawal.
Self Check 3.8
Suppose you want a more powerful bank account abstraction that keeps track of an account
number in addition to the balance. How would you change the public
interface to accommodate this enhancement?
Answer: Add an accountNumber parameter to the
constructors, and add a getAccountNumber method. There is no need for a setAccountNumber
method – the account number never changes after construction.
Commenting the Public Interface
/**
Withdraws money from the bank account.
@param amount the amount to withdraw
*/
public void withdraw(double amount)
{
//implementation filled in later
}
/**
Gets the current balance of the bank account.
@return the current balance
*/
public double getBalance()
{
//implementation filled in later
}
Class Comment
/**
A bank account has a balance that can be changed by
deposits and withdrawals.
*/
public class BankAccount
{
. . .
}
Provide documentation comments for
every class
every method
every parameter
every return value
Javadoc Method Summary
Javadoc Method Detail
Self Check 3.9
Provide documentation comments for the Counter class of Section 3.1.
Answer:
/**
This class models a tally counter.
*/
public class Counter
{
private int value;
/**
Gets the current value of this counter.
@return the current value
*/
public int getValue()
{
return value;
}
/**
Advances the value of this counter by 1.
*/
public void count()
{
value = value + 1;
}
}
Self Check 3.10
Suppose we enhance the BankAccount class so that each account has an
account number. Supply a documentation comment for the constructor
public BankAccount(int accountNumber, double initialBalance)
Answer:
/**
Constructs a new bank account with a given initial balance.
@param accountNumber the account number for this account
@param initialBalance the initial balance for this account
*/
Self Check 3.11
Why is the following documentation comment questionable?
/**
Each account has an account number.
@return the account number of this account
*/
public int getAccountNumber()
Answer: The first sentence of the method description should describe the method –
it is displayed in isolation in the summary table.
Providing the Class Implementation
First determine the data that each bank account object contains
public BankAccount()
{
private double balance;
}
Then supply the bodies of the constructors and methods
Implementing Constructors
Constructors contain instructions to initialize the instance variables of an object
public BankAccount()
{
balance = 0;
}
public BankAccount(double initialBalance)
{
balance = initialBalance;
}
Constructor Call Example
Statement:
BankAccount harrysChecking = new BankAccount(1000);
Create a new object of type BankAccount
Call the second constructor (because a construction parameter is supplied in the constructor call)
Set the parameter variable initialBalance to 1000
Set the balance instance variable of the newly created object to initialBalance
Return an object reference, that is, the memory location of the object, as the
value of the new expression
Store that object reference in the harrysChecking variable
Suppose we modify the BankAccount class so that each bank account has an account number. How does this change affect the instance variables?
Answer: An instance variable
private int accountNumber;
needs to be added to the class.
Self Check 3.13
Why does the following code not succeed in robbing mom’s bank account?
public class BankRobber
{
public static void main(String[] args)
{
BankAccount momsSavings = new BankAccount(1000);
momsSavings.balance = 0;
}
}
Answer: Because the balance instance variable is accessed from the main method of BankRobber.
The compiler will report an error because balance has private access in BankAccount.
Self Check 3.14
The Rectangle class has four instance variables: x, y, width, and height. Give a
possible implementation of the getWidth method.
Answer:
public int getWidth()
{
return width;
}
Self Check 3.15
Give a possible implementation of the translate method of the Rectangle class.
Answer: There is more than one correct answer. One possible implementation is as follows:
public void translate(int dx, int dy)
{
int newx = x + dx;
x = newx;
int newy = y + dy;
y = newy;
}
Unit Testing
Unit test: verifies that a class works correctly in isolation, outside
a complete program
To test a class, use an environment for interactive testing, or write a tester
class
Tester class: a class with a main method that contains statements to test
another class
Typically carries out the following steps:
Construct one or more objects of the class that is being tested
Invoke one or more methods
Print out one or more results
Print the expected results
ch03/account/BankAccountTester.java
Program Run:
1500
Expected: 1500
Unit Testing
Details for building the program vary. In most environments, you need to carry
out these steps:
Make a new subfolder for your program
Make two files, one for each class
Compile both files
Run the test program
Testing With BlueJ
Self Check 3.16
When you run the BankAccountTester program, how many objects of class BankAccount
are constructed? How many objects of type BankAccountTester?
Answer: One BankAccount object, no BankAccountTester object. The
purpose of the BankAccountTester class is merely to hold the main
method.
Self Check 3.17
Why is the BankAccountTester class unnecessary in development
environments that allow interactive testing, such as BlueJ?
Answer: In those environments, you can issue interactive commands to construct BankAccount
objects, invoke methods, and display their return values.
Local Variables
A local variable is declared in the body of a method:
What do local variables and parameter variables
have in common? In which essential aspect do they differ?
Answer: Variables of both categories belong to methods –
they come alive when the method is called, and they die when the method exits.
They differ in their initialization. Parameter variables are initialized with
the call values; local variables must be explicitly initialized.
Self Check 3.19
Why was it necessary to introduce the local variable change in the giveChange
method? That is, why didn’t the method simply end with the statement
return payment - purchase;
Answer: After computing the change due, payment and purchase were set to zero. If the
method returned payment - purchase, it would always return zero.
Implicit Parameter
The implicit parameter of a method is the object on which the method is invoked
