From Theory to Practice 2

1
From Theory to Practice 2
OOP 2006
2
Overview

• Performance issues
• Preparing classes for inheritance
• Memory management and release of obsolete object
  references
• The sources for this lecture
• Effective Java by Joshua Bloch
• The book contains many rules of thumbfor writing
  a code that is clear, correct,robust and
  reuseable
• Most code samples are taken from
  http//java.sun.com/docs/books/effective/
• About garbage collectionhttp//java.sun.com/deve
  loper/technicalArticles/ALT/RefObj/

3
Preparing Classes For Inheritance

• Design and document for inheritance or else
  prohibit it.
• What does it mean?
• Document precisely the effect of overriding any
  method
• Choose protected methods judiciously
• Constructors and clone must not involve
  overridable methods
• Special measures should be taken when
  implementing Serializable objects

4
Documentation
remove public boolean remove(Object o)
Removes a single instance of the specified
element from this collection, if it is present
(optional operation). More formally, removes an
element e such that (onull ? enull
o.equals(e)), if the collection contains one or
more such elements. Returns true if the
collection contained the specified element (or
equivalently, if the collection changed as a
result of the call).This implementation iterates
over the collection looking for the specified
element. If it finds the element, it removes the
element from the collection using the iterator's
remove method. Note that this implementation
throws an UnsupportedOperationException if the
iterator returned by this collection's iterator
method does not implement the remove method and
this collection contains the specified object.
A description of the effect of overriding a
method in AbstractCollection
5
Choosing Protected Methods

• Consider the API of abstractList
• The following method is called by clear
• Allows efficient implementation of clear in
  inherited class

List subList(int fromIndex, int toIndex) Returns
a view of the portion of this list between
fromIndex, inclusive, and toIndex,
exclusive. void clear() Removes all of the
elements from this collection (optional
operation).
protected void removeRange(int fromIndex,
int toIndex) Removes from this list all of the
elements whose index is between fromIndex,
inclusive, and toIndex, exclusive.
6
Constructors

• What happens if the constructor invokes
  overridable method?

public class Super // Broken - constructor
invokes overridable method public Super()
m() public void m()
7
Constructors
final class Sub extends Super // Blank
final, set by constructor private final Date
date Sub() date new Date()
// Overrides Super.m, invoked by the
constructor Super() public void m()
System.out.println(date) public static
void main(String args) Sub s new
Sub() s.m()
The program prints null
8
Memory Management in Java

• The memory in java is handled in two main
  structures
• Program execution stack contains the memory
  required by method invocation
• The memory heap contains the memory required by
  objects in the program
• The new command allocates memory for an object
  and activates its constructor

9
Releasing Unused Objects

• Memory release of unreferenced objects is handled
  using garbage collection
• The garbage collector
• Identify objects that are no-longer in use
• Recycle memory occupied by such objects
• An object is in use if it can be accessed or
  reached by the program in its current state
• In order to define a reachable object we first
  define the root set of references

10
The Root Set and Reachable Objects

• The root set of references includes
• References to objects in active methods of the
  program
• Method arguments
• Local variables
• Static reference variables
• References reiterated through the Java Native
  Interface (JNI)
• An object is reachable if
• It is referenced by a reference from the root set
• It is referenced by another reachable object

11
The Root Set and Reachable Objects
Java Heap
Unreachable objects (garbage)
Root set of references
Reachable objects
12
Advantage of Garbage collected Heap

• In programming languages such as C and C, the
  programmer manages memory allocation and release
• In Java, the programmer does not have to deal
  with memory allocation
• But special care should be taken to avoid memory
  leaks where not-used objects still occupy
  memory

13
Example Stack Implementation
public class Stack private Object
elements private int size 0 public
Stack(int initialCapacity)
this.elements new ObjectinitialCapacity
public void push(Object e)
ensureCapacity() elementssize e
private void ensureCapacity()
if (elements.length size)
Object oldElements elements
elements new Object2 elements.length 1
System.arraycopy(oldElements, 0, elements,
0, size)
14
Stack Implementation - continue
// Can you spot the memory leak? public Object
pop() if (size0) throw
new EmptyStackException() Object result
elements--size return result

• If the stack shrinks, objects that were popped of
  the stack will not be garbage collected
• Memory leak potential consequences
• Reduced performance due to paging or increased
  garbage collection activity
• OutOfMemoryError

15
Solution
public Object pop() if (size0)
throw new EmptyStackException()
Object result elements--size //
Eliminate obsolete reference
elementssize null return result

16
Correct Memory handling

• Memory leaks are hard to detect and resolved
  (there are specialized tools for that)
• Null out object references in classes that manage
  their own memory
• Special care should also be taken for caches
• Do not null out every object finishing its role
• References of local variables fall out of scope
• Variable reuse releases the previous referenced
  objects
• Define each variable in the narrowest possible
  score (There are other good reasons to do it,
  what are they?)