Transcript Lecture 2

Lecture 2
Classes and objects,
Constructors,
Arrays and vectors
1
Class Fundamentals






Class defines a new data types
Once defined, this new type can be used to create
objects of that type
Class is a template for an object and, an object is
an instance of a class
The data or variables, defined within a class are
called instance variables
The code is contained within methods
Collectively, the methods and variables defined
within a class are called members of a class
2
The General Form of a Class
class classname{
type instance-variable1
//…
type instance-variable N
type methodname1(parameter-list){
//body of the method
}
//…
type methodname N(parameter-list){
//body of the method
}
}
3
Caution



General form of a class does not specify a
main( ) method
Class declaration and implementation of
the methods are stored in the same place
and not defined separately (Different from
the C++)
Sometimes .java files become very large
4
A Simple Class
class Box{
double width;
double height;
double depth;
}


This code does not cause any objects of type Box
to come into existence
To actually create a Box object, you will use a
statement like:
Box mybox = new Box(); // create a Box object
called mybox
5
Example:BoxDemo.java

Here is a complete program that uses the Box class
class Box {
double width;
double height;
double depth;
}
// This class declares an object of type Box.
class BoxDemo {
public static void main(String args[]) {
Box mybox = new Box();
double vol;
// assign values to mybox's instance variables
mybox.width = 10;
mybox.height = 20;
mybox.depth = 15;
// compute volume of box
vol = mybox.width * mybox.height * mybox.depth;
System.out.println("Volume is " + vol);
}
}
6
Declaring Objects

To obtain objects of a class, we need




First declare a variable of the class type
Second, acquire an actual, physical copy of the object
and assign it to that variable (by new operator)
In Java, all class objects must be dynamically
allocated
Object references appear to be similar to pointers,
but you can not manipulate references as you
actual pointers
7
Declaring Objects (cont.)
Statement
Box mybox;
Effect
null
mybox
mybox=new Box( );
Width
mybox
Height
Depth
Box object
8
A Closer Look at new
mybox=new Box();




The class name followed by parentheses specifies
the constructor for the class
If a class don’t explicitly define its own
constructor, the Java automatically supply a default
constructor
We don’t need to use new for integers or
characters. Because java’s simple types are not
implemented as objects
It is possible that new will not be able to allocate
memory for an object because of insufficient
memory. In that case, a run-time exception will
occur
9
Assigning Object Reference Variables
Box b1=mew Box();
Box b2=b1;

b1
b2

b1 and b2 will both refer to the same object
Width
Height
Depth
Box object
If b1 is assigned null (b1=null;), the b2 still points
to the original object
10
Introducing Methods
class Box {
double width;
double height;
double depth;
// display volume of a 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();
// assign values to mybox1's instance variables
mybox1.width = 10;
mybox1.height = 20;
mybox1.depth = 15;
// display volume of first box
mybox1.volume();
}
}
11
Returning a Value
class Box {
double width;
double height;
double depth;
double volume( ) {
// compute and return volume
return width * height * depth;
}
}
class BoxDemo4 {
public static void main(String args[ ]) {
Box mybox1 = new Box();
double vol;
mybox1.width = 10;
// assign values to mybox1's instance variables
mybox1.height = 20;
mybox1.depth = 15;
vol = mybox1.volume( );
// get volume of first box
System.out.println("Volume is " + vol);
}
}
12
Methods having Parameters

There are two problems in the previous code



Its is clumsy and error prone (you may forget to set
dimension)
Instance variables should be accessed only through
methods defined by their class
void setDim(double w, double h, double d) {
width = w;
height = h;
depth = d;
}

mybox1.setDim(10, 20, 15);
13
Constructors





A constructor is automatically called immediately
after the object is created, before the new operator
completes
Its has no return types, not even void
Constructors have the same name as the
classname
When we write Box mybox1=new Box( ); actually the
constructor for the class is being called
As you know, Java creates a default constructor
for the class, which initializes all instance
variables to zero
14
Constructor example
Box() {
System.out.println("Constructing Box");
width = 10;
height = 10;
depth = 10;
}

When you write Box mybox1=new Box( ); the
values of height, width and depth are
automatically assigned
15
Parameterized Constructors
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
 Box mybox1 = new Box(10, 20, 15);
16
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. this always refers to the object on
which the method was invoked
Box(double w, double h, double d) {
this.width = w;
this.height = h;
this.depth = d;
}
17
Where this actually used


When a local variable has the same name as an
instance variable, the local variable hides instance
variable. This is why width, height and depth
were not used as the names of the parameters to
the Box( )
Although here we can use different names, but
you can resolve any name space collisions by
this, which lets you refer directly to the object
Box(double width, double height, double depth) {
this.width = width;
this.height = height;
this.depth = depth;
}
18
Garbage Collection




In C++, dynamically allocated objects must be
manually released by use of delete operator
Java takes a different approach; it handles
deallocation for you automatically
When no references to an object exist, that object
is assumed to be no longer needed, and the
memory occupied by the object can be reclaimed
Garbage collection only occurs sporadically
during the execution of your program
19
The finalize() Method


Sometimes an object will need to perform some action
when it is destroyed (i.e. release some non-java resources
such as file handle or windows character font)
finalize( ) method allows us to define specific actions that
will occurs when an object is just about to be reclaimed
by the garbage collector
protected void finalize( )
{
//finalization code here
}

You cannot know when- or even if- finalize( ) will be executed.
Therefore, you must not rely on it for normal program execution
20
A Closer Look at Methods
and Classes
21
Overloading methods (polymorphism)



Defining two methods within the same
class that share the same name, as long as
their declarations are different
Java uses the type and/or number of
arguments as its guide to determine which
version of the overloaded method to
actually call
The return type alone is insufficient to
distinguish two versions of a methods
22
Example
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter
double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
class Overload {
public static void main(String args[ ]) {
OverloadDemo ob = new
OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.2);
System.out.println("Result of
ob.test(123.2): " + result);
}
}
23
Automatic type conversion
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter and return
type
void test(double a) {
System.out.println("Inside test(double) a: " + a);
}
}
class Overload {
public static void main(String args[])
{
OverloadDemo ob = new
OverloadDemo();
int i = 88;
ob.test();
ob.test(10, 20);
ob.test(i); // this will invoke
test(double)
ob.test(123.2); // this will invoke
test(double)
}
}
24
Overloading Constructors
25
Using Objects as Parameters
Thus one object can be used to initialize another object

Objects are always passed by reference
26
Returning Objects
27
Introducing Access Control (Encapsulation)



When correctly implemented, a class creates a
“black box” which may be used, but inner
workings of which are not open to tampering
When a member of a class is specified as private,
then that member can only be accessed by other
members of its class
By default, the member of a class is public within
its own package, but cannot be accessed outside
of its package
28
Example
29
Example:Stack
30
Understanding Static





It is possible to create a member that can be used by itself, without
reference to a specific instance. To create such a member, precede
its declaration with the keyword static
Both methods and variables can be static
Instance variables declared as static are, essentially, global
variables
When objects of its class are declared, no copy of a static variable
is made. Instead, all instances of the class share the same static
variable
Methods declared as static have several restrictions:
 They can only call other static methods
 They must only access static data
 They cannot refer to this or super any way
31
Output:
Example
Static block initialized
X=42
A=3
B=12
32
Introducing final
A variable can be declared as final, which
prevents its contents from being modified
 final is similar to const in C/C++
 final variable must be initialized when it is
declared
 Common convention is to use uppercase
identifiers for final variables
 The keyword final can also be applied to methods
Example:
final int FILE_OPEN=2;

33
More about arrays

Arrays can be implemented as objects
i.e. length instance variable of an array

class Length {
public static void main(String args[]) {
int a1[] = new int[10];
int a2[] = {3, 5, 7, 1, 8, 99, 44, -10};
int a3[] = {4, 3, 2, 1};
System.out.println("length of a1 is " + a1.length);
System.out.println("length of a2 is " + a2.length);
System.out.println("length of a3 is " + a3.length);
}
}
34
Introducing Nested and Inner Classes



The scope of nested class is bounded by the scope
of its enclosing class
A nested class has access to the members,
including private members, of the class in which
it is nested. However, the enclosing class does not
have access to the members of the nested class
There are two types of nested class:


Static (it cannot refer to members of its enclosing
class directly)
Non-static/inner (it has access to all of the variables
and methods of its outer class directly)
35
Example
36
Exploring the String class





Every string you create is actually an object of
type String. Even string constants are actually
String objects
String objects are immutable; once a String object
is created, its contents cannot be altered
Java defines a peer class of String, called
StringBuffer, which allows strings to be altered
One way to create a string is:
String mystring=“this is a test”
+ operator is used to concatenate two strings
37
Some String methods




equals( ) is used to test two string for
equality
length( ) is used to obtain the length of
string
charAt( ) is used to obtain the character at a
specified index within a string
Also you can have arrays of string
String str[ ]={“one”, “two”, “three”};
38
Example
39
Using Command-Line Arguments

Helps us to pass information into a
program when it is run
class CommandLine {
public static void main(String args[]) {
for(int i=0; i<args.length; i++)
System.out.println("args[" + i + "]: " +
args[i]);
}
}
To execute a program, we write from the command prompt:
java CommandLine this is a test 100 -1
40