CHAPTER 2

OBJECTS AND CLASSES Goals:

•To understand the concepts of classes and objects•To realize the difference between objects and object references•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 fields and local variables •To appreciate the importance of documentation comments

Objects and Classes Object: entity that you can manipulate in your

programs (by invoking methods) Each object belongs to a class Class: Set of objects with the same behavior Class determines legal methods"Hello".println() // Error"Hello".length() // OK

An example: Rectangle Class– Construct a rectangle:

new Rectangle(5, 10, 20, 30)new Rectangle()

– Use the constructed objectSystem.out.println(new Rectangle(5,10,20,30));

prints java.awt.Rectangle[x=5,y=10,width=20,height=30]

Rectangle Shapes

A Rectangle Object

Syntax 2.1: Object Construction• Syntax: new ClassName(parameters)• Example:

– new Rectangle(5, 10, 20, 30)– new Car("BMW 540ti", 2004)

• Purpose: To construct a new object, initialize it with the construction parameters, and return a reference to the constructed object.

• Object Variables Declare and optionally initialize:

Rectangle cerealBox = new Rectangle(5, 10, 20, 30);Rectangle crispyCrunchy;

Apply methods:cerealBox.translate(15, 25);

Share objects:r = cerealBox;

Uninitialized and Initialized Variables

Uninitialized

Initialized

Two Object Variables Referring to the Same Object

Syntax 2.2: Variable Definition• Syntax:

– TypeName variableName;– TypeName variableName = expression;

• Example:– Rectangle cerealBox; – String name ="Dave";

• Purpose: To define a new variable of a particular type and optionally supply an initial value

Writing a Test Program Invent a new class, say MoveTest Supply a main method Place instructions inside the main method Import library classes by specifying the package and

class name:import java.awt.Rectangle;

You don't need to import classes in the java.lang package such as String and System

Syntax 2.3 : Importing a Class from a Package

• Syntax: import packageName.ClassName ;• Example: import java.awt.Rectangle; • Purpose: To import a class from a package for use in a program

File MoveRect.javaimport java.awt.Rectangle; public class MoveTest {

public static void main(String[] args) { Rectangle cerealBox = new Rectangle(5, 10, 20, 30); // move the rectangle cerealBox.translate(15, 25); // print the moved rectangle System.out.println(cerealBox); }}

A Simple Class

public class Greeter {

public String sayHello() { String message ="Hello,World!"; return message; }

}

Method Definition Method prototype (signature)

access specifier (such as public) return type (such as String or void) method name (such as sayHello) list of parameters (empty for sayHello)

Method body in { }

Examplepublic class Rectangle

{ . . . public void translate(int x, int y) { method body } . . .}

Syntax 2.4: Method Implementation• Syntax

public class ClassName

{

... accessSpecifier returnType methodName(parameterType parameterName,...) { method body

} ...

}

• Example:public class Greeter {

public String sayHello() {

String message = "Hello,World!";

return message;}

}• Purpose: To define the

behavior of a method A method definition specifies the method name, parameters, and the statements for carrying out the method's actions

Syntax 2.5: The return Statement • Example:

return expression;or return;

• Example:return message;

• Purpose: To specify the value that a method returns, and exit the method immediately. The return value becomes the value of the method call expression.

Testing a Class Test 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

• A Test Class for the Greeter Classpublic class GreeterTest {

public static void main(String [] args)) { Greeter worldGreeter = new Greeter();

System.out.println(worldGreeter.sayHello()); }

}

Building a Test Program

1. Make a new subfolder for your program.

2. Make two files, one for each class.

3. Compile both files.

4. Run the test program.

Testing with the SDK Tools

• mkdir greeter • cd greeter • edit Greeter.java • edit GreeterTest.java • javac Greeter.java • javac GreeterTest.java • java GreeterTest

Testing with BlueJ

Instance Fieldspublic class Greeter{

...private String name;

}

access specifier (such as private) type of variable (such as String) name of variable (such as name)

Accessing Instance Fields

public String sayHello() {String message = "Hello, " + name + "!";return message;

}

The sayHello method of the Greeter class can access the private instance field, others can not

Syntax 2.6 : Instance Field Declaration• Syntax:

– accessSpecifier class ClassName{ ... accessSpecifier fieldType fieldName; ... }

• Example:public class Greeter { ... private String name; ... }

• Purpose: To define a field that is present in every object of a class

Constructors A constructor initializes the

instance variables Constructor name = class name Invoked in new expression

new Greeter("Dave")

Syntax 2.7 : Constructor Implementation

• SyntaxaccessSpecifier class ClassName { ... accessSpecifier

ClassName(parameterType parameterName ...) { constructor implementation } ... }

• Example:public class Greeter { ... public Greeter(String aName) { name = aName; } ...}

• Purpose: To define the behavior of a constructor, which is used to initialize the instance fields of newly created objects

File Greeter.java1 public class Greeter 2 { 3 public Greeter(String aName) 4 { 5 name = aName; 6 } 7 8 public String sayHello() 9 {10 String message = "Hello, "

+ name + "!"; 11 return message; 12 } 13 14 private String name; 15 }

File GreeterTest.java1 public class GreeterTest 2 { 3 public static void main(String[] args) 4 {

5 Greeter worldGreeter = new Greeter("World");

6 System.out.println(

worldGreeter.sayHello()); 7 8 Greeter daveGreeter = new

Greeter("Dave"); 9 System.out.println(daveGreeter.

sayHello()); 10 } 11 }

Designing A Class: Bank Account

• Analysis: – Behavior of bank

account: deposit money withdraw money get balance

– Methods of BankAccount class:

deposit withdraw getBalance

• Designing Interface– Constructor

• public BankAccount() • public BankAccount(double

initialBalance)

– Methods• public void deposit(double

amount) • public void

withdraw(double amount) • public double getBalance()

Commenting/**

Withdraws money from the bank account. @param the amount to withdraw

*/

public void withdraw(double amount) {

implementation filled in later }

/** A bank account has a balance that can be changed by deposits and withdrawals.

*/ public class BankAccount {

… }

/** Gets the current balance of the bank account. @return the current balance

*/ public double getBalance() {

implementation filled in later }

Commenting the class

Commenting interface

Javadoc Method Summary

Javadoc Method Detail

BankAccount Class Implementation

• Determine instance variables to hold object stateprivate double balance

• Implement methods and constructors

Using the Interface Transfer balance

double amt = 500;momsSavings.withdraw(amt);harrysChecking.deposit(amt);

Add interestdouble rate = 5; // 5%double amt = acct.getBalance() * rate / 100;acct.deposit(amt);

File BankAccount.java/**

A bank account has a balance that can be changed by deposits and withdrawals.

*/ public class BankAccount { // instance field

private double balance;

/** Constructs a bank account with

a zero balance */ public BankAccount() { balance = 0; }

/** Deposits money into the bank account. @param amount the amount to deposit */ public void deposit(double amount) {

double newBalance=balance+amount; balance = newBalance;

} /** Withdraws money from the bank account. @param amount the amount to withdraw */ public void withdraw(double amount) {

double newBalance=balance-amount; balance = newBalance;

} /**

Gets the current balance. @return the current balance

*/ public double getBalance() {

return balance; } }

File BankAccountTest.java1 /** 2 A class to test the BankAccount class. 3 */ 4 public class BankAccountTest5 { 6 /** 7 Tests the methods of the BankAccount class. 8 @param args not used 9 */ 10 public static void main(String[] args) 11 { 12 BankAccount harrysChecking = new

BankAccount(); 13 harrysChecking.deposit(2000)14 harrysChecking.withdraw(500)15 System.out.println(harrysChecking.getBalance()); 16 } 17 }

Calling a Method in BlueJ

The Method Return Value in BlueJ

Variable Types Instance fields (balance in BankAccount) Local variables (newBalance in deposit method) Parameter variables (amount in deposit method)

Explicit and Implicit Parameterspublic void withdraw(double amount)

{ double newBalance = balance - amount; balance = newBalance;}

• balance is the balance of the object to the left of the dot:balance is an implicit parameter, while amount is an explicit parametermomsSavings.withdraw(500)

means double newBalance = momsSavings.balance - amount;

momsSavings.balance = newBalance;