University of Pittsburgh Computer Science

1
Week 2 Introduction

• Welcome to those who were not here last week
• Last week we discussed
• Computer hardware and software
• Programming languages
• Machine language
• High-level languages
• Features of high-level languages
• Variables (single and arrays)
• Operations on variables

2
Week 2 Introduction

• Control structures
• Example programs using a Stack type
• Push on the top
• Pop from the top
• We finished the implementation

3
Week 2 Introduction

• How can we improve our HLLs?

• Complex programs can get HUGE
• Millions of lines of code
• This can lead to some problems

• The human mind works best when a problem is not
  too large
• Ex. SSN, phone numbers, SIMON, shopping lists

• Many large projects require a team of programmers
• How to divide the work, check the results?

• Programs' specs sometime change
• How will change affect the rest of the code?

• I may have to do the same thing in different
  places
• Why rewrite the code? (ex. walk the dog)

4
Week 2 Subprograms

• Solution break our programs into SUBPROGRAMS

• A group of declarations and instructions that
  functions similarly to a program, but that cannot
  run by itself

• How do subprograms work?

• We DECLARE them somewhere in our code

• We CALL them when we want them to execute

5
Week 2 Subprograms

• When a subprogram is called
• The code for the subprogram executes
• This may be in a different place than the main
  program code

• When a subprogram finishes
• The main program resumes at the next instruction
  after the subprogram call

6
Week 2 Subprograms

• Real life example

Let's see what I need to do today...
Feed the cat
Water the garden
Play tennis
Fix the sidewalk
Water ski
Feed the cat
7
Week 2 Subprograms

• What does each of these really mean?

• Water the garden
• Unwind hose
• Turn on water
• Spray until wet
• Turn off water
• Wind up hose

• Feed the cat
• Open food
• Put some into dish
• Refill water
• Reseal food

8
Week 2 Subprograms

• What we are doing is REFINING our tasks
• At the highest level we only are concerned with
  what the tasks are
• When doing the tasks we need to know each step
  involved

• We do the same thing with programs
• From main program we just need to know the
  subprograms called
• Within the subprograms we have the precise
  instructions that need to execute

9
Week 2 Subprograms

• Let's look at a simple example
• Download, compile and run Seuss1.java from the
  Exercises page

10
Week 2 Parameters

• Usually we need our subprograms to communicate
  with the main program

• Ex. Building a house
• General contractor has subcontractors to do the
  electrical, plumbing, masonry, etc.

• General contractor needs to talk to the
  subcontractors regarding scheduling, any
  problems, etc.

• Something learned from one subcontractor may
  affect how another subcontractor works
• Pipes have been moved
• Subfloor is not installed yet

• We accomplish this communication in programs with
  PARAMETERS

11
Week 2 Parameters

• Parameters
• We can think of these as messages that are passed
  from the main to the subs (and possibly back to
  the main)
• When a subprogram is called, the parameters
  passed to the subprogram are called ARGUMENTS
• The subprogram uses these to help do it's job
• See Seuss2.java
• Download from Exercises page
• Compile and run it
• Add another verse to it

12
Week 2 How Subprograms Work

• When a subprogram is called
• Arguments are passed to it
• Data for it is pushed onto the RUN-TIME STACK
• Stack works just as we discussed last week
• Code for subprogram starts to execute

• Why do we need a stack for the data?
• A subprogram can call another subprogram
• We need to keep track of the data for each
  subprogram that has been called
• When "top" subprogram finishes, the next one down
  (new top) should resume

13
Week 2 Recursion

• The run-time stack also allows us to use
  RECURSION in our programs
• A subprogram calls itself
• Quite mathematical in nature -- some common math
  problems can be defined recursively
• N!

• Common solution N! N x (N-1) x (N-2) x 1

• Recursive solution
• N! N x (N-1)! when N 0 recursive case
• N! 1 when N 0 base case

14
Week 2 Recursion

• NM

• Common solution NM N x N x N x x N - M times

• Recursive solution
• NM N x N(M-1) when M 0 recursive case
• NM 1 when M 0 base case

• Concept seems difficult
• But can be useful
• Some famous algorithms are defined recursively
• Sorting (QuickSort, MergeSort)
• Searching (Binary Search)
• Image processing (Fast-Fourier Transform)

15
Week 2 Recursion

• Let's look at another famous example
• Not very useful, but famous anyway
• Good example of a problem that is VERY DIFFICULT
  to solve WITHOUT recursion

• Towers of Hanoi problem
• We have 3 towers
• On first tower we have disks of decreasing size
• Goal is to get all disks onto last tower, but
• We can only move one disk at a time
• We can never put a larger disk on top of a
  smaller one

16
Week 2 Recursion

• Download Hanoi.java from Web site
• Compile it and then run it
• First try playing it yourself for a while
• Start with only 3 or 4 disks, then try more
• Then let the computer solve it for you
• You can go up to 10 disks
• Adjust the delay so you can see each step for
  just a few disks (make it 1000 or more)
• For more disks make the delay small (50 or less)
  so the demo will finish in a reasonable amount of
  time
• When you are done playing, we will look at the
  code for a bit

17
Week 2 Subprogram Summary

• In summary, subprograms give us
• Smaller code pieces
• Each piece not so complex

• Relatively independent pieces
• Easier to debug them
• Easier to add new pieces and to change the old
  ones without "breaking" the rest of them
• Easier to teams to work on different pieces

• Reusable pieces
• I can call a subprogram many times from the same
  program
• I can use the same subprogram in many programs

18
Week 2 Subprogram Summary

• Procedural abstraction
• What is that?
• Idea I can use a subprogram without necessarily
  knowing the details of how it works
• I should probably know its input, output and its
  general purpose, but that's all

• Ex y sqrt(x)
• Calculate the square root
• I know what that is
• I know it is a real number
• I don't care how the computer actually does it!
• Unless I was the one who had to write the code

19
Week 2 Data Abstraction and OOP

• We can expand this idea to include DATA
  ABSTRACTION
• I don't need to know the implementation details
  of a data type in order to use it

• Ex. Stack from last week
• If we know what push and pop MEAN, we don't
  really have to know how they are implemented
• In fact a Stack can be implemented in various
  ways
• We only saw one of them last week
• No matter how it is implemented, it still
  functions as a Stack in the same way

• Data abstraction is one important part of
  OBJECT-ORIENTED PROGRAMMING

20
Week 2 Object-Oriented Programming

• OOP components
• Encapsulation/Data Abstraction
• The DATA and OPERATIONS for a type are
  encapsulated together into an OBJECT

• Ex Stack
• Operations Push, Pop (and others)
• Data array of integers (or other data)

• Ex Person
• Operations Walk, talk, eat, sleep
• Data body, name, address, ssn

• Look at Hanoi.java again
• class Tower

21
Week 2 Object-Oriented Programming

• Inheritance
• Allows new classes to get all of the attributes
  of previously defined classes
• Allows related classes to be accessed in a
  consistent way

• Animal

• Mammal

22
Week 2 Object-Oriented Programming

• Polymorphism
• Allows the same operation name to be defined
  differently for different classes

• Animal

• Mammal

move()
move()
move()
move()
move()
23
Week 2 Object-Oriented Programming

• We may look at object-oriented programming in
  more detail in a lab session later

24
Week 2 Summary

• This week we discussed
• Reasons for using subprograms
• How subprograms work
• Calling a subprogram
• Parameters
• Recursion
• Wacky!
• Object-oriented Programming
• Encapsulation
• Inheritance
• Polymorphism