Object References a.k.a. variables

1
Object Referencesa.k.a. variables

• Teams of Robots (e.g.)
• Could have 1 robot harvest 6 rows (weve seen
  that)
• Could have 3 robots each harvest 2 rows like
  this
• Harvester botA new Harvester(2,2,,)
• Harvester botB new Harvester(4,2,,)
• Harvester botC new Harvester(6,2,,)
• botA.move() botA.harvestTwoRows()
• botB.move() botB.harvestTwoRows()
• botC.move() botC.harvestTwoRows()

2
Object References

• Could also intersperse the operations like this
• // same instantiations
• botA.move()
• botB.move()
• botC.move()
• botA.harvestTwoRows()
• botB.harvestTwoRows()
• botC.harvestTwoRows()

3
Object References

• Could just use one reference like this
• Harvester bot
• bot new Harvester(2,2,,)
• bot.move()
• bot.harvestTwoRows()
• bot new Harvester(4,2,,)
• bot.move()
• bot.harvestTwoRows()
• bot new Harvester(6,2,,)
• bot.move()
• bot.harvestTwoRows()

a reference
we use assignment to assign a specific object to
a reference
4
Object References - Common Error

• Harvester bobbob.harvestTwoRows()
• Whats wrong with the above?
• NullPointerException
• for now, an error in Java is called an exception
• do you think this error happens at run-time or
  compile-time? why?
• Binky Pointer Video (instructors you can find
  it and other neat cs videos/materials at
  http//cslibrary.stanford.edu - youll want to
  download ahead of time, as it is huge)

5
Object References

• References model whats going on in the real
  world as well
• There are lots of Dave references - but the
  particular object (person) one is referring to
  depends on context and whom one is, in
  particular, referring to at the moment
• Well, these references are all neat and
  everything, but so what? Well, hold on a few more
  slides and youll see the power of using them -
  were headed toward an extremely important OO
  concept called Polymorphism.

6
Polymorphism

• Powerful example
• you are all objects - if I tell all of you to
  takeABreak(), you all will hear the same
  message but will act in different ways (some of
  you will sleep, some will walk out the door and
  eat something, some will try to leave school!,
  some will do work, etc.) - thats polymorphism
• sending the same message to different objects -
  each individual object has a particular way to
  interpret (implement) the message
• so, back to code and a Java/Karel example

7
Overriding move()

• remember MileWalker?
• we named its one method moveMile()
• we could have named the method move() and then
  redefined what move means to a MileWalker.
  Again, were modeling the real world. The concept
  of move is different depending on what type of
  object is moving (think about how a dog, fish,
  bird, etc., move)
• so, since the general concept is the same, we
  often use the same name (it makes coding
  easy/logical) - why would you want to try to
  remember moveMile(), moveLegs(), moveWings(),
  etc. - why not just one identifier for that -
  move()

8
Example

• lets have 3 different types of bots
• MileWalker
• when move() is invoked, moves 1 mile
• DropBeeperAndWalker
• when move() is invoked, always drops a beeper and
  then moves one block forward
• BackwardWalker (sort of the Michael Jackson of
  robots!)
• when move() is invoked, moves one block backward
• for each of these new classes, we will only have
  to write one method, move() - each, however, will
  be implemented differently, and, in addition,
  override the original definition of move()
  inherited from UrRobot --- lets see

9
As always, the Big Picture firsta.k.a. -
Inheritance Hierarchy
UrRobot
10
MileWalker

• public class MileWalker extends UrRobot
• // constructor same as always
• public void move()
• super.move() super.move()
• super.move() super.move()
• super.move() super.move()
• super.move() super.move()

11
DropBeeperAndWalker

• public class DropBeeperAndWalker extends UrRobot
• // constructor same as always
• public void move()
• putBeeper() // inherited instruction still
  serves its purpose
• super.move()

class invariant object always has at least one
beeper for each time move() might be called (AB
topic)
12
BackwardWalker

• You write it!
• In addition to writing this class, write a sample
  Driver that would demonstrate using one robot
  each of type MileWalker, DropBeeperAndWalker, and
  BackwardWalker
• Well pick someone and put it up in 5 minutes

13
Your sample Driver vs. mine

• UrRobot bot
• bot new MileWalker()
• bot.move() // polymorphic move()
• bot new DropBeeperAndWalker()
• bot.move() // polymorphic move()
• bot new BackwardWalker()
• bot.move() // polymorphic move()

14
Polymorphism

• at run-time, the correct implementation is chosen
  depending on what specific object is being
  referenced at that moment in time.

bot
15
Polymorphism - contd

• polymorphism is ubiquitous in OO
• there are many uses and examples of it
• lets now build toward another example of
  polymorphism
• but first, as last time, we need some setup

16
Choreographers

• one object controlling others
• we now want a MoveChoreographer class, which,
  when constructed, is passed 3 friends (robots)
• the MoveChoreographer has one method called,
  moveFriends() which, when invoked, moves each
  friend once
• this Choreographer model of problem solving, by
  the way, can been seen in the general
  contractor analogy we used in the ppt from Ch. 3
  - the general contractor doesnt really do the
  work, she just delegates it to another object(s)

17
MoveChoreographer

• public class MoveChoreographer extends UrRobot
• // constructor on next slide
• // other methods
• private UrRobot delegateA
• private UrRobot delegateB
• private UrRobot delegateC

objects can not only do(behavior) things, they
can also remember(state) things
18
MoveChoreographers constructor

• public MoveChoreographer ( int st, int av,
• Direction dir, int numBeepers,
• UrRobot botA,
• UrRobot botB,
• UrRobot botC )
• super (st, av, dir, numBeepers) // must come
  first in method
• delegateA botA
• delegateB botB
• delegateC botC

instance variables being assigned
19
MoveChoreographers moveFriends()

• public void moveFriends()
• delegateA.move()
• delegateB.move()
• delegateC.move()

20
Sample Client code using a MoveChoreographer

• can you now give some sample client code that
  uses a MoveChoreographer object? (do so now for 5
  minutes)

draw a picture and show the before and after
an example UrRobot bot1 new MileWalker(2, 4,
North, 0) UrRobot bot2 new DropBeeperAndWalker
(2, 5, North, infinity) UrRobot bot3 new
BetterTurner(2, 6, North, 0) MoveChoreographer
chor chor new MoveChoreographer(1, 1, North,
0, bot1, bot2, bot3) chor.moveFriends()
21
examining the constructors reference types

• The statement from the previous slide,
• chor new MoveChoreographer(1, 1, North, 0,
  bot1, bot2, bot3)
• is kind of neat. When someone constructs a
  MoveChoreographer, he can pass any 3 robots in
  any order as long as each one is-A UrRobot or
  extends from a UrRobot. The MoveChoreographer
  only wants to be guaranteed that it can perform a
  move() on any object passed to it - since there
  is a move() in UrRobot, it chose to make its
  parameters of type UrRobot, guaranteeing (to
  itself and the compiler) that it will be able to
  call move() at run-time.The term that describes
  which particular move() will be called at
  run-time is ____________?

22
Abstract classes

• Sometimes we want to do several tasks, but the
  tasks are very similar. How can we build the
  classes to take advantage of the common parts of
  the task and yet distinguish the specific
  differences? Another way to say that is, how can
  we design the inheritance tree so that we dont
  duplicate common code used among sub-classes, yet
  allow sub-classes to have some specific
  differences?
• The answer use an abstract class

23
contrived/simple task to demo the need for an
abstract class
run demo

• Here is a task for a team of robots. We want to
  lay down beepers in a 5-by-4 field. The
  odd-numbered rows have 2 beepers per corner, the
  even have 3. Here is how wed organize that with
  what we currently know

24
BeeperLayers

• On the previous slide, we saw that layBeepers()
  would have the exact same implementation for both
  types of beeper layers - namely
• move() putBeepers()
• move() putBeepers()
• move() putBeepers()
• move() putBeepers()
• move()

discuss why code duplication (a.k.a., copy/paste)
and lack of localization are poor/costly design
patterns
25
BeeperLayers

• At the same time, we saw that putBeepers() would
  have a different implementation in each of the
  subclasses (one puts 2, the other puts 3). So
  here is the new design pattern
• Well extract out an abstract concept of what a
  general beeper layer would look like and put that
  into a class(in this case, an abstract class).
  Methods in the abstract class that would have the
  exact same implementation regardless of the
  subclass will be implemented in the abstract
  class - methods that would have different
  implementations in the subclasses will not be
  implemented in the abstract class, forcing each
  subclass to give its own unique implementation

26
Inheritance Hierarchy
27
Terminology Concepts

• BeeperLayer lisa null
• lisa new TwoRowLayer(1, 3 ,East,
  infinity)lisa.layBeepers()lisa new
  ThreeRowLayer(2, 3, East, infinity)lisa.layBeepe
  rs()lisa new TwoRowLayer(3, 3, East,
  infinity)lisa.layBeepers()lisa new
  ThreeRowLayer(4, 3, East, infinity)lisa.layBeepe
  rs()lisa new TwoRowLayer(5, 3, East,
  infinity)lisa.layBeepers()

making references to the code, the inheritance
tree, or whatever else we just discussed in the
BeeperLayer problem, pick one of these terms and
demonstrate that you know what it means
abstraction, abstract class, abstract method,
polymorphism