CHAPTER 2

An Introduction to Objects
and Classes

Classes
Class: Set of objects with the
same behavior, describes
characteristics and behavior of
an object.
Each class can have instances of
multiple objects
Written in a file all its own

Objects
Object: real world entity that you
can manipulate in your
programs (by invoking methods)
Each object belongs to a class

Object vs Class
Object

is an instance of a class

Cookie

Class

is a blueprint for an
object
Cookie

Cutter

Create an instance of an
object
Instantiation

of an object creates an
instance of an object and the
parameters passed into the
constructor will initialize the private
instance fields.keyword new

Car

c = new Car(blue, 1999);

An Object
An

object has data fields, which hold values

that can change while the program is
running. A piece of data maybe another
object.

An

object has a set of methods that can

process messages of certain types. A method
can change the objects state, send
messages to other objects, and create new
objects.

Class
blueprint for
objects of a
particular type
Defines the
structure
(number, types)
of the attributes
Defines available
behaviors of its
objects

Object

Attributes

Behaviors

Class: Car

Attributes:
String model
Color color
int numPassengers
double amountOfGas

car

Object: my

Attributes:
model = "Mustang"
color = Color.YELLOW
numPassengers = 0
amountOfGas = 16.5

Behaviors:
Behaviors:
Add/remove a passenger
Get the tank filled
Report when out of gas

Class
Written by a
programmer
Example: class Robot which
keeps track of its initial
location, current location
and direction facing with
behaviors such as turn and
step forward.

vs.

Object

Created when the

program is
running (by the
main method or a
constructor or
another method)
Example: R2D2 or WallE

OOP
Object-Oriented Programming
An

OO program models the application

as a world of interacting objects.

An
An

object can create other objects.

object can call another objects

(and its own) methods (that is, send
messages).

OOP Benefits
Facilitates

team development

Easier

to reuse software components and

write reusable software

Easier

GUI (Graphical User Interface) and

multimedia programming

Objects in the Dance Studio

Program
Dance Studio
window

Band

Foot
Dance selection
pulldown list

Dancer

Go / Stop button
Control panel

Dance floor
Positioning
button
Waltz, etc.
Dance step

Dance group

Classes and Source Files

Each

class is stored in a separate file

The name of the file must be the same
as the name of the class, with the
Car.java
extension .java
By convention, the
public class Car
{
...
}

name of a class
(and its source file)
always starts with
a capital letter.

(In Java, all names are case-sensitive.)

3 parts to every class

Fields/Instance

Fields/Instance
Variables /private data
members/Attributes

Methods/Behaviors
Constuctors

SomeClass.java

import ...

import statements

public class SomeClass

Class header
{
Fields

Attributes / variables that define the

objects state; can hold numbers,
characters, strings, other objects

Constructors

Methods

Procedures for constructing

a new object of this class
and initializing its fields
Actions that an object
of this class can take
(behaviors)

Object Diagrams and

Access to all the parts
public constructor
___________

private fields
____________

public method
___________

____________
____________

public method
___________

Part 1 - Fields
Constitute

private memory of an

object
Each field has a data type (int, double,
String, boolean, char, or another type
of object)
Each field has a name given by the
programmer

Fields
Should

always be of private access type

Can

be used by any method within the same

class.

From

within the class, just refer to them by

their names.
From outside the class in another file such as
main, the only way we can access them is via
methods of the class.

Syntax 2.6 : Instance Field

Declaration
accessSpecifier

class ClassName

{
...
accessSpecifier fieldType fieldName;

...

accessSpecifier could be private, public,

protected
fieldType could be int, double, String,
boolean, char

You name it!

Fields (contd)
private datatype name;
Usually
private

int, double, etc., or an

object: String, Image,
Foot

private double cost;

private String name;
private int age;

An objects STATE
Each

object of a class has its own set of

instance fields.

An

object stores its state in one or more

variables called INSTANCE FIELDS/DATA.

What

is in these private variables

indicate the STATE of an object.

Part 2 - Constructors
A

constructor is special
procedure for constructing an
object.

PURPOSE:

Initialize the
objects fields

Constructors
Always

have the same name as the

Always

public

class

No

return type

May

or may not take parameters

Constructors
public class Car()
{
public Car(int m)
{
miles = m;
}
. . .
}

Syntax 2.7 : Constructor

Implementation
To define the behavior of a constructor,
which is used to initialize the instance
fields of newly created objects
Using the new keyword
Invoked in new expression
new Car(15000)
For now we will construct an
object in the main file.

More on constructors
Not

a method

overloading

common practice, same

signature, different parameter lists
(method signature = name of method and parameter list)

class may have several constructors

that differ in the number and/or types
of their parameters

Overloaded Constructors
These are all different
public Car ( )
no parameters called
the
default constructor initializes
all private data to 0 or null.
public Car (int miles)
public Car (String name, int miles)
public Car (int miles, String name)

PUBLIC INTERFACE OF A
CLASS

The

constructors
and methods of a
class which can be
seen by all.

Public Access Specifier

Constructors

and methods can call

other public and private methods
of the same class.
Constructors and methods can call
only public methods of another
class.
Class X
Class Y
private field
public method

private method

public method

3. Methods
Example:

one of the behaviors of an

object may be to compute something.
All the objects of the class will use the
same formula for the computation, but
the result may depend on the specific
values of objects attributes at the
time of the computation.

Method Definition
Written in the class
access specifier (We will always use public)
return type (int,double,char,String,boolean,void,
or another objects type MUCH LATER)
method name (meaningful and lowercase)
list of parameters (need types and names
separated by commas)
method body in { }

Sample method
public double addIt (int number)
{
total = total + number;
return total;
}
Name each colored part
We can also have overloaded methods
public double addIt(int x, int y)

Methods (contd)
A

method can return a value to the

caller again for now this is just the
main file.
The keyword void in the methods
header indicates that the method does
not return any value
public void moveSideways(int distance)
{
...
Method Body is always in
}
curly braces

2 Types of Methods
Accessor

will access a private

variable and typically RETURN it,
make sure the return type
matches the data type of the field

Modifier/Mutator

will change
what is in a private field and
typically RETURN void.

METHOD PARAMETERS
These

are the values you pass into a

method.
They will be used inside the method in
some way.
They are only a COPY of the variable
from where you passed it in from.
They can have different names from
where you passed them in from.

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 line ends the method action

and returns program control to where it
was called from.

METHOD IMPLEMENTATION
A

CALL to a method
For instance System.out.printl();
is a call to the method println in the
system class.
Use a dot
For now we will call a method from our main
file.

Objects
Contain

1.
properties/variables/fields
2. methods/behaviors
3. constructors

Object Construction
In main for now
To create an new object:
new className(parameters without types)

This calls the constuctor which

matches the same number and
type of parameters and initializes
the private data fields to the
parameter values passed in.

Object Construction

Examples

new Rectangle(5, 10, 20, 30)

this would match the constructor:
public Rectangle(int x,int y,int w,int h)

new Car("BMW 540ti", 2004)

this would match the constructor:
public Car(String name, int year)

A Rectangle Object
an OBJECT DIAGRAM

Object Reference
We

need to be able to reference a

particular object to so we can use it
and its data and its methodsto do
this we must name it.
Called creating an object reference.
Each object will most likely have a
different name or reference to it.

Creating an Object Variables or

Object Reference
A

container that stores the location of

an object
MUST be initialized before you can use it
ClassName referenceName =
The right side of the equals sign now has an object
construction callsee previous slides.

Object Variables/Reference
Declare and optionally initialize:
Rectangle crispyCrunchy;
This only declares an object
reference, it does NOT create the
object itself until you use = new
Right now it refers to no object
BETTER KNOWN AS NULL

To use an object variable

Use

the reference name along with a

dot and a method call from that class.

Example:

r is a reference to a Rectangle
as in previous slide.
r.GetArea( );

2 object references referring to

the same object
Common

gotcha on AP multiple
choice questions (and on my tests)

Rectangle

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

what happens here on the next slide.

They both refer to the EXACT same object, not
a copy they are the SAME OBJECT.

Two Object Variables

Referring to the Same Object

Programs can use objects in

the following ways
To

construct an object with the new

keyword

to

store object references in an object

variable

to

call methods on an object variable

Testing a Class/Driver
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

VARIABLES
Lots

of different kind of variables.

So far we have discussed:
private instance variables in a class
object reference variables
parameters being passes into
methods or
constructors.
There are more

Local Variables - used

anywhere
created

in a block of code
enclosed within a set of curly
braces.
Could be in a method
Could be in the main class file
They exist only within that block
of code die upon closing brace

General Definition of a
Variable
An

item of information in memory

whose location is identified by a name.

Holds
Every

data of some sort

variable has a type which defines

what kind of information it will hold,
defines how much memory to set aside.

General Definition of a
Variable
Instance

fields -Do not need to be

initialized, numbers default to zero,
strings default to null.

Local

variables NEED to be initialized

to something.

Declaration vs Definition
age

int age ;

int age = 22;

age
22

Syntax 2.2: Variable

Definition

TypeName variableName;

TypeName variableName = expression;

Example:
Rectangle cerealBox;
String name ="Dave";
int x = 10;
Purpose:
To define a new variable of a particular type

and optionally supply an initial value

Naming Conventions for

Variables
Letters,

digits, and underscores

No symbols
No reserved words
Cant start with a digit
case sensitive (upper/lower)
Class

Name Variables - must be

Capitalized

Variable Catagories
class first letter capitalized
constant set only once never changed all capitalized
private instance field mySomething or specific name
variable noun
temporary variable - letter
accessor method verb getter
modifier method verb setter
method verb

Reserved Words
In

Java a number of words are reserved for a

special purpose.

Reserved

words use only lowercase letters.

Reserved

words include:

primitive data types: int, double, char, boolean, etc.

storage modifiers: public, private, static, final, etc.
control statements: if, else, switch, while, for, etc.
built-in constants: true, false, null

There

are about 50 reserved words total.

Programmer-Defined Names
In

addition to reserved words, Java

uses standard names for library
packages and classes:
String, Graphics, javax.swing, JApplet,
JButton, ActionListener, java.awt

The

programmer gives names to his or

her classes, methods, fields, and
variables.

Note

Do NOT make a class called

System it already exists you
overwrite it and loss all functionality.

Names (contd)
Programmers

follow strict style conventions.

Style:

Names of classes begin with an

uppercase letter, subsequent words are
capitalized:
public class FallingCube

Style:

Names of methods, fields, and

variables begin with a lowercase letter,
subsequent words are capitalized.
private final int delay = 30;
public void dropCube()

Names (contd)
Method

names often sound like verbs:

setBackground, getText, dropCube, start

Field

names often sound like nouns:

cube, delay, button, whiteboard

Constants

sometimes use all caps:

PI, CUBESIZE
It

is OK to use standard short names

for temporary throwaway variables:
i, k, x, y, str

Package
Package:

a set of libraries with

many RELATED classes of
prewritten code

To

import a class from a package for

use in a program

Syntax 2.3 : Importing a

Class from a Package
importpackageName.ClassName

Example:
import java.awt.Rectangle;

We

dont need to import anything

with the System class in it,
done automatically.

ENCAPSULATION
Keeping

things hidden as much as possible

to keep things bug free
Benefit: cant accidentally put an object into
an incorrect state.
Wrapping up variables and methods in such
a way so that only those things relevant to
the outside world are visible.
Hiding object data and providing
methods which access them (private
data and public methods.)

Encapsulation and
Information Hiding
A

class interacts with other classes only

through constructors and public methods
Other classes do not need to know the
mechanics (implementation details) of a
class to use it effectively
Encapsulation facilitates team work and
program maintenance (making changes to
the code)

ABSTRACTION

Strip

away to find
the essential
features of an
object.

Designing the Public

Interface

Behavior of bank account:

deposit money
withdraw money
get balance

Methods of BankAccount class:

deposit
withdraw
getBalance

Javadoc
Automatically

generates a set of HTML

pages that describe the class
utility which formats your comments
into a new set of documents that you
can view in a web browser
automatically creates hyperlinks to
other classes and methods

Javadoc Method Summary

Javadoc Method Detail

3 reasons to comment
First

sentence used in summary table of all

methods, javadoc with a description of each.
Spend more time deciding whether or not to
do it than it does just to do it.
Write method comment first to see if you
understand what you need to program.
Styles /*for multiple lines*/
//..once for each line
JavaDoc

Comments
Comments

are notes in plain English

inserted in the source code.

Comments

are used to:

document the programs purpose, author,

revision history, copyright notices, etc.
describe fields, constructors, and methods
explain obscure or unusual places in the code
temporarily comment out fragments of code

Formats for Comments

A

block comment is placed between /*

and */ marks:
/* Exercise 5-2 for Java Methods
Author: Miss Brace
Date: 3/5/2010
Rev. 1.0
*/

single-line comment goes from // to

the end of the line:
wt *= 2.2046;

// Convert to kilograms

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;

Designing and Implementing

a Class
1. What are you asked to do with an object,
list of operations needed.
2. Find names for the methods.
3. Document the public interface.
4. Determine instance variables.
5. Determine constructors.
6. Implement methods one at a time, easiest
first.
7. Test class, apply method calls.