Object Oriented Programming

1
Object Oriented Programming

• Lecture 4
• Refactoring, An Applet Example, Idiom - Animation
  applets, Introduction to the Laboratorial
  exercise
• www2.hh.se/staff/jebe/oop2005/

2
Last time

• Definition of Design Patterns
• The Singleton pattern
• The Iterator/Enumeration Pattern
• The Collections Framework
• Data structures, Iterator, Enumeration
• Abstract Coupling
• Explanation and definition of...

3
Shadowing of variables

• Public class
• int myVariable
• ....
• public doStuff(int test)
• int myVariable
• myVariable test
• this.MyVariable test
• Inner scope myVariable shadows the outer scope
  myVariable

global scope
local scope
4
Design rule using Shadowing

• In general - avoid using identical names for
  variables
• For critical variables in sections where
  something unexpected might happen that would
  leave variables in an inconsistent state
• An example could
• Parallel tasks in multi threaded environments
  accessing a global variable
• Unexpected exception
• Otherwise Shadowing should be avoided
• Should not be needed in properly written programs

5
Generics

• Generics is a new feature in java 1.5
• Avoids the need for type casts when working with
  collections
• Usually the programmer knows what type is
  contained in a collection
• Benefits
• Type checking can be done at compile time and
  errors avoided during run time
• Reduces type casting clutter in the code
• Lets see an example...

6
Refactoring

• Refactoring is a technique that can be used to
  collect identical parts into a generic component
• What is a generic component?
• Classes with general conent that can be extended,
  adapted and reused in different programs
• Can be reused without having to modify the
  current source code

7
Refactoring of methods

• Class ComputeThings
• public void computeMany1()
• anything()
• compute1()
• compute2()
• compute3()
• public void computeMany2()
• something()
• compute1()
• compute2()
• compute3()

These parts are similar....
8
Refactoring of methods

• Class computeThings
• public void computeMany1()
• anything()
• computeAlot()
• public void computeMany2()
• something()
• computeAlot()
• public void computeAlot()
• compute1()
• compute2()
• compute3()

9
Refactoring of methods

• Benefits with method refactoring
• Reduces lines of written code
• Changes can be done more safely without having to
  do the same changes at several places

10
Refactoring by Inheritance

• Class computeStuff1
• superCompute1()
• compute1()
• compute2()
• compute3()
• ....

• Class computeStuff2
• somethingElse()
• compute1()
• compute2()
• compute3()
• ...

Both classes uses identical code sections
11
Refactoring by Inheritance

• Class ComputeStuff1 extends Common
• ...
• superCompute1()
• super.computeAlot()
• ....
• Class ComputeStuff2 extends Common
• ...
• somethingElse()
• super.computeAlot()
• ...

• Class Common
• ...
• computeAlot()
• compute1()
• compute2()
• compute3()
• ...

12
Refactoring by Delegation

• Instead of inheriting factorized code
• Let the object that collects the commonly
  recurring code be separate
• Can be accessed by
• A reference to the object
• Declaring the methods static
• Example The classes Sorting and Helpers in the
  laboratiorial exercise

13
Refactoring by Delegation

• Class ComputeStuff1
• Compute compVar
• superCompute1()
• compVar.computeAlot()
• ....
• Class ComputeStuff2
• ...
• somethingElse()
• compVar.computeAlot()
• ...

• Class Compute
• ...
• computeAlot()
• compute1()
• compute2()
• compute3()
• ...

14
Support in Netbeans

• Refactor Classes and Interfaces
• Renames the class and updates all references in
  project to that class
• Encapsulation of fields
• Create accessors and mutators (setters and
  getters in Netbeans)
• updates all references to that field or method

15
The Applets Design Pattern

• Java applets can be embedded in web pages, they
  are not standalone applications
• Applets are downloaded from a web server and
  executed on the client in a web browser or
  appletviewer
• Applets must extend the Applet class
• Can be found in java.applet package

16
Interaction between the context and applet

• An applet interacts with the context according to
  a contractual interface
• Init() initialize the applet when it is
  initially loaded
• Start() activates the applet and is invoked
  when entering the webpage
• Stop() deactivates the applet
• Destroy() - destroys the applet when the webpage
  is discarded

17
Simple animation applet

• The applet displays the current time
• HHMMSS
• In order draw on the screen we must overload the
  paint() method
• Requires a Thread to control the Animation
• Problem We cant extend both Applet and Thread...

18
The Runnable Interface

• The Solution Java provides the Runnable
  Interface that is implemented by a class that
  should run in a Thread
• Classes that implements Runnable interface can
  pass itself as argument to the Thread()
  constructor
• We need to define the run() method that is
  invoked when starting the Thread

19
The start() method

• public void start()
• if(clockThread ! null)
• clockThread new Thread(this)
• clockThread.start()
• Public void stop()
• clockThread null

Calls run()!
Kill the Thread!
20
Controlling the Animation -the run() method

• public void run()
• while(Thread.currentThread() clockThread)
• repaint()
• try
• Thread.currentThread().sleep(1000)
• catch(InterruptedException e)

Calls paint() to draw the time on the screen
Sleep 1 second before redrawing
21
Drawing the time on screen- the paint() method

• Public void paint(graphics g)
• ...
• g.setFont(font)
• g.setColor(color)
• g.drawString(hour minute
  second)

22
Idiom Animation Applet

• An Idiom How we can program a template that can
  be reused for a recurring problem
• It should be possible to customize and adapt for
  a specific problem
• Commonly, applets produce some graphical output
  that changes without interaction from the user
  (animation)
• Using the Animation Applet Idiom, we can extend
  AnimationApplet and just redefine the paint method

23
Double buffering

• If painting directly on the screen, it will
  flicker
• Double buffering can be used to solve this
  problem
• Double buffering means that we first invisibly
  draw each part of the screen in the background
  (memory)
• Then this picture can be drawn entirely at once

24
Double buffering

• When calling repaint() it will in turn call the
  update() method
• update() will clear the screen using the
  background color and call the paint method
  paint(Graphics g)
• Solution To avoid the the flicker, we simply
  need to override the update method!
• Instead of clearing, let update() paint the
  double buffered image!

25
A Generic Double buffered Animation Applet

• What do we need to do?
• We need to create a background image.
• We need to override the update() method.
• We need a method to do the drawing in the
  background image.
• It seem very similar to the Animation Applet
• In fact, we can extend and reuse the Animation
  Applet code!

26
DoubleBuffered Animation Applet Refactoring by
Inheritance

• Public class abstract DBAnimationApplet extends
  AnimationApplet
• ...
• Graphics backGraphics
• Image backImage
• Dimension dim
• Boolean doubleBuffered
• ...

27
The init() method

• Public final void init()
• dim getSize()
• backImage new Image(dim.width, dim.height)
• backGraphics backImage.getGraphics()
• initAnimator()
• Protected void initAnimator()

28
The update() method

• ...
• Public final void update(Graphics g)
• if(doubleBuffered)
• paintFrame(backGraphics)
• g.drawImage(backImage,0,0,this)
• else
• super.update()
• Public void paint(Graphics g)
• paintFrame(g)

29
The constructors

• Protected DBAnimationApplet(boolean db)
• this.doubleBuffered db
• Protected DBAnimationApplet()
• this.doubleBuffered true

30
How do we use the DoubleBuffered Animation Applet

• Extend the DBAnimationApplet
• Use the appropriate constructor to choose
  doublebuffer/not doublebuffer
• Define the abstract paintFrame() method
• ...and that is it