Transcript Box()

//This progam includes a method inside the box class.
class Box {
double width;
double height;
double depth;
//display volume a box
Box is new data type of the class.
Box is used to declare objects for this type
Class declaration only creates a template, not object
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( );
Box mybox2 = new Box ( );
After this statement executes, mybox1
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,
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.
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
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
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();
System.out.println (“Volume is” + vol);
}
}
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.
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 ( ) ;
Box mybox2 = new Box ( ) ;
double vol;
//get volume each box
vol =mybox1.volume() ;
System.out.println (“Volume is” + vol) ;
vol =mybox2.volume();
System.out.println (“Volume is” + vol) ;
}
}
mybox1 and mybox2 were initialized by the Box()
constructor when they were created.
Since the constructor gives all boxes the same
dimensions, both mybox1 and mybox2 will have
same value as follows:
Constructing Box The println( ) statement inside Box()
Constructing Box is for sake of illustration only. Most
Volume is 1000.0 Most constructor functions will not
Volume is 1000.0 display anything.
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) {
width = w;
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 ) ;
Box mybox2 = new Box (3,6,9 ) ;
double vol;
//get volume each box
vol =mybox1.volume() ;
System.out.println (“Volume is” + vol) ;
vol =mybox2.volume();
System.out.println (“Volume is” + vol) ;
}
}
We construct the Box objects of various
dimensions by adding parameters to constructor
The values 10,25,and 15 are passed to the
Box() constructor when new creates object
Thus mybox1’s copy of width, height, and depth will
contain the values 10,20,and 25 respectively
The output from this program is:
Volume is 3000.0
Volume is 162.0
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.
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
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;
}
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.
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.
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.
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.
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
class Stack {
int stck [ ] = new int [10];
int tos;
//Initialize top-of- stack
Stack () {
tos = -1;
}
The stack class defines two data items and three methods.
The stack of integers is held by the array stck. This array is
indexed by the variable tos, which always contains the index
of the top of the stack
The Stack constructor initializes tos to -1, which indicates
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
}
}
 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:”);
for (int i=0; i<10; i++)
System.out.println (mystack2.pop());
} }
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\J
RE\lib\i18n.jar;C:\JBUILDER8\JDK1.4\JRE\lib\sunrsasign.jar;C:\JBUILDER8\JDK1.4\JRE\lib\jsse.jar;C:\JB
UILDER8\JDK1.4\JRE\lib\jce.jar;C:\JBUILDER8\JDK1.4\JRE\lib\charsets.jar;C:\JBUILDER8\JDK1.4\JRE\c
lasses;C:\JBUILDER8\jdk1.4\lib\tools.jar"
textstack.TextStack
Stack mystack1:
9
8
7
6
5
4
3
2
1
0
Stack mystack2:
19
18
17
16
15
14
13
12
11
10
 As we can see, the contents of each stack are separate.
Second part of the lesson on
24th October
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.
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
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.
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.
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
231 - 1
long
8
-263
263 - 1
char
2
0x0
0xffff
float
4
1.401298e-45
3.402823e+38
double
8
4.940656e-324
1.797693e+308
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
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.
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)
0
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.