Lecture 1

Chapter 6
 Course Main Objective
On successful completion of this course, students will be able to:

• Explain the steps in creating an executable computer program using object-oriented concepts.

• Explain the benefits of object-oriented design and understand when it is an appropriate

methodology to use including - classes, objects, inheritance, data abstraction, encapsulation, and
polymorphism.

• Design object-oriented solutions for moderately complex applications involving multiple objects.

• Explain the benefits of code reuse by learning how to make use of off-the-shelf Java libraries.
 Assessment Percentage of Total Assessment
Score
Assignments and Quizzes and Class activates 10%
Mid-term Exam 20%
Final Exam 50% (30 theoretical + 20 practical)
Lab evaluation exercises and Project 20% (10 exercises + 10 Project)
• Required Textbooks: Gaddis, Tony. Starting Out with Java: From Control
Structures through Objects. Pearson. 6th edition. Pearson.

• Electronic Materials: Slides and related handouts.

• Inheritance and code reusability, protected members, extend classes, overriding vs.
overloading, access superclass constructors and methods, the Object class and its
toString() and equals() methods, prevent class extending & method overriding.

• Polymorphism and dynamic binding, upcasting and downcasting, casting objects

and the instanceof operator.
• Abstract classes and interfaces.

• Exception handling: basic exceptions, throwing and catching exceptions, creating

customized exceptions, rethrowing exceptions, performing cleanup with finally.

• Generic classes, interfaces, and methods.

 Lecture 1 Topics
Chapter 6 discusses the following main topics:
• Objects and Classes
• Writing a Simple Class, Step by Step
• Instance Fields and Methods
• Constructors
• Passing Objects as Arguments
• Overloading Methods and Constructors
• Scope of Instance Fields
• Packages and import Statements

6-9
 Objects and Classes

• An object exists in memory and performs a specific task.

• Objects have two general capabilities:

• Objects can store data. The pieces of data stored in an object are
known as fields.

• Objects can perform operations. The operations that an object can

perform are known as methods.

6-10
 Objects and Classes

• You have already used the following objects:

• Scanner objects, for reading input
• Random objects, for generating random numbers
• PrintWriter objects, for writing data to files

• When a program needs the services of a particular type of

object, it creates that object in memory, and then calls that
object's methods as necessary.
 Objects and Classes

• Classes: Where Objects Come From

• A class is code that describes a particular type of object. It specifies the
data that an object can hold (the object's fields), and the actions that an
object can perform (the object's methods).

• You can think of a class as a code "blueprint" that can be used to

create a particular type of object.
 Objects and Classes

• When a program is running, it can use the class to

create, in memory, as many objects of a specific type as
needed.

• Each object that is created from a class is called an

instance of the class.
 Objects and Classes
This expression creates a
Example: Scanner object in memory.

Scanner keyboard = new Scanner(System.in);

The object's memory address

is assigned to the keyboard
variable.

keyboard Scanner
variable object
 Objects and Classes
This expression creates a
Example: Random object in memory.

Random rand = new Random();

The object's memory address is

assigned to the rand variable.

rand Random
variable object
 Objects and Classes
This expression creates a
Example: PrintWriter object in memory.

PrintWriter outputFile = new PrintWriter("numbers.txt");

The object's memory address is assigned to

the outputFile variable.

outputFile PrintWriter
variable object
Primitive Variables
 Objects and Classes

• The Java API provides many classes

• So far, the classes that you have created objects from are provided by the Java API.

• Examples:
• Scanner

• Random

• PrintWriter

• See ObjectDemo.java
 Writing a Class, Step by Step

• A Rectangle object will have the following fields:

• length. The length field will hold the rectangle’s length.
• width. The width field will hold the rectangle’s width.

6-20
 Writing a Class, Step by Step
• The Rectangle class will also have the following methods:
• setLength. The setLength method will store a value in an object’s length
field.
• setWidth. The setWidth method will store a value in an object’s width field.
• getLength. The getLength method will return the value in an object’s
length field.
• getWidth. The getWidth method will return the value in an object’s width
field.
• getArea. The getArea method will return the area of the rectangle, which is the
result of the object’s length multiplied by its width.

6-21
 UML Diagram

• Unified Modeling Language (UML) provides a set of standard

diagrams for graphically depicting object-oriented systems.

Class name goes here

Fields are listed here

Methods are listed here

6-22
 UML Diagram for Rectangle class

Rectangle

length
width

setLength()
setWidth()
getLength()
getWidth()
getArea()

6-23
 Writing the Code for the Class Fields

public class Rectangle

private double length;

private double width;

6-24
 Access Specifiers
• An access specifier is a Java keyword that indicates how a field or
method can be accessed.
• public
• When the public access specifier is applied to a class member, the member
can be accessed by code inside the class or outside.
• private
• When the private access specifier is applied to a class member, the member
cannot be accessed by code outside the class. The member can be accessed
only by methods that are members of the same class.

6-25
 Header for the setLength Method

Return Notice the word

Type static does not
Access Method appear in the method
specifier Name header designed to work
on an instance of a class
(instance method).

public void setLength (double len)

Parameter variable declaration

6-26
 Writing and Demonstrating the setLength Method

/**
The setLength method stores a value in the
length field.
@param len The value to store in length.
*/
public void setLength(double len)
{
length = len;
}
Examples: Rectangle.java, LengthDemo.java
6-27
Rectangle.java
LengthDemo.java
 Creating a Rectangle object

Rectangle box = new Rectangle ();

A Rectangle object
The box
variable holds length: 0.0
the address of address
the Rectangle width: 0.0
object.

6-30
 Calling the setLength Method

box.setLength(10.0);
The box A Rectangle object
variable holds the
address of the length: 10.0
address
Rectangle width: 0.0
object.

This is the state of the box object after

the setLength method executes.
6-31
 Writing the getLength Method
/**
The getLength method returns a Rectangle
object's length.
@return The value in the length field.
*/
public double getLength()
{
return length;
}
Similarly, the setWidth and getWidth methods can be created.
Examples: Rectangle.java, LengthWidthDemo.java

6-32
 Writing and Demonstrating the getArea Method
/**

The getArea method returns a Rectangle

object's area.

@return The product of length times width.

*/

public double getArea()

return length * width;

Examples: Rectangle.java, RectangleDemo.java

6-33
 Accessor and Mutator Methods
• Because of the concept of data hiding, fields in a class are private.

• The methods that retrieve the data of fields are called accessors.

• The methods that modify the data of fields are called mutators.

• Each field that the programmer wishes to be viewed by other classes needs an accessor.

• Each field that the programmer wishes to be modified by other classes needs a mutator.

6-34
 Accessors and Mutators
• For the Rectangle example, the accessors and mutators are:
• setLength : Sets the value of the length field.
public void setLength(double len) …

• setWidth : Sets the value of the width field.

public void setLength(double w) …

• getLength : Returns the value of the length field.

public double getLength() …

• getWidth : Returns the value of the width field.

public double getWidth() …

• Other names for these methods are getters and setters.

6-35
 Data Hiding

• An object hides its internal, private fields from code that is outside the
class that the object is an instance of.

• Only the class's methods may directly access and make changes to the
object’s internal data.

• Code outside the class must use the class's public methods to operate on an
object's private fields.
 Data Hiding

• Data hiding is important because classes are typically used as

components in large software systems, involving a team of
programmers.

• Data hiding helps enforce the integrity of an object's internal data.

 Stale Data
• Some data is the result of a calculation.
• Consider the area of a rectangle.
• length × width

• It would be impractical to use an area variable here.

• Data that requires the calculation of various factors has the potential to become
stale.
• To avoid stale data, it is best to calculate the value of that data within a method
rather than store it in a variable.

6-38
 Stale Data
• Rather than use an area variable in a Rectangle class:
public double getArea()
{
return length * width;
}

• This dynamically calculates the value of the rectangle’s area when the method is
called.
• Now, any change to the length or width variables will not leave the area of the
rectangle stale.

6-39
 UML Data Type and Parameter Notation

• UML diagrams are language independent.

• UML diagrams use an independent notation to show return types,

access modifiers, etc.
Access modifiers Rectangle
are denoted as:
public +
private - - width : double

+ setWidth(w : double) : void

6-40
 UML Data Type and Parameter Notation

• UML diagrams are language independent.

• UML diagrams use an independent notation to show return types,

access modifiers, etc. Variable types are
Rectangle placed after the variable
name, separated by a
colon.
- width : double

+ setWidth(w : double) : void

6-41
 UML Data Type and Parameter Notation

• UML diagrams are language independent.

• UML diagrams use an independent notation to show return types,

access modifiers, etc. Method return types are
Rectangle placed after the method
declaration name,
separated by a colon.
- width : double

+ setWidth(w : double) : void

6-42
 UML Data Type and Parameter Notation

• UML diagrams are language independent.

• UML diagrams use an independent notation to show return types,

access modifiers, etc.
Method parameters
are shown inside the Rectangle
parentheses using the
same notation as
variables. - width : double

+ setWidth(w : double) : void

6-43
 Converting the UML Diagram to Code

• Putting all of this information together, a Java class file can be built
easily using the UML diagram.

• The UML diagram parts match the Java class file structure.

class header
ClassName
{
Fields Fields
Methods Methods
}

6-44
 Converting the UML Diagram to Code
The structure of the class can be public class Rectangle
compiled and tested without having {
bodies for the methods. Just be sure to private double width;
put in dummy return values for methods private double length;
that have a return type other than void.
public void setWidth(double w)
{
Rectangle }
public void setLength(double len)
{
- width : double }
- length : double public double getWidth()
{ return 0.0;
+ setWidth(w : double) : void }
+ setLength(len : double): void public double getLength()
{ return 0.0;
+ getWidth() : double }
+ getLength() : double public double getArea()
+ getArea() : double { return 0.0;
}
6-45 }
 Converting the UML Diagram to Code
Once the class structure has been public class Rectangle
{
tested, the method bodies can be
private double width;
written and tested. private double length;

public void setWidth(double w)

Rectangle { width = w;
}
- width : double public void setLength(double len)
- length : double { length = len;
}
public double getWidth()
+ setWidth(w : double) : void
{ return width;
+ setLength(len : double): void }
+ getWidth() : double public double getLength()
+ getLength() : double { return length;
}
+ getArea() : double
public double getArea()
{ return length * width;
}
6-46 }
 Instance Fields and Methods

• Fields and methods that are declared as previously shown are called
instance fields and instance methods.

• Objects created from a class each have their own copy of instance
fields.

• Instance methods are methods that are not declared with a special
keyword, static.

6-47
 Instance Fields and Methods

• Instance fields and instance methods require an object to be created in order

to be used.

• See example: RoomAreas.java

• Note that each room represented in this example can have different
dimensions.
Rectangle kitchen = new Rectangle();
Rectangle bedroom = new Rectangle();
Rectangle den = new Rectangle();

6-48
 States of Three Different Rectangle Objects
The kitchen variable
holds the address of a
length: 10.0
address
Rectangle Object.
width: 14.0

The bedroom variable length: 15.0

holds the address of a address
Rectangle Object. width: 12.0

The den variable

length: 20.0
holds the address of a address
Rectangle Object.
width: 30.0

6-49
 Constructors

• Classes can have special methods called constructors.

• A constructor is a method that is automatically called when an object is

created.

• Constructors are used to perform operations at the time an object is created.

• Constructors typically initialize instance fields and perform other object

initialization tasks.

6-50
 Constructors

• Constructors have a few special properties that set them apart from
normal methods.
• Constructors have the same name as the class.

• Constructors have no return type (not even void).

• Constructors may not return any values.

• Constructors are typically public.

6-51
 Constructor for Rectangle Class
/**

Constructor

@param len The length of the rectangle.

@param w The width of the rectangle.

*/

public Rectangle(double len, double w)

length = len;

width = w;

Examples: Rectangle.java, ConstructorDemo.java

6-52
 Constructors in UML

• In UML, the most common way constructors are defined is:

Rectangle
Notice there is no
return type listed
- width : double for constructors.
- length : double
+Rectangle(len:double, w:double)
+ setWidth(w : double) : void
+ setLength(len : double): void
+ getWidth() : double
+ getLength() : double
+ getArea() : double

6-53
 Uninitialized Local Reference Variables
• Reference variables can be declared without being initialized.

Rectangle box;

• This statement does not create a Rectangle object, so it is an uninitialized local reference
variable.

• A local reference variable must reference an object before it can be used, otherwise a compiler
error will occur.

box = new Rectangle(7.0, 14.0);

• box will now reference a Rectangle object of length 7.0 and width 14.0.

6-54
 The Default Constructor

• When an object is created, its constructor is always called.

• If you do not write a constructor, Java provides one when the class is
compiled. The constructor that Java provides is known as the default
constructor.
• It sets all of the object’s numeric fields to 0.
• It sets all of the object’s boolean fields to false.
• It sets all of the object’s reference variables to the special value null.

6-55
 The Default Constructor
• The default constructor is a constructor with no parameters, used to initialize an
object in a default configuration.

• The only time that Java provides a default constructor is when you do not write
any constructor for a class.
• See example: First version of Rectangle.java

• A default constructor is not provided by Java if a constructor is already written.

• See example: Rectangle.java with Constructor

6-56
 Writing Your Own No-Arg Constructor
• A constructor that does not accept arguments is known as a no-arg
constructor.
• The default constructor (provided by Java) is a no-arg constructor.
• We can write our own no-arg constructor

public Rectangle()
{
length = 1.0;
width = 1.0;
}

6-57
 The String Class Constructor

• One of the String class constructors accepts a string literal as an

argument.

• This string literal is used to initialize a String object.

• For instance:

String name = new String("Michael Long");

6-58
 The String Class Constructor

• This creates a new reference variable name that points to a String

object that represents the name “Michael Long”

• Because they are used so often, String objects can be created with a
shorthand:

String name = "Michael Long";

6-59
 Passing Objects as Arguments

• When you pass a object as an argument, the thing that is passed into
the parameter variable is the object's memory address.

• As a result, parameter variable references the object, and the receiving

method has access to the object.

• See DieArgument.java
 Overloading Methods and Constructors

• Two or more methods in a class may have the same name as long as
their parameter lists are different.

• When this occurs, it is called method overloading. This also applies to

constructors.

• Method overloading is important because sometimes you need several

different ways to perform the same operation.

6-61
 Overloaded Method add
public int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}

public String add (String str1, String str2)

{
String combined = str1 + str2;
return combined;
}

6-62
 Method Signature and Binding
• A method signature consists of the method’s name and the data types of the method’s
parameters, in the order that they appear. The return type is not part of the signature.

Signatures of the
add(int, int)
add methods of
add(String, String)
previous slide

• The process of matching a method call with the correct method is known as binding. The
compiler uses the method signature to determine which version of the overloaded method
to bind the call to.

6-63
 Rectangle Class Constructor Overload

If we were to add the no-arg constructor we wrote previously to our

Rectangle class in addition to the original constructor we wrote, what
would happen when we execute the following calls?

Rectangle box1 = new Rectangle();

Rectangle box2 = new Rectangle(5.0, 10.0);

6-64
 Rectangle Class Constructor Overload
If we were to add the no-arg constructor we wrote previously to our
Rectangle class in addition to the original constructor we wrote,
what would happen when we execute the following calls?

Rectangle box1 = new Rectangle();

Rectangle box2 = new Rectangle(5.0, 10.0);

The first call would use the no-arg constructor and box1 would have a length of 1.0
and width of 1.0.
The second call would use the original constructor and box2 would have a length
of 5.0 and a width of 10.0.

6-65
 The BankAccount Example
BankAccount.java BankAccount
AccountTest.java -balance:double

+BankAccount()

Overloaded Constructors +BankAccount(startBalance:double)

+BankAccount(strString):
+deposit(amount:double):void
Overloaded deposit methods
+deposit(str:String):void
+withdraw(amount:double):void
Overloaded withdraw methods
+withdraw(str:String):void
+setBalance(b:double):void
Overloaded setBalance methods
+setBalance(str:String):void
+getBalance():double

6-66
 Scope of Instance Fields

• Variables declared as instance fields in a class can be accessed by any

instance method in the same class as the field.

• If an instance field is declared with the public access specifier, it

can also be accessed by code outside the class, as long as an instance
of the class exists.

6-67
 Shadowing
• A parameter variable is, in effect, a local variable.
• Within a method, variable names must be unique.
• A method may have a local variable with the same name as an instance field.
• This is called shadowing.
• The local variable will hide the value of the instance field.
• Shadowing is discouraged and local variable names should not be the same as
instance field names.

6-68
 Packages and import Statements

• Classes in the Java API are organized into packages.

• Explicit and Wildcard import statements
• Explicit imports name a specific class
• import java.util.Scanner;
• Wildcard imports name a package, followed by an *
• import java.util.*;

• The java.lang package is automatically made available to any Java

class.

6-69
 Some Java Standard Packages

6-70
 Object Oriented Design
Finding Classes and Their Responsibilities

• Finding the classes

• Get written description of the problem domain
• Identify all nouns, each is a potential class
• Refine list to include only classes relevant to the problem

• Identify the responsibilities

• Things a class is responsible for knowing
• Things a class is responsible for doing
• Refine list to include only classes relevant to the problem

6-71