A quick introduction to Objects & Object-Oriented thinking & design, with a short review of basic programming principles and some simple example code.

1. Objects & OO Thinking
for Java
Prof. Jeff Sonstein
Department of Information Technology
Rochester Institute of Technology
jxsast@rit.edu
http://www.it.rit.edu/~jxs/
Center for the Handheld Web
http://chw.rit.edu/blog/
Mobile Web Best Practices Working Group
http://www.w3.org/2005/MWI/BPWG/Group/

2. What is Object-
Oriented Design?
• Objects are self-contained application
components that work together
• Object-Oriented Design is the art (not
science) of decomposing an application into
some number of objects.
Prof. Jeff Sonstein

3. Why Decompose
Problems?
• Simply put, meaningfully large systems &
problems can be overwhelming to
approach as a whole
• Breaking a big problem into many small
problems is a useful way to manage
complexity
Prof. Jeff Sonstein

4. Why Objects?
• Reuse (A lazy programmer is a good
programmer)
• Encapsulate (that other idiot cannot mess
up what they cannot access directly)
Prof. Jeff Sonstein

5. OO Decomposition
Guidelines
• think in terms of interfaces first
• hide and abstract as much as you can
• use objects in their existing form as much
as you can (composition, not inheritance)
• organize related objects into packages
• program as though there really is a
tomorrow
Prof. Jeff Sonstein

6. Review: Some Key
Programming Concepts
• All computer programs are constructed of
just 2 things
1. data structures
2. and algorithms to manipulate those data
structures
Prof. Jeff Sonstein

7. Data Structures
• are simply containers to hold data
• examples of data structures:
• lists
• queues
• arrays
• etc
Prof. Jeff Sonstein

8. Data Structures:
Example I
The list of ingredients at the top of a recipe
for making a chocolate cake
Prof. Jeff Sonstein

9. Data Structures:
Example II
The queue of patrons waiting to buy movie
tickets
Prof. Jeff Sonstein

10. Algorithms
• are simply instructions on how to manipulate
data structures
• all algorithms are composed of only 3
“control structures”:
1. sequence
2. selection
3. iteration
Prof. Jeff Sonstein

11. Control Structures I:
Sequence
• simply means:
DO this 1st
DO this 2nd
DO this 3rd
[and so on]
Prof. Jeff Sonstein

12. Control Structures II:
Selection
• simply means:
IF some condition is true
THEN do this
ELSE do something else
(note: a “case” or “switch” statement is just a fancy set of IF statements)
Prof. Jeff Sonstein

13. Control Structures III:
Iteration
• “leading test”:
WHILE some condition is true (may never be so)
DO something
• “trailing test”:
REPEAT something (always do at least once)
UNTIL some condition is true
Prof. Jeff Sonstein

14. Data Structures &
Algorithms Example
Data
Structure
Algorithm
Prof. Jeff Sonstein

15. What Can an Object
Contain?
• methods
• variables (data structures)
• initialization code
• and inner classes (really hidden)
Prof. Jeff Sonstein

16. Methods
• constructors
• accessors and mutators
(also known as getters & setters -
getWhatever and setWhatever methods)
• note method overloading (see
java.io.PrintStream.print() methods, for
example)
Prof. Jeff Sonstein

17. And What Can
Methods Contain?
• local variables (data structures)
• and algorithms to manipulate those data
structures
(sound familiar?)
Prof. Jeff Sonstein

18. Method Overloading
Example
Prof. Jeff Sonstein

19. Variables
• things that can change during the running of
a program
• hide them whenever possible (see
discussion of accessors & mutators)
Prof. Jeff Sonstein

20. Initialization
• constructors have the same name as the
class
• constructors say what to do when a new
instance is created
• constructors can call other methods of
their class as well as calling other classes
Prof. Jeff Sonstein

21. Inner Classes
• only visible to this particular instance of
this particular class (revisit information
hiding)
Prof. Jeff Sonstein

22. A Simplified GUI
Example
• testHarness.java - a very simple (and
simplified) example of an easily-modified GUI
test container. Note that it is “smart” enough
to run as either a standalone program or in a
Web browser context.
Prof. Jeff Sonstein

23. import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.util.*;
public class testHarness extends Applet {
private randomNumbers myCurve;
private TextArea myMessages = new TextArea();
private String statusString = "Random Numbers in a Gaussian Distribution";
public testHarness() {
setLayout( new BorderLayout() );
add( myMessages, BorderLayout.CENTER );
add( new Label( statusString ), BorderLayout.SOUTH );
// add( new myButton( myMessages ), BorderLayout.SOUTH );
myCurve = new randomNumbers();
int counter = 1;
for ( Enumeration x = myCurve.getNumbers(); x.hasMoreElements(); ) {
myMessages.append( counter + ":t" + (Double)x.nextElement() + "n" );
counter++;
}
}
public static void main( String[] args ) {
Frame myFrame = new Frame ( "testHarness.java" );
myFrame.setSize( 300, 300 );
myFrame.add( new testHarness() );
myFrame.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent e ) {
System.exit( 0 );
}
} );
myFrame.show();
}
}
Prof. Jeff Sonstein

24. A Simplified Support-
Class Example
• and randomNumbers.java - a very simple
(and simplified) example of an easily-
modified random number generator.
Prof. Jeff Sonstein

25. import java.util.*;
public class randomNumbers {
private static final int MAX_NUMBERS = 100;
private Vector myVector;
public randomNumbers() {
setNumbers();
}
public void setNumbers() {
Random myGenerator = new Random();
myVector = new Vector();
for ( int i = 0; i < MAX_NUMBERS; i++ ) {
myVector.add( new Double( myGenerator.nextGaussian() ) );
}
}
public Enumeration getNumbers() {
return myVector.elements();
}
}
Prof. Jeff Sonstein

26. Review: Object-
Oriented Design
• Objects are self-contained application
components that work together
• Object-Oriented Design is the art (not
science) of decomposing an application into
some number of objects.
Prof. Jeff Sonstein

27. Review: Decomposition
• Simply put, meaningfully large systems &
problems can be overwhelming to
approach as a whole
• Breaking a big problem into many small
problems is a useful way to manage
complexity
Prof. Jeff Sonstein

28. Review: What Good
Programmers Do
• Reuse (A lazy programmer is a good
programmer)
• Encapsulate (that other idiot cannot mess
up what they cannot access directly)
Prof. Jeff Sonstein

29. Some Useful Online
Resources
• JavaDocs: Sun
http://java.sun.com/reference/api/
• Java Programming textbook: Wikibooks
http://en.wikibooks.org/wiki/Java_Programming
• Patterns Book: “Design Patterns: Elements of
Reusable Object-Oriented Software”
http://en.wikipedia.org/wiki/Design_Patterns_(book)
Prof. Jeff Sonstein

30. Objects & OO Thinking
for Java
Prof. Jeff Sonstein
Department of Information Technology
Rochester Institute of Technology
jxsast@rit.edu
http://www.it.rit.edu/~jxs/
Center for the Handheld Web
http://chw.rit.edu/blog/
Mobile Web Best Practices Working Group
http://www.w3.org/2005/MWI/BPWG/Group/