Scribd
Upload
4 views21 pages

Taxiiii

The document discusses key concepts in advanced Java programming including the stack, heap, objects, inheritance, interfaces, and arrays. The stack stores local variables and ends when the scope ends, while the heap is handled explicitly by the user through memory allocation and garbage collection. All objects are created on the heap using the new operator, and can be copied using clone() for a shallow copy or by overriding clone() for a deep copy. Inheritance allows classes to extend others to inherit fields and methods, while interfaces define abstract methods that classes implementing the interface must define. Arrays store consecutive blocks of memory, while vectors can dynamically grow beyond their original size.

Uploaded by

Mayur Bundele
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
4 views21 pages

Taxiiii

The document discusses key concepts in advanced Java programming including the stack, heap, objects, inheritance, interfaces, and arrays. The stack stores local variables and ends when the scope ends, while the heap is handled explicitly by the user through memory allocation and garbage collection. All objects are created on the heap using the new operator, and can be copied using clone() for a shallow copy or by overriding clone() for a deep copy. Inheritance allows classes to extend others to inherit fields and methods, while interfaces define abstract methods that classes implementing the interface must define. Arrays store consecutive blocks of memory, while vectors can dynamically grow beyond their original size.

Uploaded by

Mayur Bundele
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

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

You might also like