1. class Box { Box is new data type of the class. double width;
//This progam includes a method inside the box class.
class Box { Box is new data type of the class.
double width;
double height; Box is used to declare objects for this type
double depth; Class declaration only creates a template, not object
//display volume a box This code does not cause any objects of type Box
void volume ( ) {
System.out.print (“Volume is”);
System.out.println(width*height*depth);
} }
class BoxDemo3 {
public static void main (String args [ ]) {
Box mybox1 = new Box( ); After this statement executes, mybox1
Box mybox2 = new Box ( ); and mybox2 will be instances of Box
// assign values to mybox1’s instance variables
mybox1.width=10;
mybox1.height=20;
mybox1.depth=15;
//assign different values to mybox2’ s instance variables
mybox2.width=3;
mybox2.height=6;
mybox2.depth=9;
//display volume of first and second boxes
mybox1.volume(); Invokes volume( ) method on mybox1
mybox2.volume(); Invokes volume ( ) method on mybox1
} } volume () method is called relative to the mybox1 or mybox2 object,

2. Calling a Method
When mybox1.volume( ) method is executed Java run time system transfers control to the code defined inside volume( ).
After the statements inside volume ( ) have executed,
control is returned to the volume ( ) calling routine, and
execution resumes with the line of code following that call.
Instance variables width, height, depth inside volume() method are referred to directly,
without explicit reference to an object
without use of the dot operator.

3. Important:
A method is always invoked relative to some object of its class
Once this invocation has occurred, the object is known.
Thus, within this method, there is no need to specify the object a second time.
This means that width, height, and depth inside volume() implicitly refer to the copies of those variables found in the object that invokes volume().
As summary:
When instance variable is accessed by code that a part of the same class as the instance variable, that variable can be referred to directly.
On the contrary:
When the instance variable is accessed by code, that is not part of the class in which the instance variable is defined,
it must be done through an object, by use of the dot operator.

4. Adding a Method that Takes Parameters
While some methods don’t need parameters, most do.
Parameters allow a method to be generalized.
A parameterized method can operate on a variety of data and/or be used in a number of slightly different situations.
int square () {
return 10*10; }
If we modify the method, it takes a parameter
int square (int i)
return i*i;
Square is now a general-purpose method that can compute the square of any integer value.
Now square will return the square of whatever value it is called with.
int x,y;
x=square(5); // x equals 25
x=square (9); // x equals 81
y=2;
x=square (y); // x equals 4

5. The Previous Program Using a Parameterized Method
class Box {
double width;
double height;
double depth;
//compute and return a value
double volume ( ) {
return width*height*depth; }
//sets dimensions of box
void setDim(double w, double h, double d) {
width = w; A better approach to setting the dimensions of a box is to
height =h; create a method that takes the dimension of a box in its
depth =d; parameters and sets each instance variable appropriately
class BoxDemo4 {
public static void main (String args [ ]) {
Box mybox1 = new Box ( );
Box mybox2 = new Box ( );
double vol;
//initialize each box
mybox1.setDim (10,20,15);
mybox2.setDim( 3,6,9);
//get volume each box
vol =mybox1.volume();
System.out.println (“Volume is” + vol);
vol =mybox2.volume();

6. Constructors
Objects are allocated by specifying the new operator with an object constructor
A constructor is a special method with the same name as its class and return no type, it is not void even.
Because the implicit return type of a class constructor is the class type itself
It’s called when a new class instance is created.
It initializes all of the variables in a class each time an instance is created.
Once defined, it is automatically called after the object is created, before new operator completes.
We can rework the Box example so that the dimensions of a box are automatically initialized when an object is constructed. To do so, replace setDim() with a constructor.

7. Box uses a constructor to initialize the dimensions of a box
class Box {
double width;
double height;
double depth;
//This is the constructor for Box.
Box() {
System.out.println (“Constructing Box”);
width = 10;
height =10;
depth =10; }
//compute and returm volume
double volume ( ) {
return width*height*depth;
} }
class BoxDemo5 {
public static void main (String args [ ]) {
// declare, allocate, and initialize Box objects
Box mybox1 = new Box ( ) ; mybox1 and mybox2 were initialized by the Box()
Box mybox2 = new Box ( ) ; constructor when they were created.
double vol; Since the constructor gives all boxes the same
//get volume each box dimensions, both mybox1 and mybox2 will have
vol =mybox1.volume() ; same value as follows:
System.out.println (“Volume is” + vol) ;
vol =mybox2.volume(); Constructing Box The println( ) statement inside Box()
System.out.println (“Volume is” + vol) ; Constructing Box is for sake of illustration only. Most
} Volume is Most constructor functions will not
} Volume is display anything.

8. Box uses a parameterized constructor to initialize the dimensions of a box
class Box ( ) {
double width;
double height;
double depth;
//This is the constructor for Box.
Box(double w, double h, double d) { We construct the Box objects of various
width = w; dimensions by adding parameters to constructor
height =h;
depth =d; }
//compute and returm volume
double volume ( ) {
return width*height*depth;
} }
class BoxDemo6 {
public static void main (String args [ ]) {
// declare, allocate, and initialize Box objects
Box mybox1 = new Box (10,20,15 ) ; The values 10,25,and 15 are passed to the
Box mybox2 = new Box (3,6,9 ) ; Box() constructor when new creates object
double vol; Thus mybox1’s copy of width, height, and depth will
//get volume each box contain the values 10,20,and 25 respectively
vol =mybox1.volume() ;
System.out.println (“Volume is” + vol) ;
vol =mybox2.volume(); The output from this program is:
} Volume is
} Volume is 162.0

9. The this Keyword
Sometimes a method will need to refer to the object that invoked it.
To allow this, java defines the this keyword.
this can be used inside any method to refer to the current object.
That is, this is always a reference to the object on which the method was invoked.
We can use this anywhere a reference to an object of the current class’ type is permitted.
//A redundant use of this.
Box (double w, double h, double d) {
this.width= w;
this.height= h;
this.depth=d; }
Although the use of this is redundant above , it is perfectly
correct.

10. Instance and Local Variables
Instance Variables are declared inside the braces of the class definition, but not inside any particular method in that class.
Because they belong to entire class, and copies of them appear in any of the methods inside their class.
They set to a default value 0 (for numeric types), false (for boolean variables , or null (for class type variables) unless they are initialized
Instance variable differ from method arguments and other variables that are declared inside a single method. These variables are called local variables including formal parameters to methods, which overlap with names of class’ instance variables.
Local variables are effectively private variables that can be seen only by code inside the method.
Java does not initialize local variables, so the values must be assigned by the user.
Local variables live only as long as the method is executing and then they disappear.
Each time the method is invokes, its local variables are created and must be assigned values

11. Instance Variable Hiding
When a local variable has the same name as an instance variable, the local variable hides the instance variables.
This is why width, height, and depth were not used as the names of the parameters to the Box() constructor inside the Box class in the previous example.
If they had been, then width would have referred to the formal parameter, hiding the instance variable width.
It is usually easier to use different names to the problem
Moreover, this lets us refer directly to the object
So we can use this to resolve any name space collisions that might occur between instance and local variables.
box (double width, double height, double depth) {
this.width = width;
this.height= height;
this.depth= depth; }

12. Garbage Collection
Objects are dynamically allocated by using new operator.
In C we don’t have to do anything to get rid of objects
In C++ , dynamically allocated objects are manually released by use of a delete operator.
Java runtime system uses a garbage collection mechanism to deal with objects no longer in user.
The garbage collector sweeps up objects not referenced by any variables and removes them from memory.
Garbage collection is one of the most important features of Java.
It frees us from the error prone task of having to worry about details memory allocation and deallocation.

13. The finalize () Method It is a reserved method name
finalize () method is called when an object is no longer being used, i.e. when there are no further references to it
To add a finalizer method to a class, we simply define the finalize () method.
The Java run time calls that method
protected void finalize() {
//finalization code here }
The keyword protected is a specifier that prevents access to this method by code defined outside its class
It is important to understand that finalize() is only called just prior to garbage collection.
This means that we cannot know when the finalize() method will be executed.

14. The difference of finalize() method with a destructor in C++
C++ allows us to define a destructor for a class, which is called when an object goes out of scope.
Java does not support this idea or provide for destructors.
The finalize method only approximates the function of a destructor.

15. Summarizing the Encapsulation Achieved by Java
By creating a class, we create a new data type
Defining both the nature of data being manipulated and the routines used to manipulate it.
Methods define a consistent and controlled interface to class’s data
A class is like a data engine
No knowledge of what goes on inside the engine is required to use the engine through its controls
The details are hidden, its inner workings can be changed as needed
As long as the code uses the class through its methods, internal details can change without causing side effects outside the class.

16. A Stack Class to Summarize the Encapsulation Achieved by Java
Stack is one of the classic examples of encapsulation.
Stores data using first in, last out ordering.
The first plate (like a stack of plates on a table) put down on the table is the last plate to be used.
Stacks are controlled through two operations called push and pop.
To put an item on top of the stack, we use push
To take an item off the stack we use pop.
Next slide shows the implementation a stack defining an integer stack that can hold 10 integers

17. class Stack { The stack class defines two data items and three methods.
int stck [ ] = new int [10]; The stack of integers is held by the array stck. This array is
int tos; indexed by the variable tos, which always contains the index
of the top of the stack
//Initialize top-of- stack
Stack () { The Stack constructor initializes tos to -1, which indicates
tos = -1; an empty stack }
//Push an item onto the stack
void push (int item) { The method push puts an item on the stack
if( tos == 9)
System.out.println (“Stack is full”);
else
stck [++tos] = item;
//Pop an item from the stack
int pop() { To retrieve an item, call pop()
if (tos < 0) {
System.out.println (“Stack underflow”); Since access to the stack is through
return 0; push() and pop(), the fact that the stack
} is held is actually not relevant to using
else stack. Stack can be held in a more
return stck [tos---]; complicated data structure., such as a
linked list

18. The class TestStack demonstrates the Stack class.
It creates two integer stacks, pushes some values onto each , then pops them off
class TextStack{
public static void main (String args[ ] ) {
Stack mystack1= new Stack( );
Stack mystack2 = new Stack( );
//push some numbers onto the stack
for ( int i =0; i<10; i++) mystack1.push(i);
for ( int i =10; i<20; i++) mystack2.push(i);
//pop those numbers off the stack
System.out.println(“Stack mystack1:”);
for (int i=0; i<10; i++)
System.out.println ( mystack1.pop());
System.out.println(“Stack mystack2:”);
System.out.println (mystack2.pop());
} }

19. Program generates the following output
C:\JBUILDER8\JDK1.4\bin\javaw -classpath "C:\WINDOWS\jbproject\TextStack\classes;C:\JBUILDER8\JDK1.4\JRE\lib\rt.jar;C:\JBUILDER8\JDK1.4\JRE\lib\i18n.jar;C:\JBUILDER8\JDK1.4\JRE\lib\sunrsasign.jar;C:\JBUILDER8\JDK1.4\JRE\lib\jsse.jar;C:\JBUILDER8\JDK1.4\JRE\lib\jce.jar;C:\JBUILDER8\JDK1.4\JRE\lib\charsets.jar;C:\JBUILDER8\JDK1.4\JRE\classes;C:\JBUILDER8\jdk1.4\lib\tools.jar"
textstack.TextStack
Stack mystack1: 9 8 7 6 5 4 3 2 1
Stack mystack2: 19 18 17 16 15 14 13 12 11 10
As we can see, the contents of each stack are separate.

20. Second part of the lesson on 24th October

21. Language Fundamentals I
Identifiers are names of variables, functions, classes etc.
The name used as an identifier must follow the following rules in Java technology.
Each character is either a digit, letter, underscore(_) or currency symbol ($,¢, £ or ¥)
First character cannot be a digit.
The identifier name must not be a reserved word.

22. Language Fundamentals II
A keyword or reserved word in Java technology has special meaning and cannot be used as a user defined identifier.
It is important to understand that Java language is case-sensitive. So even though super is a keyword, Super is not.
All the Java technology keywords are in lower case
The list of keywords in Java technology is given below:
abstract
boolean
break
byte
case
catch
char
class
const
continue
default do
double
else
extends
final
finally
float
for
goto if
implements
import
Instance of
int
interface
long
native
new
null
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while

23. Language Fundamentals III
A literal in Java technology denotes a constant value.
For example;
0 is an integer literal, and 'c' is a character literal.
The reserved literals true and false are used to represent boolean literals.
"This is a string" is a string literal.
Integer literals can also be specified as octal (base 8), or hexadecimal (base 16).
Octal and hexadecimal have 0 and 0x prefix respectively.
So 03 and 0x3 are representation of integer three in octal and hexa-decimal respectively.

24. Language Fundamentals IV
Java technology supports three type of comments:
A single line comment starting with //
A multi-line comment enclosed between
/* and */
A documentation or javadoc comment is enclosed between /** and */.
These comments can be used to generate HTML documents using the javadoc utility, which is part of Java language.

25. Language Fundamentals V
Java technology supports the following primitive types:
boolean (for representing true or false),
a character type called char,
four integer types (byte, short, int and long)
two floating point types (float and double)
Data types
Width (in bytes)
Minimum value
Maximum Value
byte 1
-27
27 - 1
short 2
-215
215-1
int 4
-231
long 8
-263
char
0x0
0xffff
float
e-45
e+38
double
e-324
e+308

26. Language Fundamentals VI
Corresponding to all the primitive type there is a wrapper class defined.
These classes provide useful methods for manipulating primitive data values and objects.
Data types
Wrapper class
int
Integer
short
Short
long
Long
byte
Byte
char
Character
float
Float
double
Double

27. Language Fundamentals VII
Instance variables (data members of a class) and static variables are initialized to default values.
Local variables (i.e. variables defined in blocks or inside member functions) are not initialized to default values.
Local variables must be explicitly initialized before they are used.
If local variables are used before initialization, compilation error gets generated.
The defaults for static and instance variables are given in the table below.

28. Language Fundamentals VIII
The defaults for static and instance variables are given in the table below:
Data types
Default Values
boolean
false
char
'\u0000'
Integer types (byte, short, int, long)
Floating types (float, double)
0.0F or 0.0 D
Object References
null
public static void main (String args []) {
int i;
System.out.println(i); }
Printing of i generates a compilation error, because local variable i is used before being initialized. The initialization of instance and static variables is an important concept both for understanding of Java.