Chapter 2

An Introduction to Objects and Classes


Chapter Goals

Objects and Classes

Rectangle Class

Rectangle Shapes


A Rectangle Object



Syntax 2.1: Object Construction

 
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

Uninitialized and Initialized Variables

Uninitialized:


Initialized:

Two Object Variables Referring to the Same Object


Syntax 2.2: Variable Definition

  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

Syntax 2.3 : Importing a Class from a Package

  importpackageName.ClassName ;

Example:

  import java.awt.Rectangle;

Purpose:

To import a class from a package for use in a program.

File MoveRect.java

1 import java.awt.Rectangle; 
2
3 public class MoveTest
4 {
5    public static void main(String[] args)
6    {
7       Rectangle cerealBox = new Rectangle(5, 10, 20, 30);
8       // move the rectangle
9       cerealBox.translate(15, 25);
10       // print the moved rectangle
11       System.out.println(cerealBox);
12    }

A Simple Class

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

Method Definition

Method Parameters

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

Syntax 2.4: Method Implementation

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

  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

A Test Class for the Greeter Class

public 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 Fields

public class Greeter

   ...
   private String name;
}

Instance Fields


Accessing Instance Fields

 Syntax 2.6 : Instance Field Declaration

 
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

Syntax 2.7 : Constructor Implementation

 
accessSpecifier 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.java

1 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.java

1 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 the Public Interface

Behavior of bank account:
Methods of BankAccount class:

BankAccount Public Interface

public BankAccount() 
public BankAccount(double initialBalance)
public void deposit(double amount)
public void withdraw(double amount)
public double getBalance()

Using the Public Interface

Commenting the Public Interface

/**
   Withdraws money from the bank account.
   @param 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
{
   ...
}


Javadoc Method Summary


Javadoc Method Detail


BankAccount Class Implementation

File BankAccount.java

1/**
2   A bank account has a balance that can be changed by 
3   deposits and withdrawals.
4*/
5public class BankAccount
6{  
7   /**
8      Constructs a bank account with a zero balance
9   */
10   public BankAccount()
11   {   
12      balance = 0;
13   }
14
15   /**
16      Constructs a bank account with a given balance
17      @param initialBalance the initial balance
18   */
19   public BankAccount(double initialBalance)
20   {   
21      balance = initialBalance;
22   }
23
24   /**
25      Deposits money into the bank account.
26      @param amount the amount to deposit
27   */
28   public void deposit(double amount)
29   {  
30      double newBalance = balance + amount;
31      balance = newBalance;
32   }
33
34   /**
35      Withdraws money from the bank account.
36      @param amount the amount to withdraw
37   */
38   public void withdraw(double amount)
39   {   
40      double newBalance = balance - amount;
41      balance = newBalance;
42   }
43
44   /**
45      Gets the current balance of the bank account.
46      @return the current balance
47   */
48   public double getBalance()
49   {   
50      return balance;
51   }
52
53   private double balance;
54}

File BankAccountTest.java

1/**
2   A class to test the BankAccount class.
3*/
4public class BankAccountTest
5{
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

Explicit and Implicit Parameters

public void withdraw(double amount)

double newBalance = balance - amount;
balance = newBalance;
}
balance is the balance of the object to the left of the dot:

momsSavings.withdraw(500)
means
   double newBalance = momsSavings.balance - amount;
momsSavings.balance = newBalance;