Scribd
Upload
79 views21 pages

Advanced Java Programming: CS 537 - Data Structures and Algorithms

The document provides an overview of key Java programming concepts including the stack, heap, objects, references, inheritance, interfaces, arrays, and the Vector class. It explains that the stack stores local variables and references to objects, while the heap stores objects. It discusses how to create objects, copy objects using clone(), and assign references. It also covers inheritance, abstract classes and methods, interfaces, and exceptions that can occur with arrays.

Uploaded by

happy2009y
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
79 views21 pages

Advanced Java Programming: CS 537 - Data Structures and Algorithms

The document provides an overview of key Java programming concepts including the stack, heap, objects, references, inheritance, interfaces, arrays, and the Vector class. It explains that the stack stores local variables and references to objects, while the heap stores objects. It discusses how to create objects, copy objects using clone(), and assign references. It also covers inheritance, abstract classes and methods, interfaces, and exceptions that can occur with arrays.

Uploaded by

happy2009y
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 21

Advanced Java Programming

CS 537 Data Structures and Algorithms

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;

func1
obj1 = 200
obj2 = null

Object
200

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;

func1
obj1 = 200
obj2 = 200

Object
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(f1s num = + f1.getNum()); // prints 10
System.out.println(f2s 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(f1s num = + f1.getNum()); // prints 5
System.out.println(f2s num = + f2.getNum()); // prints 10

Shallow Clone
Only copies the fields
does not copy what the fields reference

Doesnt work 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();

func1
f1 = 200
f2 = 100

nums = 50
200
Array
nums = 50
100

Stack

Heap

50

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

You might also like