1

Basics of Java Programming

MODULE 3
Syllabus:
Introducing Classes: Class Fundamentals, Declaring Objects, Assigning Object Reference Variables, Introducing
Methods, Constructors, The this Keyword, Garbage Collection, The finalize( ) Method, A Stack Class.
A Closer Look at Methods and Classes: Overloading Methods, Using Objects as Parameters, A Closer Look at
Argument Passing, Returning Objects, Recursion, Introducing Access Control, Understanding static, Introducing
final, Arrays Revisited.
Inheritance: Inheritance, Using super, Creating a Multilevel Hierarchy, When Constructors Are Called, Method
Overriding, Dynamic Method Dispatch, Using Abstract Classes, Using final with Inheritance, The Object Class.

Class is a basis of OOP languages. It is a logical construct which defines shape and nature of an object. Entire Java
is built upon classes.

3.1 Class Fundamentals

Class can be thought of as a user-defined data type. We can create variables (objects) of that data type. So, we can
say that class is a template for an object and an object is an instance of a class. Most of the times, the terms
object and instance are used interchangeably.

The General Form of a Class

A class contains data (member or instance variables) and the code (member methods) that operate on the data. The
general form can be given as –

class classname
{
type var1;
type var2;
…….
type method1(para_list)
{
//body of method1
}

type method2(para_list)
{
//body of method2
}
………..
}

Here, classname is any valid name given to the class. Variables declared within a class are called as instance
variables because every instance (or object) of a class contains its own copy of these variables. The code is
contained within methods. Methods and instance variables collectively called as members of the class.

A Simple Class
Here we will consider a simple example for creation of class, creating objects and using members of the class. One
can store the following program in a single file called BoxDemo.java. (Or, two classes can be saved in two
different files with the names Box.java and BoxDemo.java.)

Dept of ISE, SCE

 2
Basics of Java Programming

class Box
{
double w, h, d;
}
class BoxDemo
{
public static void main(String args[])
{
Box b1=new Box();
Box b2=new Box();
double vol;

b1.w=2;
b1.h=4;
b1.d=3;

b2.w=5;
b2.h=6;
b2.d=2;

vol=b1.w*b1.h*b1.d; System.out.println("Volume
of Box1 is " + vol);

vol=b2.w*b2.h*b2.d; System.out.println("Volume
of Box2 is " + vol);
}
}

The output would be –

Volume of Box1 is 24.0
Volume of Box1 is 60.0

When you compile above program, two class files will be created viz. Box.class and BoxDemo.class. Since
main() method is contained in BoxDemo.class, you need to execute the same.

In the above example, we have created a class Box which contains 3 instance variables w, h, d.
Box b1=new Box();
The above statement creates a physical memory for one object of Box class. Every object is an instance of a class,
and so, b1 and b2 will have their own copies of instance variables w, h and d. The memory layout for one object
allocation can be shown as –
Box Class

main()
{ Box Instance
Box b1 = new Box( );
}

BoxDemo Class

JVM Heap

Dept of ISE, SCE

 3
Basics of Java Programming

3.2 Declaring Objects

Creating a class means having a user-defined data type. To have a variable of this new data type, we should
create an object. Consider the following declaration:
Box b1;
This statement will not actually create any physical object, but the object name b1 can just refer to the actual object
on the heap after memory allocation as follows –
b1 = new Box ();

We can even declare an object and allocate memory using a single statement – Box
b1=new Box();
Without the usage of new, the object contains null. Once memory is allocated dynamically, the object b1 contains
the address of real object created on the heap. The memory map is as shown in the following diagram –

Statement Effect

Box b1; null

b1

b1 = new Box();
b1 w
h
d
Closer look at new
The general form for object creation is –
obj_name = new class_name();

Here, class_name() is actually a constructor call. A constructor is a special type of member function invoked
automatically when the object gets created. The constructor usually contains the code needed for object
initialization. If we do not provide any constructor, then Java supplies a default constructor.

Java treats primitive types like byte, short, int, long, char, float, double and boolean as ordinary variables but
not as an object of any class. This is to avoid extra overhead on the heap memory and also to increase the efficiency
of the program. Java also provides the class-version of these primitive types that can be used only if necessary. We
will study those types later in detail.

With the term dynamic memory allocation, we can understand that the keyword new allocates memory for the
object during runtime. So, depending on the user’s requirement memory will be utilized. This will avoid the
problems with static memory allocation (either shortage or wastage of memory during runtime). If there is no
enough memory in the heap when we use new for memory allocation, it will throw a run-time exception.

3.3 Assigning Object Reference Variables

When an object is assigned to another object, no separate memory will be allocated. Instead, the second object
refers to the same location as that of first object. Consider the following declaration –
Box b1= new Box();
Box b2= b1;

Dept of ISE, SCE

 4
Basics of Java Programming

Now both b1 and b2 refer to same object on the heap. The memory representation for two objects can be shown as –

w
b1
h
d

b2

Thus, any change made for the instance variables of one object affects the other object also. Although b1 and b2
both refer to the same object, they are not linked in any other way. For example, a subsequent assignment to b1 will
simply unhook b1 from the original object without affecting the object or affecting b2. For example:

Box b1 = new Box();

Box b2 = b1;
// ...
b1 = null;

Here, b1 has been set to null, but b2 still points to the original object.

NOTE that when you assign one object reference variable to another object reference variable, you are not creating
a copy of the object, you are only making a copy of the reference.

3.4 Introducing Methods

A class can consist of instance variables and methods. We have seen declaration and usage of instance variables in
Program 2.1. Now, we will discuss about methods. The general form of a method is –

ret_type method_name(para_list)
{
//body of the method
return value;
}

Here, ret_type specifies the data type of the variable returned by the method. It may be any primitive
type or any other derived type including name of the same class. If the method does
not return any value, the ret_type should be specified as void.
method_name is any valid name given to the method
para_list is the list of parameters (along with their respective types) taken the method. It may be even
empty also.
body of method is a code segment written to carryout some process for which the method is meant for.
return is a keyword used to send value to the calling method. This line will be absent if the
ret_type is void.

Adding Methods to Box class

Dept of ISE, SCE

 5
Basics of Java Programming

Though it is possible to have classes with only instance variables as we did for Box class of Program 2.1, it is
advisable to have methods to operate on those data. Because, methods acts as interface to the classes. This allows
the class implementer to hide the specific layout of internal data structures behind cleaner method abstractions. In
addition to defining methods that provide access to data, you can also define methods that are used internally by the
class itself. Consider the following example –

class Box
{
double w, h, d;

void volume()
{
System.out.println("The volume is " + w*h*d);
}
}

class BoxDemo
{
public static void main(String args[])
{
Box b1=new Box();
Box b2=new Box();

b1.w=2;
b1.h=4;
b1.d=3;

b2.w=5;
b2.h=6;
b2.d=2;

b1.volume();
b2.volume();
}
}

The output would be –

The volume is 24.0
The volume is 60.0

In the above program, the Box objects b1 and b2 are invoking the member method volume() of the Box class to
display the volume. To attach an object name and a method name, we use dot (.) operator. Once the program control
enters the method volume(), we need not refer to object name to use the instance variables w, h and d.

Returning a value
In the previous example, we have seen a method which does not return anything. Now we will modify the above
program so as to return the value of volume to main() method.

Dept of ISE, SCE

 6
Basics of Java Programming

class Box
{
double w, h, d;

double volume()
{
return w*h*d;
}
}

class BoxDemo
{
public static void main(String args[])
{
Box b1=new Box();
Box b2=new Box();
double vol;

b1.w=2;
b1.h=4;
b1.d=3;

b2.w=5;
b2.h=6;
b2.d=2;

vol = b1.volume(); System.out.println("The

volume is " + vol);
System.out.println("The volume is " + b2.volume());
}
}

The output would be –

The volume is 24.0
The volume is 60.0

As one can observe from above example, we need to use a variable at the left-hand side of the assignment operator
to receive the value returned by a method. On the other hand, we can directly make a method call within print
statement as shown in the last line of above program.

There are two important things to understand about returning values:

 The type of data returned by a method must be compatible with the return type specified by the method. For
example, if the return type of some method is boolean, you could not return an integer.
 The variable receiving the value returned by a method (such as vol, in this case) must also be compatible
with the return type specified for the method.

Dept of ISE, SCE

 7
Basics of Java Programming

Adding Methods that takes Parameters

Having parameters for methods is for providing some input information to process the task. Consider the following
version of Box class which has a method with parameters.

class Box
{
double w, h, d;

double volume()
{
return w*h*d;
}

void set(double wd, double ht, double dp)

{
w=wd;
h=ht;
d=dp;
}
}

class BoxDemo
{
public static void main(String args[])
{
Box b1=new Box();
Box b2=new Box();

b1.set(2,4,3);
b2.set(5,6,2);

System.out.println("The volume of b1 is " + b1.volume()); System.out.println("The

volume of b2 is " + b2.volume());
}
}

The output would be –

The volume of b1 is 24.0
The volume of b2 is 60.0

In the above program, the Box class contains a method set() which take 3 parameters. Note that, the variables wd,
ht and dp are termed as formal parameters or just parameters for a method. The values passed like 2, 4, 3 etc.
are called as actual arguments or just arguments passed to the method.

3.5 Constructors
Constructor is a special type of member method which is invoked automatically when the object gets created.
Constructors are used for object initialization. They have same name as that of the class. Since they are called
automatically, there is no return type for them. Constructors may or may not take parameters.

Dept of ISE, SCE

 8
Basics of Java Programming

class Box
{
double w, h, d;

double volume()
{
return w*h*d;
}

Box() //ordinary constructor

{
w=h=d=5;
}

Box(double wd, double ht, double dp) //parameterized constructor

{
w=wd;
h=ht;
d=dp;
}
}

class BoxDemo
{
public static void main(String args[])
{
Box b1=new Box();
Box b2=new Box();
Box b3=new Box(2,4,3);

System.out.println("The volumeof b1 is " + b1.volume());

System.out.println("The volumeof b2 is " + b2.volume());
System.out.println("The volumeof b3 is " + b3.volume());
}
}

The output would be –

The volume of b1 is 125.0
The volume of b2 is 125.0
The volume of b3 is 24.0

When we create two objects b1 and b2, the constructor with no arguments will be called and the all the instance
variables w, h and d are set to 5. Hence volume of b1 and b2 will be same (that is 125 in this example). But, when
we create the object b3, the parameterized constructor will be called and hence volume will be 24.

Few points about constructors:

 Every class is provided with a default constructor which initializes all the data members to respective
default values. (Default for numeric types is zero, for character and strings it is null and default value for
Boolean type is false.)

Dept of ISE, SCE

 9
Basics of Java Programming

 In the statement
classname ob= new classname();
the term classname() is actually a constructor call.
 If the programmer does not provide any constructor of his own, then the above statement will call default
constructor.
 If the programmer defines any constructor, then default constructor of Java can not be used.
 So, if the programmer defines any parameterized constructor and later would like to create an object
without explicit initialization, he has to provide the default constructor by his own.
For example, the above program, if we remove ordinary constructor, the statements like Box
b1=new Box();
will generate error. To avoid the error, we should write a default constructor like – Box(){ }
Now, all the data members will be set to their respective default values.

3.6 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
which invokes the method call. For example, in the Program 2.5, the method volume() can be written as –
double volume()
{
return this.w * this.h * this.d;
}
Here, usage of this is not mandatory as it is implicit. But, in some of the situations, it is useful as explained in the
next section.

Instance Variable Hiding

As we know, in Java, we can not have two local variables with the same name inside the same or enclosing scopes.
(Refer Program 1.7 and a NOTE after that program from Chapter 1, Page 16 & 17). But we can have local
variables, including formal parameters to methods, which overlap with the names of the class instance variables.
However, when a local variable has the same name as an instance variable, the local variable hides the
instance variable. That is, if we write following code snippet for a constructor in Program 2.5, we will not get
an expected output –
Box(double w, double h, double d)
{
w=w;
h=h;
d=d;
}
Here note that, formal parameter names and data member names match exactly. To avoid the problem, we can use –
Box(double w, double h, double d)
{
this.w=w; //this.w refers to data member name and w refers to formal parameter
this.h=h;
this.d=d;
}

Dept of ISE, SCE

 10
Basics of Java Programming

3.7 Garbage Collection

In C and C++, dynamically allocated variables/objects must be manually released using delete operator. But, in
Java, this task is done automatically and is called as garbage collection. 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 occurs once in a while during the execution of the program. It will not occur simply because one or more
objects exist that are no longer used. Furthermore, different Java run-time implementations will take varying
approaches to garbage collection.

3.8 The finalize() Method

Sometimes an object will need to perform some action when it is destroyed. For example, if an object is holding
some non-Java resource such as a file handle or character font, then you might want to make sure these resources
are freed before an object is destroyed. To handle such situations, Java provides a mechanism called finalization.
By using finalization, you can define specific actions that will occur when an object is just about to be reclaimed by
the garbage collector. To add a finalizer to a class, you simply define the finalize() method. The Java run time
calls that method whenever it is about to recycle an object of that class.

The finalize( ) method has this general form:

protected void finalize( )
{
// finalization code here
}
Here, the keyword protected is a specifier that prevents access to finalize( ) by code defined outside its class. Note
that finalize( ) is only called just prior to garbage collection. It is not called when an object goes out-of-scope. So,
we can not know when finalize() method is called, or we may be sure whether it is called or not before our
program termination. Therefore, if at all our program uses some resources, we should provide some other means for
releasing them and must not depend on finalize() method.

3.9 A Stack Class

To summarize the concepts of encapsulation, class, constructor, member initialization etc, we will now consider a
program to implement stack operations.

Concept of Stack: A stack is a Last in First Out (LIFO) data structure. Following figure depicts the basic
operations on stack:

Dept of ISE, SCE

 11
Basics of Java Programming

Inserting an element into a stack is known as push operation, whereas deleting an element from the stack is pop
operation. An attempt made to push an element into a full stack is stack overflow and an attempt to delete from
empty stack is stack underflow.

class Stack
{
int st[] = new int[5];
int top;

Stack()
{
top = -1;
}

void push(int item)

{
if(top==4)
System.out.println("Stack is full.");
else
st[++top] = item;
}

int pop()
{
if(top==-1)
{
System.out.println("Stack underflow.");
return 0;
}
else
return st[top--];
}
}

class StackDemo
{
public static void main(String args[])
{
Stack mystack1 = new Stack();
Stack mystack2 = new Stack();

for(int i=0; i<5; i++)

mystack1.push(i);
for(int i=5; i<10; i++)
mystack2.push(i);

System.out.println("Contents of mystack1:");
for(int i=0; i<5; i++)
System.out.println(mystack1.pop());

Dept of ISE, SCE

 12
Basics of Java Programming

System.out.println("Contents of mystack2:");
for(int i=0; i<5; i++)
System.out.println(mystack2.pop());
}
}

3.10 Overloading Methods

Having more than one method with a same name is called as method overloading. To implement this concept,
the constraints are:
 the number of arguments should be different, and/or
 Type of the arguments must be different.

NOTE that, only the return type of the method is not sufficient for overloading.

class Overload
{
void test() //method without any arguments
{
System.out.println("No parameters");
}

void test(int a) //method with one integer argument

{
System.out.println("Integer a: " + a);
}

void test(int a, int b) //two arguments

{
System.out.println("With two arguments : " + a + " " + b);
}

void test(double a) //one argument of double type

{
System.out.println("double a: " + a);
}
}

class OverloadDemo
{
public static void main(String args[])
{
Overload ob = new Overload();

ob.test();
ob.test(10);
ob.test(10, 20);
ob.test(123.25);
}
}

Dept of ISE, SCE

 13
Basics of Java Programming

3.11 Overloading Constructors

One can have more than one constructor for a single class if the number and/or type of arguments are different.
Consider the following code:

class OverloadConstruct
{
int a, b;
OverloadConstruct()
{
System.out.println("Constructor without arguments");
}

OverloadConstruct(int x)
{
a=x;
System.out.println("Constructor with one argument:"+a);
}

OverloadConstruct(int x, int y)
{
a=x;
b=y;
System.out.println("Constructor with two arguments:"+ a +"\t"+ b);
}
}

class OverloadConstructDemo
{
public static void main(String args[])
{
OverloadConstruct ob1= new OverloadConstruct();
OverloadConstruct ob2= new OverloadConstruct(10);
OverloadConstruct ob3= new OverloadConstruct(5,12);
}
}

Output:
Constructor without arguments
Constructor with one argument:
10
Constructor with two arguments: 5 12

3.12 Using Objects as Parameters

Just similar to primitive types, even object of a class can also be passed as a parameter to any method. Consider the
example given below –

class Test
{
int a, b;
Test(int i, int
j)
{
Dept of ISE, SCE
 14
Basics of Java Programming

a = i;
b = j;
}

boolean equals(Test ob)

{
if(ob.a == this.a && ob.b == this.b)
return true;
else
return false;
}
}

class PassOb
{
public static void main(String args[])
{
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " + ob1.equals(ob2));
System.out.println("ob1 == ob3: " + ob1.equals(ob3));
}
}

Output:
ob1 == ob2: true
ob1 == ob3: false

Using one object to initialize the other:

Sometimes, we may need to have a replica of one object. The usage of following statements will not
serve the purpose.
Box b1=new Box(2,3,4);
Box b2=b1;

In the above case, both b1 and b2 will be referring to same object, but not two different objects. So, we can write a
constructor having a parameter of same class type to clone an object.

class Box
{
double h, w, d;

Box(double ht, double wd, double dp)

{
h=ht; w=wd; d=dp;
}
Box (Box bx) //observe this constructor
{
h=bx.h; w=bx.w; d=bx.d;
}

Dept of ISE, SCE

 15
Basics of Java Programming

void vol()
{
System.out.println("Volume is " + h*w*d);
}
public static void main(String args[])
{
Box b1=new Box(2,3,4);
Box b2=new Box(b1); //initialize b2 using b1
b1.vol();
b2.vol();
}
}
Output:
Volume is 24
Volume is 24

3.13 A Closer Look at Argument Passing

In Java, there are two ways of passing arguments to a method.
 Call by value : This approach copies the value of an argument into the formal parameter of the method.
Therefore, changes made to the parameter of the method have no effect on the argument.
 Call by reference: In this approach, a reference to an argument is passed to the parameter. Inside the
subroutine, this reference is used to access the actual argument specified in the call. This means that
changes made to the parameter will affect the argument used to call the subroutine.

In Java, when you pass a primitive type to a method, it is passed by value. When you pass an object
to a method, they are passed by reference. Keep in mind that when you create a variable of a class type, you
are only creating a reference to an object. Thus, when you pass this reference to a method, the parameter that
receives it will refer to the same object as that referred to by the argument. This effectively means that objects are
passed to methods by use of call-by-reference. Changes to the object inside the method do affect the object used as
an argument.

class Test
{ int a, b;
Test(int i, int
j)
{
a = i;
b = j;
}
void meth(Test o)
{
o.a *= 2;
o.b /= 2;
}
}
class CallByRef
{
public static void main(String args[])
{

Dept of ISE, SCE

 16
Basics of Java Programming

Test ob = new Test(15, 20);

System.out.println("before call: " + ob.a + " " + ob.b);
ob.meth(ob);
System.out.println("after call: " + ob.a + " " + ob.b);
}
}

Output:
before call: 15 20
after call: 30 10

3.14 Returning Objects

In Java, a method can return an object of user defined class.
class Test
{
int a;
Test(int i)
{
a = i;
}

Test incrByTen()
{
Test temp = new Test(a+10);
return temp;
}
}

class RetOb
{
public static void main(String args[])
{
Test ob1 = new Test(2);
Test ob2;

ob2 = ob1.incrByTen();
System.out.println("ob1.a: " + ob1.a);
System.out.println("ob2.a: " + ob2.a);

ob2 = ob2.incrByTen();
System.out.println("ob2.a after second increase: " + ob2.a);
}
}

Output:
ob1.a: 2
ob2.a: 12
ob2.a after second increase: 22

Dept of ISE, SCE

 17
Basics of Java Programming

3.15 Recursion
A method which invokes itself either directly or indirectly is called as recursive method. Every recursive method
should satisfy following constraints:
 It should have at least one non-recursive terminating condition.
 In every step, it should be nearer to the solution (that is, problem size must be decreasing)

class Factorial
{
int fact(int n)
{
if (n==0)
return 1;
return n*fact(n-1);
}
}

class FactDemo
{
public static void main(String args[])
{
Factorial f= new Factorial();

System.out.println("Factorial 3 is "+ f.fact(3));

System.out.println("Factorial 8 is "+ f.fact(8));

}
}

Output:
Factorial of 3 is 6
Factorial of 8 is 40320

3.16 Introducing Access Control

Encapsulation feature of Java provides a safety measure viz. access control. Using access specifiers, we can
restrict the member variables of a class from outside manipulation. Java provides following access specifiers:
 public
 private
 protected
Along with above access specifiers, Java defines a default access level.

Some aspects of access control are related to inheritance and package (a collection of related classes). The
protected specifier is applied only when inheritance is involved. So, we will now discuss about only private and
public.

When a member of a class is modified by the public specifier, then that member can be accessed by any other code.
When a member of a class is specified as private, then that member can only be accessed by other members of its
class. When no access specifier is used, then by default the member of a class is public within its own package, but
cannot be accessed outside of its package. Usually, you will want to

Dept of ISE, SCE

 18
Basics of Java Programming

restrict access to the data members of a class—allowing access only through methods. Also, there will be times
when you will want to define methods that are private to a class. An access specifier precedes the rest of a
member’s type specification. For example,
public int x;
private char ch;

Consider a program given below –

class Test
{ int a;
public int b;
private int c;

void setc(int i)
{
c = i;
}

int getc()
{
return c;
}
}

class AccessTest
{
public static void main(String args[])
{
Test ob = new Test();
ob.a = 10;
ob.b = 20;
// ob.c = 100; // inclusion of this line is Error!
ob.setc(100);
System.out.println("a, b, and c: " + ob.a + " " + ob.b + " "
+ ob.getc());
}
}

3.17 Understanding static

When a member is declared static, it can be accessed before any objects of its class are created, and without
reference to any object. Instance variables declared as static are 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 in any way.

Dept of ISE, SCE

 19
Basics of Java Programming

If you need to do computation in order to initialize your static variables, you can declare a static block that gets
executed exactly once, when the class is first loaded.

class UseStatic
{
static int a = 3;
static int b;

static void meth(int x) //static method

{
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}

static //static block

{
System.out.println("Static block initialized.");
b = a * 4;
}

public static void main(String args[])

{
meth(42);
}
}

Output:
Static block initialized.
x = 42
a=3
b = 12

Outside of the class in which they are defined, static methods and variables can be used independently of any
object. To do so, you need only specify the name of their class followed by the dot operator. The general form is –
classname.method();

Consider the following program:

class StaticDemo
{
static int a = 42;
static int b = 99;

static void callme()

{
System.out.println("Inside static method, a = " + a);
}
}

Dept of ISE, SCE

 20
Basics of Java Programming

class StaticByName
{
public static void main(String args[])
{
StaticDemo.callme();
System.out.println("Inside main, b = " + StaticDemo.b);
}
}

Output:
Inside static method, a = 42
Inside main, b = 99

3.18 Arrays Revisited

Arrays have been discussed earlier. An important point to be noted with arrays is: arrays are implemented as
objects in Java. Because of this, we can use a special instance variable length to know the size of an array.

class Test
{
public static void main(String args[])
{
int a1[]=new int[10];
int a2[]={1, 2, 3, 4, 5};
int a3[]={3, 8, -2, 45, 9, 0, 23};

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);
}
}

Output:
Length of a1 is 10
Length of a2 is 5
Length of a3 is 7

3.19 Inheritance
Inheritance is one of the building blocks of object oriented programming languages. It allows creation of classes
with hierarchical relationship among them. Using inheritance, one can create a general class that defines traits
common to a set of related items. This class can then be inherited by other, more specific classes, each adding those
things that are unique to it. In the terminology of Java, a class that is inherited is called a superclass. The class
that does the inheriting is called a subclass. Therefore, a subclass is a specialized version of a superclass. It
inherits all of the instance variables and methods defined by the superclass and add its own, unique elements.
Through inheritance, one can achieve re-usability of the code.

In Java, inheritance is achieved using the keyword extends. The syntax is given below:

Dept of ISE, SCE

 21
Basics of Java Programming

class A //super class

{
//members of class A
}

class B extends A //sub class

{
//members of B
}

Consider a program to understand the concept:

class A
{
int i, j;

void showij()
{
System.out.println("i and j: " + i + " " + j);
}
}

class B extends A
{
int k;
void showk()
{
System.out.println("k: " + k);
}
void sum()
{
System.out.println("i+j+k: " + (i+j+k));
}
}

class SimpleInheritance
{
public static void main(String args[])
{
A superOb = new A();
B subOb = new B();
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();

subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");

Dept of ISE, SCE

 22
Basics of Java Programming

subOb.showij();
subOb.showk();

System.out.println("Sum of i, j and k in subOb:");

subOb.sum();
}
}

Note that, private members of the super class can not be accessed by the sub class. The subclass contains all non-
private members of the super class and also it contains its own set of members to achieve specialization.

3.19.1 Type of Inheritance

 Single Inheritance: If a class is inherited from one parent class, then it is known as single
inheritance. This will be of the form as shown below –

superclass

subclass
The previous program is an example of single inheritance.

 Multilevel Inheritance: If several classes are inherited one after the other in a hierarchical
manner, it is known as multilevel inheritance, as shown below –

B
C

Dept of ISE, SCE

 23
Basics of Java Programming

3.19.2 A Superclass variable can reference a subclass object

A reference variable of a superclass can be assigned a reference to any subclass derived from that superclass.
Consider the following for illustration:

class Base
{
void dispB()
{
System.out.println("Super class " );
}
}
class Derived extends Base
{
void dispD()
{
System.out.println("Sub class ");
}
}

class Demo
{
public static void main(String args[])
{
Base b = new Base();
Derived d=new Derived();

b=d; //superclass reference is holding subclass object

b.dispB();
//b.dispD(); error!!
}
}

Note that, the type of reference variable decides the members that can be accessed, but not the type of the
actual object. That is, when a reference to a subclass object is assigned to a superclass reference variable, you
will have access only to those parts of the object defined by the superclass.

3.20 Using super

In Java, the keyword super can be used in following situations:
 To invoke superclass constructor within the subclass constructor
 To access superclass member (variable or method) when there is a duplicate member name in the
subclass

Let us discuss each of these situations:

 To invoke superclass constructor within the subclass constructor: Sometimes, we may need
to initialize the members of super class while creating subclass object. Writing such a code in subclass
constructor may lead to redundancy in code. For example,

class Box
{
double w, h, b;

Dept of ISE, SCE

 24
Basics of Java Programming

Box(double wd, double ht, double br)

{
w=wd; h=ht; b=br;
}
}
class ColourBox extends Box
{
int colour;
ColourBox(double wd, double ht, double br, int c)
{
w=wd; h=ht; b=br; //code redundancy
colour=c;
}
}

Also, if the data members of super class are private, then we can’t even write such a code in subclass
constructor. If we use super() to call superclass constructor, then it must be the first statement executed
inside a subclass constructor as shown below –

class Box
{
double w, h, b;
Box(double wd, double ht, double br)
{
w=wd; h=ht; b=br;
}
}

class ColourBox extends Box

{
int colour;
ColourBox(double wd, double ht, double br, int c)
{
super(wd, ht, br); //calls superclass constructor
colour=c;
}
}

class Demo
{
public static void main(String args[])
{
ColourBox b=new ColourBox(2,3,4, 5);
}
}

Here, we are creating the object b of the subclass ColourBox . So, the constructor of this class is invoked. As the
first statement within it is super(wd, ht, br), the constructor of superclass Box is invoked, and then the rest
of the statements in subclass constructor ColourBox are executed.

Dept of ISE, SCE

 25
Basics of Java Programming

 To access superclass member variable when there is a duplicate variable name in the
subclass: This form of super is most applicable to situations in which member names of a subclass hide
members by the same name in the superclass.

class A
{
int a;
}

class B extends A
{
int a; //duplicate variable a

B(int x, int y)
{
super.a=x; //accessing superclass a
a=y; //accessing own member a
}

void disp()
{
System.out.println("super class a: "+ super.a);
System.out.println("sub class a: "+ a);
}
}

class SuperDemo
{
public static void main(String args[])
{
B ob=new B(2,3);
ob.disp();
}
}

3.21 Creating Multilevel Hierarchy

Java supports multi-level inheritance. A sub class can access all the non-private members of all of its super
classes. Consider an illustration:

class A
{ int a;
}

class B extends A
{ int b;
}

class C extends B
{ int c;

Dept of ISE, SCE

 26
Basics of Java Programming

C(int x, int y, int z)

{
a=x; b=y; c=z;
}
void disp()
{
System.out.println("a= "+a+ " b= "+b+" c="+c);
}
}

class MultiLevel
{
public static void main(String args[])
{
C ob=new C(2,3,4);
ob.disp();
}
}

3.22 When Constructors are called

When class hierarchy is created (multilevel inheritance), the constructors are called in the order of their
derivation. That is, the top most super class constructor is called first, and then its immediate sub class and so on.
If super is not used in the sub class constructors, then the default constructor of super class will be called.

class A
{
A()
{
System.out.println("A's constructor.");
}
}

class B extends A
{
B()
{
System.out.println("B's constructor.");
}
}
class C extends B
{
C()
{
System.out.println("C's constructor.");
}
}
class CallingCons
{
public static void main(String args[])

Dept of ISE, SCE

 27
Basics of Java Programming

{
C c = new C();
}
}

Output:
A's constructor
B's constructor
C's constructor

3.23 Method Overriding

In a class hierarchy, when a method in a subclass has the same name and type signature as a method in its
superclass, then the method in the subclass is said to override the method in the superclass. When an overridden
method is called from within a subclass, it will always refer to the version of that method defined by the subclass.
The version of the method defined by the superclass will be hidden.

class A
{
int i, j;
A(int a, int
b)
{
i = a;
j = b;
}
void show() //suppressed
{
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A
{
int k;
B(int a, int b, int c)
{
super(a, b);
k = c;
}
void show() //Overridden method
{
System.out.println("k: " + k);
}
}
class Override
{
public static void main(String args[])
{
B subOb = new B(1, 2, 3);
subOb.show();
}
}

Dept of ISE, SCE

 28
Basics of Java Programming

Output:
k: 3

Note that, above program, only subclass method show() got called and hence only k got displayed. That is, the
show() method of super class is suppressed. If we want superclass method also to be called, we can re-write the
show() method in subclass as –

void show()
{
super.show(); // this calls A's show()
System.out.println("k: " + k);
}

Method overriding occurs only when the names and the type signatures of the two methods (one in superclass and
the other in subclass) are identical. If two methods (one in superclass and the other in subclass) have same name,
but different signature, then the two methods are simply overloaded.

3.24 Dynamic Method Dispatch

Method overriding forms the basis for one of Java’s most powerful concepts: dynamic method dispatch. Dynamic
method dispatch is the mechanism by which a call to an overridden method is resolved at run time, rather than
compile time. Java implements run-time polymorphism using dynamic method dispatch. We know that, a superclass
reference variable can refer to subclass object. Using this fact, Java resolves the calls to overridden methods during
runtime. When an overridden method is called through a superclass reference, Java determines which version of that
method to execute based upon the type of the object being referred to at the time the call occurs. Thus, this
determination is made at run time. When different types of objects are referred to, different versions of an
overridden method will be called. In other words, it is the type of the object being referred to (not the type of the
reference variable) that determines which version of an overridden method will be executed. Therefore, if a
superclass contains a method that is overridden by a subclass, then when different types of objects are referred to
through a superclass reference variable, different versions of the method are executed.

class A
{
void callme()
{
System.out.println("Inside A");
}
}
class B extends A
{
void callme()
{
System.out.println("Inside B");
}
}

class C extends A
{
void callme()
{

Dept of ISE, SCE

 29
Basics of Java Programming

System.out.println("Inside C");
}
}
class Dispatch
{
public static void main(String args[])
{
A a = new A();
B b = new B();
C c = new C();

A r; //Superclass reference
r = a; //holding subclass object
r.callme();
r = b;
r.callme();
r = c;
r.callme();
}
}

Why overridden methods?

Overridden methods are the way that Java implements the “one interface, multiple methods” aspect of
polymorphism. superclasses and subclasses form a hierarchy which moves from lesser to greater specialization.
Used correctly, the superclass provides all elements that a subclass can use directly. It also defines those methods
that the derived class must implement on its own. This allows the subclass the flexibility to define its own methods,
yet still enforces a consistent interface. Thus, by combining inheritance with overridden methods, a superclass can
define the general form of the methods that will be used by all of its subclasses. Dynamic, run-time polymorphism is
one of the most powerful mechanisms that objectoriented design brings to bear on code reuse and robustness.

3.25 Using Abstract Classes

Sometimes, the method definition will not be having any meaning in superclass. Only the subclass (specialization)
may give proper meaning for such methods.In such a situation, having a definition for a method in superclass is
absurd. Also, we should enforce the subclass to override such a method. A method which does not contain any
definition in the superclass is termed as abstract method. Such a method declaration should be preceded by the
keyword abstract. These methods are sometimes referred to as subclasser responsibility because they have no
implementation specified in the superclass.

A class containing at least one abstract method is called as abstract class. Abstract classes can not be
instantiated, that is one cannot create an object of abstract class. Whereas, a reference can be created for an abstract
class.
abstract class A
{
abstract void callme();
void callmetoo()
{
System.out.println("This is a concrete method.");
}
}

Dept of ISE, SCE

 30
Basics of Java Programming

class B extends A
{
void callme() //overriding abstract method
{
System.out.println("B's implementation of callme.");
}
}

class AbstractDemo
{
public static void main(String args[])
{
B b = new B(); //subclass object
b.callme(); //calling abstract method
b.callmetoo(); //calling concrete method
}
}

Example: Write an abstract class shape, which has an abstract method area(). Derive three classes Triangle,
Rectangle and Circle from the shape class and to override area(). Implement run-time polymorphism by creating
array of references to supeclass. Compute area of different shapes and display the same.

Solution:

abstract class Shape

{
final double PI= 3.1416;
abstract double area();
}

class Triangle extends Shape

{
int b, h;
Triangle(int x, int y) //constructor
{
b=x;
h=y;
}

double area() //method overriding

{
System.out.print("\nArea of Triangle is:");
return 0.5*b*h;
}
}

class Circle extends Shape

{
int r;

Dept of ISE, SCE

 31
Basics of Java Programming

Circle(int rad) //constructor

{
r=rad;
}

double area() //overriding

{
System.out.print("\nArea of Circle is:");
return PI*r*r;
}
}

class Rectangle extends Shape

{
int a, b;
Rectangle(int x, int y) //constructor
{
a=x;
b=y;
}
double area() //overriding
{
System.out.print("\nArea of Rectangle is:");
return a*b;
}
}

class AbstractDemo
{
public static void main(String args[])
{
Shape r[]={new Triangle(3,4), new Rectangle(5,6),new Circle(2)};

for(int i=0;i<3;i++)
System.out.println(r[i].area());
}
}

Output:
Area of Triangle is:6.0 Area
of Rectangle is:30.0 Area of
Circle is:12.5664

Note that, here we have created array r, which is reference to Shape class. But, every element in r is holding
objects of different subclasses. That is, r[0] holds Triangle class object, r[1] holds Rectangle class object and so
on. With the help of array initialization, we are achieving this, and also, we are calling respective constructors.
Later, we use a for-loop to invoke the method area() defined in each of these classes.

Dept of ISE, SCE

 32
Basics of Java Programming

3.26 Using final

The keyword final can be used in three situations in Java:
 To create the equivalent of a named constant.
 To prevent method overriding
 To prevent Inheritance

To create the equivalent of a named constant: A variable can be declared as final. Doing so prevents its
contents from being modified. This means that you must initialize a final variable when it is declared. For example:
final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;

It is a common coding convention to choose all uppercase identifiers for final variables. Variables declared as final
do not occupy memory on a per-instance basis. Thus, a final variable is essentially a constant.

To prevent method overriding: Sometimes, we do not want a superclass method to be overridden in the
subclass. Instead, the same superclass method definition has to be used by every subclass. In such situation, we can
prefix a method with the keyword final as shown below –
class A
{
final void meth()
{
System.out.println("This is a final method.");
}
}
class B extends A
{
void meth() // ERROR! Can't override.
{
System.out.println("Illegal!");
}
}

To prevent Inheritance: As we have discussed earlier, the subclass is treated as a specialized class and
superclass is most generalized class. During multi-level inheritance, the bottom most class will be with all the
features of real-time and hence it should not be inherited further. In such situations, we can prevent a particular class
from inheriting further, using the keyword final. For example –
final class A
{
// ...
}
class B extends A // ERROR! Can't subclass A
{
// ...
}

Dept of ISE, SCE

 33
Basics of Java Programming

Note:
 Declaring a class as final implicitly declares all of its methods as final, too.
 It is illegal to declare a class as both abstract and final since an abstract class is incomplete by itself and
relies upon its subclasses to provide complete implementations

3.27 The Object Class

There is one special class, Object, defined by Java. All other classes are subclasses of Object. That is, Object is a
superclass of all other classes. This means that a reference variable of type Object can refer to an object of any
other class. Also, since arrays are implemented as classes, a variable of type Object can also refer to any array.
Object defines the following methods, which means that they are available in every object.

Method Purpose
Object clone( ) Creates a new object that is the same as the object being cloned.

boolean equals(Object object) Determines whether one object is equal to another.

void finalize( ) Called before an unused object is recycled.

Class getClass( ) Obtains the class of an object at run time.

int hashCode( ) Returns the hash code associated with the invoking object.

void notify( ) Resumes execution of a thread waiting on the invoking object.

void notifyAll( ) Resumes execution of all threads waiting on the invoking object.

String toString( ) Returns a string that describes the object.

void wait( ) Waits on another thread of execution.

void wait(long milliseconds)
void wait(long milliseconds,
int nanoseconds)

The methods getClass( ), notify( ), notifyAll( ), and wait( ) are declared as final. You may override the
others. The equals( ) method compares the contents of two objects. It returns true if the objects are
equivalent, and false otherwise. The precise definition of equality can vary, depending on the type of objects
being compared. The toString( ) method returns a string that contains a description of the object on which it is
called. Also, this method is automatically called when an object is output using println( ). Many classes
override this method.

Question Bank:
1. Define class. Give syntax and example.
2. Briefly explain static members of the class with suitable examples.
3. Discuss method overloading. Write a program to overload a method area() to compute area of a triangle
and a circle.

Dept of ISE, SCE

 34
Basics of Java Programming

4. Define a constructor. What are the salient features of Constructor? Write a Java program to show these
features.
5. How do you overload a constructor? Explain with a program.
6. Define recursion. Write a recursive program to find nth Fibonacci number.
7. Write a program to implement stack operations.
8. What are different parameter passing techniques in Java? Discuss the salient features of the same.
9. What are various access specifiers in Java? List out the behaviour of each of them.
10. Create a Java class called Student with the following details as variables (USN, Name, Branch, Phone
Number). Write a Java program to create n student objects and print USN, Name, Branch, and Phone
number with suitable heading.
11. What is inheritance? Discuss different types of inheritance with suitable example.
12. Discuss the behavior of constructors when there is a multilevel inheritance. Give appropriate code to
illustrate the process.
13. Mention and explain the uses of super keyword in Java.
14. How do you pass arguments to superclass constructor through the subclass constructor? Explain with a
code snippet.
15. Discuss usage of final keyword in Java. Give suitable examples.
16. What do you mean by method overriding? Discuss with a programming example.
17. Explain abstract class and abstract method with suitable code snippet.
18. Write a note on:
a. Use of this keyword
b. Garbage Collection in Java
c. Finalize() method
d. Object Class
e. Dynamic Method Dispatch
19. Create an abstract class called Employee. Include the members: Name, EmpID and an abstract method
cal_sal(). Create two inherited classes SoftwareEng (with the members basic and DA) and HardwareEng
(with members basic and TA). Implement runtime polymorphism (dynamic method dispatch) to display
salary of different employees by creating array of references to superclass.
20. Differentiate method overloading and method overriding.

Dept of ISE, SCE