Advanced Java Programming

The Stack

 The stack is the place where all local variables

are stored
 a local variable is declared in some scope
 Example
int x; // creates the variable x on the stack
 As soon as the scope ends, all local variables
declared in that scope end
 the variable name and its space are gone
 this happens implicitly – the user has no control
over it
The Heap

 The heap is an area of memory that the user handles

explicitly
 user requests memory through new operator
 java does garbage collection to reclaim unused memory
 A user maintains a handle on memory allocated in the heap
with a reference variable
Creating Objects

 All objects are created on the heap

 A reference to object is stored on the stack
 simply declaring an object does not create it
 automatically set to null
 new operator allocates space on the heap
Creating Objects
 Example
Object obj1 = new Object();
Object obj2;

Object
func1
obj1 = 200 200
obj2 = null

main
x=3

Stack Heap
Assigning Object References
 Reference can be assigned through new operator
 obj2 = new Object();
 Reference can assigned to another reference
 obj2 = obj1;
 WARNING
 when assigning to another reference, both references now refer to the same
object
Assigning Object References
 Example
 Object obj1 = new Object();
 Object obj2 = obj1;

Object
func1
obj1 = 200 200
obj2 = 200

main
x=3

Stack Heap
Simple Class

class Foo implements Cloneable {

private int num;
public void Foo(int num) { this.num =
num; }
public void setNum(int num) { this.num =
num; }
public int getNum() { return num; }
}
Copying an Object
 Want to create and modify copy of object
 remember, simple assignment not enough
Foo f1 = new Foo(5);
Foo f2 = f1; // still only one object – 2 references
f2.setNum(10);
System.out.println(“f1’s num = “ + f1.getNum()); // prints 10
System.out.println(“f2’s num = “ + f2.getNum()); // prints 10

 need to use the clone() method

clone() Method

 To use clone() must implement Cloneable

 Object.clone() is automatically inherited by every class
 by default, it creates a new object and copies all fields
 Example
Foo f1 = new Foo(5);
Foo f2 = f1.clone();
f2.setNum(10);
System.out.println(“f1’s num = “ + f1.getNum()); // prints 5
System.out.println(“f2’s num = “ + f2.getNum()); // prints 10
Shallow Clone
 Only copies the fields
 does not copy what the fields reference
 Doesn’twork well for sophisticated objects
 Example:
Class Foo {
private int [] nums;
public void Foo(int size) { nums = new int[size]; }
…
}

Foo f1 = new Foo(5);

Foo f2 = f1.clone();
Shallow Clone

Foo f1 = new Foo(5);

Foo f2 = f1.clone();
nums = 50
func1
f1 = 200 200
f2 = 100 Array
50
nums = 50

100

Stack Heap
Deep Clone
 Copies fields and what they refer to
 Must reimplement the clone() method
class Foo {
…
public Object clone() {
try {
Foo fobj = (Foo)super.clone(); // copies fields
fobj.nums = (int)nums.clone(); // arrays implement clone
return fobj;
} catch(CloneNotSupportedException e) { }
}
}
Inheritance

 lets one class inherit fields and methods from another class
 use keyword extends to explicitly inherit another classes
public and protected fields/methods
 can only explicitly extend from one class
 all classes implicitly extend the Object class
Inheritance

 overriding a method
 must have the same signature as original
 declaring a method final means future derived classes cannot
override the method
 overloading a method
 method has same name but different signature
 they are actually different methods
Inheritance

 abstract classes and methods

 declaring a class abstract
 must have an abstract method
 class cannot be directly used to create an object
 class must be inherited to be used
 declaring a method abstract
 method must be defined in derived class
Abstract Class

abstract class Pixel {

...
public abstract void refresh();
}

class ColorPixel extends Pixel {

...
public void refresh() {
do some work
}
}

 Note: signature of method in derived class must be

identical to parent declaration of the method
Interface

 basically an abstract class where all methods are abstract

 cannot use an interface to create an object
 class that uses an interface must implement all of the
interfaces methods
 use the implements keyword
 a class can implement more than one interface
Interface

 simple example
class Tester implements Foo, Bar {
...
}
 Foo and Bar are interfaces
 Tester must define all methods declared in Foo and Bar
Array Review

 Consecutive blocks of memory

 Creation: int [] grades = new int[25];
 __.length: holds size of array
 __.clone(): makes copy of array data
 out-of-bounds exception: trying to access data outside of
array bounds generates an exception
 Array size is fixed at creation
Vector Class

 Very similar to an array

 Major difference: vectors can grow beyond original size
 if a certain capacity is exceeded, a new, larger memory region
is allocated for vector
 copy all data to the new area
 See Java documentation on-line for complete details