Intro to Object-Oriented (

1

• Intro to Object-Oriented (OO) Design

2
OO Design

• Simplified methodology
• 1. Write down detailed description of problem
• 2. Identify all (relevant) nouns and verbs
• 3. From list of nouns, select objects
• 4. Identify data components of each object
• 5. From list of verbs, select operations

3
Object-Oriented Design Example 1

• Problem Statement
• Write a program to input the length and width of
  a rectangle, and calculate and print the
  perimeter and area of the rectangle
• Nouns
• Length, width, rectangle, perimeter, area

4
class Rectangle with Data Members and Operations
5
Object-Oriented Design - Example 2

• An inoperable candy machine has a cash register
  and several dispensers to hold and release items
  sold by the machine
• Lets design the software outline for a machine
  that dispenses 4 items candies, chips, gum, and
  cookies

Dispensers
Cash register
6
Object-Oriented Design Example 2 (continued)

• The program should do the following
• Show the customer the different products sold by
  the candy machine
• Let the customer make the selection
• Show the customer the cost of the item selected
• Accept money from the customer
• Return change
• Release the item that is, make the sale
• Notice the careful thought to nouns verbs. More
  on this shortly
• The dispenser can keep track of the cost of the
  item, number in stock, etc.

7
OO Design - Cash Register Example contd

• We will need a Dispenser class to record info
  about the items we are selling.
• We will design a CashRegister class to record
  how much money was inserted, and how much should
  be returned.
• We will need a CandyMachine class in which we
  will instantiate 4 Dispenser objects, and 1
  CashRegister object.
• Can you think of the fields methods we would
  use for these classes? This is the key step.
  Dont move on until youve spent some time
  thinking about this.

8
OO Design - Cash Register Example contd
9
Implementing Classes and Operations

• Algorithms are used to implement operations
• Construct and implement your own methods
• classes Integer, Double, Character, Long, Float
• Known as wrapper classes
• Provided so that values of primitive data types
  can be treated as objects
• Have limitations (cannot change value stored in
  objects)

10
Wrapper Classes

• A Wrapper is a class that wraps primitive data
  types into corresponding objects.
• While this can be useful at times (for example to
  convert a String into one of the primitive data
  types as we shall see), we still need a basic
  understanding of how they work.

11
Wrapper Classes 1 The Integer class
Consider the following line of code int x x
JOptionPane.showInputDialog(Enter your age
) You ma not realize it, but we have a type
mismatch because the showInputDialog() method
returns a String. As it turns out, this is not
usually a problem because Java is often smart
enough to try and cast an input that looks like
an integer. Still, there is a much better way
to handle things. There is a method called
parseInt() that exists in a class called Integer.
This method accepts a string and if possible,
will convert this string to an integer. The
method then returns that string. Here is how the
code might look String input int age input
JOptionPane.showInputDialog(Enter your age
) age Integer.parseInt( input ) //parseInt
converts input to an int A more efficient way of
writing this code might be int age age
Integer.parseInt( JOptionPane.showInputDialog(Ent
er your age ) ) In this case, the String
returned by the showInputDialog method is
immediately converted to an int.
12
The class Integer
13
The class Integer (continued)
14
The class Integer (continued)
15
An Integer object and an int variable are NOT
the same!
You are familiar with variables of type int.
However, an object of type Integer is NOT the
same. Recall that what we typically call
objects are actually references. Also recall
that references do NOT hold information related
to the state of the object. Instead,a reference
holds only the address of the object.We will
discuss this with some examples
16
The class Integer (continued)
Integer num num new Integer(86)
num is a reference. 1350 is the address of num.
Inside memory location 1350 is the object whose
current state is 86.
17
Auto-boxing and Auto-Unboxing
Now as it turns out, because Integer objects are
meant exclusively to hold int values, Java lets
us take some shortcuts. Consider Integer num
25 Technically this should NOT mean that
Integer holds the int value 25. It SHOULD mean
that the address of the reference num is memory
location 25. However, Java, recognizing what the
Integer class is really all about, does allow us
to assign the integer number 25 to the reference
num. Although we can get away with this, I
hope you recognize that the technically accurate
way of doing this is Integer num new
Integer( 25 ) Similarly, you should recognize
that the statement System.out.println( num )
should output the reference (address) of
num. Instead, this statement will in fact, output
the state (i.e. the integer value) held inside
that reference location. Technically, however,
we should have to say System.out.println(
num.intValue() ) All this being said, feel free
to use the automatic unboxing done by Java. I
do require you to understand however, that this
process is occuring behind the scenes.
18
The class Integer (continued)
int x Integer num num 25
For the most part, this statement is similar to
the statement num new Integer(25) The
expression num 25 (as opposed to
num.setInteger(25) ) is referred to as
autoboxing of the int type
19
The class Integer (continued)
int x Integer num The
statement x num This statement is
equivalent to the statement x num.intValue()
This statement is referred to as auto
unboxing of the int type
20
The class Integer (continued)

• To compare the values of two Integer objects
  (i.e. to see which is greater), you can use the
  method compareTo
• If you want to compare the values of two Integer
  objects for equality, you could use the method
  equals

21
There are other Wrapper classes

• Double
• Long
• Float
• Character

22
Chapter Summary

• Every GUI contains a window
• Various components are added to content pane of
  window
• class JFrame is used to create windows
• JLabel is used to label GUI components and
  display information to user
• JTextFiled is used for input/output
• JButton generates action event
• Action event is sent to action listener

23
Chapter Summary (continued)

• Action listener must have method called
  actionPerformed
• class collection of data members and methods
  associated with those members
• Object-Oriented Design (OOD)
• Starts with a problem statement
• Identifies classes required with nouns in problem
  statement
• Identifies methods required with verbs in problem
  specification