CONTENTS

Unit Contents Page No.

Introduction to Java
o History of Java
o Features ofJava
o Java Compiler andInterpreter
o JVM (Java VirtualMachine)
o GarbageCollection
o Structure of JavaProgram
1 1-39
o Writing Compiling and Executing SimpleJava Program
o Data Types inJava
o WrapperClasses
o Java NamingConventions
o Input / Output inJava
o Control Structures inJava
o Arrays inJava

Class and Object Concepts

o OOPConcepts
o Concept ofclass
o Adding members (Attributes and Methods) to class
o Defining Objects on aclass
o Using members from class through itsobject
o Concept ofconstructor
2 40-86
o Types ofconstructors
o Passing Arguments toMethods
o Function and MethodOverloading
o Modifiers
o Array of Objects
o Concept ofPackage
o Introduction to ExceptionHandling

“Only for Private Circulation”

 Unit Contents Page No.

Inheritance and Polymorphism

o Concept and Importance ofInheritance
o ‘is-a’Relation
o Types ofInheritance
o Concept ofPolymorphism
3 87-126
o FunctionOverloading
o MemberOverriding
o Dynamic Method Dispatch
o Keywords used in Inheritance – abstract, final, super
o Interface

Concurrent Programming
o Concept ofThreads
o Lifecycle ofThreads
o CreatingThreads
4 127-139
o ThreadClass
o RunnableInterface
o Thread Class Vs. RunnableInterface
o Introduction to ThreadSynchronization

Java Input/Output
o ConceptStreams
5 140-152
o Types ofStreams
o BufferedStreams

Java Applets and GUI

o What isApplet?
o Creating Simple Applet
6 153-174
o AppletLifecycle
o Concept ofAWT
o AWTcontrols

Abbreviations

References

“Only for Private Circulation”

 Java Programming

UNIT - 1
INTRODUCTION TO JAVA
NOTES

Ejcrvgt"Qdlgevkxgu"
To understand –
o Development of Java
o How Java is different than other Programming Languages
o Java Compilation Process and JVM
o Writing Procedure Oriented Programs in Java
o Using Arrays in Java

Jkuvqt{"qh"Lcxc
James Gosling is the person who designed the language in 1991 along with
his team at Sun Microsystems. Initially, the team was developing language to
program processor-controlled home appliances. Controllers were wide in variety
and so language was developed with a feature of ‘not controller specific’. Home
appliances like a set-top box, washing machines, fridge, microwave and many
more. The first version of Java was used to write these controller programs.
During 1994, Gosling realized the need to use the
language for network programming. In 1995 it was
introduced as a network programming language and the
Netscape was the first browser to run java programs.
Nowadays Java is preferred for the development
of robust software. It has become so popular because of
its features, which we are going to discuss in
forthcoming chapters. Though Java is a relatively new
programming language, it is accepted and widely used
for various applications. And as an introduction of new
concepts, makes it more powerful.
How it was named ‘Java’?
Why Logo is ‘Coffee Cup, Saucer, and Steam’?
Every new invention is to be named for its recognition. The developer team
of java was also looking for a suitable name for their new invention. The
development team was named ‘Green Team’ and hence name suggested for the
language was 'Oak'. But afterward, it was learned a language with the same name
was already existing. So now the team was worried about finding a new name.
By making an acronym of team member names they formed a new name as
JAVA (James gosling, Arthur, Van Hoff, Andy Bechtolsheim). Coincidently it is
the name of an island that is famous for coffee beans and all were a fan of it. At
Introduction to Java 1

“Only for Private Circulation”

 Java Programming that moment when the language was being named, all were sitting in a coffee
shop with a cup of coffee having steam. Gosling used the same image as a logo
for the language.
NOTES
Hgcvwtgu"qh"Lcxc
Though java was developed as a general-purpose programming language
to be used for home appliances, after 1995 it was modified and was introduced
with new features to make it compatible to be used on World Wide Web (WWW).
During those days WWW was new and was being adapted for data transmission.
These new features made java an extraordinary and all-purpose programming
language. Points below discuss various features of java.

Qdlgev"Qtkgpvgf"Rtqitcookpi"Ncpiwcig
Java is considered to be pure Object Oriented Language, as everything in
java is an Object. Objective of Object Oriented Programming paradigm is to
provide security to data from unintended processes. Object is a basic entity in
OOP which encapsulates data and processes together.
As an OOP language, it also supports all basic concepts of OOP.
Applications developed using Java can be easily extended or upgraded since it
is based on the Object model. This feature makes java applications more durable.

Rncvhqto"Kpfgrgpfgpv"cpf"Kpvgtrtgvgf"Ncpiwcig
Java is more popular because it is platform-independent. Here platform used
to execute an application or service includes hardware and software, hardware
includes a processor, RAM, etc, while software includes an operating system and
other supporting software. Java programs have a feature that makes them
platform-independent.
The compilation process for Java is different than other programming
languages. When compiler translates the High-Level Langage code to machine
level language it adds some feature to code from platform on which it has been
compiled. Hence the compiled code now requires a platform with the same
configuration on which it has been compiled. Hence the compiled version of
application becomes platform dependent though the language is featured with
'platform-independent'. For example, an application written and compiled using
‘c’ language on windows operating system, can be executed on Windows
operating system only, and cannot be executed on machines with Linux or
Ubuntu operating system.
It is not the case with java. Platform creates a foundation that ensures object
code will execute successfully. Unlike many other programming languages
including C and C++, when Java is compiled, it is not compiled into the platform-
specific machine, rather into platform-independent byte code. This byte code is
distributed over the web and interpreted by the Virtual Machine (JVM) on
whichever platform it is being run on. Additionally, the interpreter makes the
development process more rapid and analytical since the linking is an incremental
and lightweight process. This makes java ‘Architecture Neutral’ and ‘Portable’.

2 Introduction to Java

“Only for Private Circulation”

Ugewtg Java Programming
Java is considered to be a more secure development tool as it enables the
developmentof virus-free, tamper-free systems. Authentication techniques are
based on public-key encryption. NOTES

Ukorng
Syntaxes used in Java are simple and easy to remember. Moreover, java
maintains uniformity for the implementation of basic OOP concepts. Once
formats used in OOP language are clearly understood it becomes very easy to
write programs.
Java programmers follow programming conventions that should be
followed while writing java programs which helps new programmers to be master
of programming. But if anyone follows these conventions it becomes very easy
for him to read and understand programs written in java. These conventions are
given in upcoming sections.

Tqdwuv
Java makes an effort to eliminate error-prone situations by emphasizing
mainly on compile-time error checking and runtime checking. While compiling
java program all possible future run time errors are estimated and accordingly
program is compiled. It also provides a well defined ‘Exception Handling’
technique for handling run time errors. This helps to handle future errors.
In addition to the full proof compilation process, the Java compiler does not
allow the programmer to have any direct access to memory. The memory
management process is taken care of by JVM while executing the program. The
feature is known as ‘Garbage Collection’.

Ownvkvjtgcfgf
With Java's multithreaded feature it is possible to write programs that can
perform many tasks simultaneously. This design feature allows the developers
to construct interactive applications that can run smoothly.

Lcxc"Eqorkngt"cpf"Kpvgtrtgvgt
Compiler and interpreter are the translators which translate the code written
in High-Level Language to Low-Level Language i.e. machine language.
Programming languages other than java either use Compiler or Interpreter. These
translators translate code once and generate machine code which can be executed
on the target processor.
Java uses compiler as well as interpreter. Java program is compiled in
different stages as compiler and interpreter, both are involved in the process. Java
compiler compiles the program and generates bytecode. The generated bytecode
is interpreted through Java Virtual Machine. This feature of java makes it
different from other languages.

Lcxc"eqorkngt"*lcxce"eqoocpf+"cpf"D{vgeqfg
The source code file of Java program is stored with extension ’.java’. Using Introduction to Java 3

“Only for Private Circulation”

 Java Programming ‘javac’ command java source code is compiled, so ‘javac’ accepts source code
file name with extension ‘.java’ as an argument. Compiler, after compiling source
code, as an output generates an intermediate code which is known as "Bytecode",
NOTES whose extension is ‘.class’.
Byte code is the new concept introduced in Java which makes java more
flexible and platform- independent. Bytecode though is a compiled java program,
but like other programming languages, it is not entirely in machine language. It
consists of some java instructions, for executing which we need again interpreter.
These instructions are executed through a virtual machine known as Java Virtual
Machine (JVM), the concept of JVM is discussed in the next point. So bytecode
is not actually an executable code but only translated and ready for execution on
JVM. For executing bytecode JVM is a necessary condition and needs to be
installed on a platform where bytecode is to be executed. Therefore we need to
remember bytecode is a non-executable code.

Gzgewvkpi"Lcxc"Rtqitco"vjtqwij"LXO"*lcxc"eqoocpf+
‘Javac’ command only compiles java program to generate bytecode and to
execute the generated bytecode command ‘java’ is used. The command ‘java’
accepts the bytecode file with extension ‘.class’ as an argument. The command
java executes bytecode through JVM.
Before executing bytecode it is interpreted by JVM and then different
resources required to complete execution of bytecode are provided by JVM.
Generally when a compiled code for any language is executed calls processor
for required resources. In the case of java bytecode, JVM calls processor for the
allocation of required resources. After the allocation of proper resources, the
bytecode is executed. In the next point, we discuss about JVM.
LXO"*Lcxc"Xktvwcn"Ocejkpg+
JVM is the feature of java that makes it portable and secure. The diagram
below explains the structure of the JVM. It is a layer working between the
bytecode and the platform on which the program is to be executed. As discussed
earlier bytecode forwards its requirements to JVM. JVM acts as a virtual machine
for bytecode and satisfies all requirements of it.

Diagram 1.1: JVM’s Working Flow Source:

4 Introduction to Java [Link]

“Only for Private Circulation”

 JVM is a part of the JRE (Java Run Environment). It works as an interpreter Java
Software
Programming
Testing
which converts bytecode to machine-specific machine code. And therefore
though bytecode is machine-independent, JVM is machine-dependent.
Now we will see the architecture of JVM in detail. NOTES

LXO"Ctejkvgevwtg
The following diagram shows components of JVM and its hierarchies. It
contains a classloader, memory area, execution engine, etc.

Fig 1.2: JVM Architecture Source: [Link]

These all components work sequentially as shown in the figure to execute
the program. Every component is explained in short below.
1) ClassLoader – The class loader is a subsystem used for loading class
files. It performs three major functions viz. Loading, Linking, and
Initialization.
2) Method Area - JVM Method Area stores class structures like
metadata, the constant runtime pool, and the code for methods.
3) Heap - All the Objects, their related instance variables, and arrays are
stored in the heap. This memory is common and shared across multiple
threads.
4) JVM language Stacks - Java language Stacks store local variables,
and it’s partial results. Each thread has its own JVM stack, created
simultaneously as the thread is created. A new frame is created
whenever a method is invoked, and it is deleted when the method
invocation process is complete.
5) PC Registers - PC register store the address of the Java virtual
machine instruction which is currently executing. In Java, each thread
has its separate PC register.
Introduction to Java 5

“Only for Private Circulation”

 Java Programming 6) Native Method Stacks - Native method stacks hold the instruction of
native code depends on the native library. It is written in another
language instead of Java.
NOTES 7) Execution Engine - It is a type of software used to test hardware,
software, or complete systems. The test execution engine never carries
any information about the tested product.
8) Native Method interface - The Native Method Interface is a
programming framework. It allows Java code which is running in a
JVM to call by libraries and native applications.
9) Native Method Libraries - Native Libraries is a collection of the
Native Libraries(C, C++) which are needed by the Execution Engine.

Jqy"LXO"ocmgu"Rtqitco"Oqtg"Ugewtg"
The Java VM or Java Virtual Machine resides on the RAM. During
execution, using the class loader the class files are brought on the RAM. The
BYTE code is verified for any security breaches. And consequently, it avoids
direct access to any virus or intruders and makes java programs more secure.

LKV"*Lwuv/Kp/Vkog+"Eqorkncvkqp"
JIT compiler is a part of JVM. Once the class loader loads the classes the
execution engine converts the Bytecode into Native machine code. This is just
in time compiling. It is one of the main reasons why Java is comparatively slow.
JIT works as an interpreter, which interprets bytecode to machine code. Hence
Java is known as the language which is compiled and interpreted.

Ictdcig"Eqnngevkqp
Variables and objects declared in the program being executed occupy
memory. This occupied memory needs to be freed when the variables are not
being used. This freed memory now can be utilized for other purposes. Java
provides an inbuilt facility to free memory occupied by unused objects and
variables. Java is characterized by ‘garbage collector’, who is responsible for the
removal of unused and unreached objects. Unlike other programming languages,
java programmer does not need to worry about the destruction of unnecessary
objects. It is done automatically. Garbage Collector is a Daemon thread that keeps
running in the background. Basically, it frees up the heap memory by destroying
the unnecessary objects. The objects not referenced by any part of the program
are the one which are removed.
For allocating memory block for an object heap memory is used. After a
certain time interval, the garbage collector keeps on checking and destroying
heap for unreachable objects. As the number of objects goes on increasing the
checking time also increases. For this destruction process, some strategy needs to
be applied. The system needs to decide which objects to be kept and which to be
removed. The adopted methodology is called Generational Garbage Collection.
6 Introduction to Java

“Only for Private Circulation”

 The JVM is responsible for the classification and collection of objects. The Java Programming
process carried out by JVM to collect garbage is known as ‘Garbage Collector’.
Again for using Garbage Collector, there are different four strategies. Users,
while using JVM for execution, can select any of these Garbage Collectors. All NOTES
these four Garbage Collectors are generational, i.e. to destroy the object or not
is based on its generation. Every Garbage Collector has its own advantages and
disadvantages, which are discussed one by one. The selection of Garbage
Collector affects throughput of execution.

Uvtwevwtg"qh"lcxc"rtqitco
In this section, we are going to see the basic structure of the java program.
Java is case sensitive language. Java compiler differentiates between capital
letters and small letters and therefore while writing the program in java we have
to be careful about cases of instructions. Maximum syntaxes in java are in small
case. The basic syntax of the java program is like ‘c’ only, as it is developed using
‘c’. The only big difference in ‘c’ and ‘java’ is all instructions in java are written
within the class, as java is a pure object- oriented program. Following syntax
shows how a simple procedure-oriented java program can be written–
/*These are non-executable statements which can denote a block*/ package
<package name>;
import <package name>; class <class name>
{
public static void main(String argv[])
{
//This is also a non-executable statement for single line
//Code to be executed in main()
}
}

Vjg"cdqxg/ikxgp"u{pvcz"hqt"lcxc"rtqitco"ecp"dg"gzrnckpgf"cu"⁄
• The statements which are marked to be non-executable, ignored by the
compiler, are written either within ‘/*…*/’ or if it is a single line it should
start with ‘//’.
• Very first line of java program is declaration of package. It is optional to
write the line. If the program is to be declared as a part of the package,
the program starts with the line. But if the program is not part of any
package, it is not necessary to write the line.
• The next line is ‘import’. The ‘import’ statement is like ‘include’ directive
in ‘c’. It is used to add predefined packages to the program. These
packages are collections of classes and functions and when the developer
wants to use these members from the package, these packages need to Introduction to Java 7

“Only for Private Circulation”

 Java Programming import using ‘import’ statement. Java compiler does not need to import
any basic packages like ‘System’ is the package which defines basic
system handling functionalities and does not need to import this package.
NOTES So like package ‘import’ is also optional.
• Then we start with the keyword ‘class’, which starts with the class
definition. Java is pure OOP language. Every instruction of java is written
within class. The keyword ‘class’ is followed by the class name. The class
declaration is followed by delimiters that define the scope of the class.
Variables and methods defined within the scope of the class are members
of the class.
• Here in class, we start with the definition of function ‘main( )’. It is the
function from which execution of the program starts. Processor while
execution of program searches for function ‘main( )’ first. The function
main() is defined as ‘public static void main(String args[])’. It is
explained below –
o public – As java is pure OOP language, it is defined as a member
function of a class, and hence is assigned with an access modifier,
which is always ‘public’, so that can be accessed outside the
class.
o static – As a member of a class to access it always needs an object
on the class to which it belongs to. But to call main we don’t have
any object and hence need to be called without the object. The
members which are declared to be static can be accessed without
object, hence ‘main( )’ is defined to be static.
o void – The main() is called by the processor and hence it does
not return anything, and hence its return data type is void.
o String args[] – Function main( ) accepts command-line arguments
that are accepted as an array of strings. Java defines ‘String’ as a
system defined class.
• The function main( ) is followed by delimiters, which defines the block
of instructions to be executed on call to main( ).
/*First Welcome Program in Java*/
/*It is independent program and not part of any package, so no package
instruction*/
/*Here only System package is used, so no need to import any package*/
class Welcome
{
public static void main(String args[])
{
8 Introduction to Java

“Only for Private Circulation”

 [Link](“Welcome to World of Java”); Java Programming

}
} NOTES
By using the above structure a simple welcome program is shown in the
following block – This block shows how a simple java program looks. In the
next subsection, we will see how to save, compile and execute this program.

Ytkvkpi."Eqorknkpi"cpf"Gzgewvkpi"c"Ukorng"Lcxc"Rtqitco
In this section, we are going to see how we can write, compile and execute
a java program. Here we will see three steps for writing and executing Java
program -
i. Writing Source Code –
There are a number of IDEs (Integrated Development Environment)
like ‘eclipse’, ‘NetBeans’ etc. which helps in writing, compiling and
executing Java programs. But here we are going to see how a java
program can be written, compiled and executed using notepad and
command prompt. To write source code using notepad, this is a basic
editor for writing any high-level program. Any java program can be
written in the following steps –
a. Open notepad application.
b. Type your source code.
c. Save your source code file with extension ‘.java’ in your folder.
For example, suppose we type the above program using notepad and
save it with the name ‘[Link]’.

ii. Compiling Source Code –

For compiling source code for java program command prompt is used.
Follow the given steps to compile the java program.
Introduction to Java 9

“Only for Private Circulation”

 Java Programming a. Open command prompt.
b. Set path to ‘bin’ folder in ‘java\jdk’ folder by using the command
C:\>set path=”c:\program files\java\jdk1.5.0\bin”
NOTES
c. Change drive where the program folder is stored. Suppose your
programs are stored on ‘D’ drive then –
C:\>D:
D:\>
d. Change directory to your desired directory. For eg. If your
programs are stored in the directory ‘java’ directory then –
D:\> cd SLM
D:\SLM>
e. Now we are ready to compile source code for java program. To
compile a program the command used is ‘javac’, which is given
in the following format –
D:\SLM>javac [Link]
If there are any errors in the program those will be shown right after
the command. For example, if we change line – System. out.
print(“Welcome to World of Java”); as – [Link](“Welcome
to World of Java”); and we compile the program, then the error
message is shown as below –

To debug the program go to source code, make necessary changes,

save files and again compile the program. Now it will not give any
error message and will compile the program successfully. After
successful compilation of program check again contents of the
directory, and you can see the following change in the directory –

10 Introduction to Java

“Only for Private Circulation”

 One more file is added to your folder with extension ‘.class’, whose Java Programming
name is the same as class name in source code. This file is known as
‘Byte Code’, and is executed with the help of JVM, as we have
discussed in subsection 1.3.3. NOTES
Now the program is ready to execute. In the next subsection, we will
discuss how to execute the Byte Code.

iii. Executing Java Program –

Byte Code is executed using command ‘java’. The command accepts
the class file name as an argument. The command is case sensitive and
hence accepts class name as it has been given in source code, so take
care while giving class name. The following image shows how our
program is executed in the command window.

In the command window, we can observe that command java accepts

only class name without extension. If the program accepts command
line arguments those are to be passed with ‘java’ command. We will
discuss input in chapter 5.

Fcvc"V{rgu"kp"Lcxc
Before starting the discussion on data types in java, we need to know
something about variables in java. As the name suggests, variables are used to
store data which may vary from one execution to others. The data used in any
program is of two types – constants and variables. Data or value for constant is
known while writing the program, for example, while calculating the area of
circle value of i.e. 3.14. While value for the variable is not known to the
programmer and will be accepted as input from the user, for example, the value
of the radius of the circle for calculating the area of the circle. Here the value of
the radius will go on changing user to user and hence programmer needs to
declare the variable with a proper data type to store its value. Here a programmer
needs to make the decision about the data type of the variable as well as the name
of the variable. About data type, we are going to discuss in detail but before that,
we will discuss rules which has to be followed while assigning a name to a
variable. If any of these rules are not followed then the compiler gives an error,
hence to avoid these errors firstly we will see these rules in detail.

Introduction to Java 11

“Only for Private Circulation”

 Java Programming Rules for assigning variable names –
• It should be meaningful so that while reading the program it will be easy
to understand the use of the variable.
NOTES
• Allowed characters set to be used for variable name is alphabets (‘A-Z’,
‘a-z’), digits (‘0-9’) and ‘_’. Any other special symbol is not allowed to
be used in the variable name.
• Every variable name should start with an alphabet. The first alphabet can
be followed by other allowed character set.
• If the variable name consists of two words then those should be separated
by ‘_’ and not space.
• The name can be of any length, but don't extend too long.
• It should be unique in a function block.
• It should not be a keyword or reserved word from java.
• Java is case sensitive and it differentiates between small case characters
and upper case characters.

Following table shows some proper and improper variable names –

Proper variable Names – cust1, customer_name, customerName,
Improper variable Names – cust#1, customer name, class
If the programmer follows these rules while defining variables then it
becomes easy for writing, reading and debugging of programs.
While declaring any variable, which is used to store data, need to assign
with data type. Data types describe following information about variable –
• The type of value will be stored by variable.
• Range of value assigned to the variable.
• Number of memory bytes to be allocated for variable. Basically, data
types are categorized as –
• Primitive Data Types: These are called primitive as these are defined
by the processor. The primitive data types include boolean, char, byte,
short, int, long, float and double.
• Non-primitive Data Types: The non-primitive data types are either
derived data types like arrays, strings or user-defined data types which
include Classes and Interfaces.

12 Introduction to Java

“Only for Private Circulation”

 The following diagram explains the categorization of data types in java. Java Programming

NOTES

Fig 1.3: Data Types in Short

Source: [Link] Firstly we will
discuss primitive data types in detail.

Lcxc"Rtkokvkxg"Fcvc"V{rgu
As shown in the above figure java avails a wide variety of primitive data
types. These primitive data types are basic building blocks of data manipulation.
These are the most basic data types available in the Java language. Java is a
statically-typed programming language. It means all variables must be declared
before its use. That is why we need to declare the variable's type and name.
There are eight different primitive data types which help the user to
categorize and process different type of data :
• Boolean data type
• byte data type
• char data type
• short data type
• int data type
• long data type
• float data type
• double data type

Cnn"rtkokvkxg"fcvc"v{rgu"ctg"fkuewuugf"kp"fgvckn0
1. Boolean Data Type
It is used to store Boolean value, ‘true’ / ‘false’. In java, unlike ‘c’, the
return of relational and logical operators is also of type Boolean. The
Introduction to Java 13

“Only for Private Circulation”

 Java Programming branching and looping statements in java work depending on Boolean
return. The Boolean data type specifies one bit of information, but its
"size" can't be defined precisely. For example – boolean flag = false;
NOTES It is a java statement that defines a variable ‘flag’ of type Boolean and
is initialized with value false.

2. Byte Data Type

As shown in figure it is a numerical data type. It is an 8-bit signed
two's complement integer. Its value-range lies between -128 to 127
and the default value are 0. When the range of value to be stored is
small then for saving memory, instead of an integer, the byte data type
can be used. It saves space because a byte is 4 times smaller than an
integer. For example - byte n = 10;
The instruction declares variable ‘n’ with type ‘byte’. Here ‘n’ is
allocated with one byte.

3. Short Data Type

It is again a variety of integer which occupies two bytes in memory.
Its value-range lies between - 32,768 to 32,767 and default value is 0.
Just like ‘byte’, it can be also used when memory needs to be saved.
A short data type is 2 times smaller than an integer. For example –
short s = 10000;
The above instruction declares a variable ‘s’ of type ‘short’ and
occupies two bytes of memory.

4. Int Data Type

As in ‘c’ language, int data type stores whole is a 32-bit signed two's
complement integer. Its value-range lies between - 2,147,483,648 (-
2^31) to 2,147,483,647 (2^31 -1) (inclusive). Its default value is 0.
The int data type is generally used as a default data type for integral
values unless if there is no problem with memory. For example – int a
= 100000;
Here variable ‘a’ is declared of type ‘int’.

5. Long Data Type

The long data type is a 64-bit two's complement integer. Its value-
range lies between - 9,223,372,036,854,775,808(-2^63) to
9,223,372,036,854,775,807(2^63 -1)(inclusive). Its default value is 0.
The long data type is used when you need a range of values more than
those provided by int. for example – long a = 100000L;
The above instruction declares the variable ‘a’ of type long. While
initializing long variables value is postfixed with either ‘l’ or ‘L’, which
helps to differentiate between ‘int’ and ‘long’.
14 Introduction to Java

“Only for Private Circulation”

 6. Float Data Type Java Programming
The float data type is a single-precision 32-bit IEEE 754 floating-point.
Its value range is unlimited. It is recommended to use a float (instead
of double) if you need to save memory in large arrays of floating-point NOTES
numbers. The float data type should never be used for precise values,
such as currency. Its default value is 0.0F. For example – float f1 =
234.5f like ‘long’, float constants are also postfixed with either ‘f’ or
‘F’, so that values can be differentiated from double.

7. Double Data Type

The double data type is a double-precision 64-bit IEEE 754 floating-
point. Its value range is unlimited. The double data type is generally
used for decimal values just like float. The double data type also should
never be used for precise values, such as currency. Its default value is
0.0d. For example – double d1 = 12.3

8. Char Data Type

The char data type is a single 16-bit Unicode character. Its value-range
lies between '\u0000' (or 0) to '\uffff' (or 65,535 inclusive).The char
data type is used to store characters. For example - char letterA = 'A'
Character constants are enclosed within single quotes.
The following table explains data types of their default value and memory
size. At a glance, it will help you to remember the features of each datatype.

Ytcrrgt"Encuugu
Data types known as primitive data types as they cannot be decomposed
further. As well as all basic instructions like input/output, operators, etc. can
process these primitive data types directly.
Introduction to Java 15

“Only for Private Circulation”

 Java Programming But sometimes the programmer faces certain situations where he needs to
process variables before processing. For example conversion from one data type
to another, known as ‘type-casting’ or ‘Data Type Conversion’. ‘C’ provides a
NOTES header file ‘stdlib.h’ which defines data type conversion functions.
Java compiler is strict about the implicit conversion of data types. For the
purpose, java provides classes for all built-in or primitive data types known as
‘Wrapper Classes’. These classes treat variables for data types as objects, and
hence handling becomes easy. All the wrapper classes (Integer, Long, Byte,
Double, Float, Short, Character, Boolean) are subclasses of the abstract class
Object. The class hierarchy for Wrapper classes is shown in the diagram. In the
hierarchy, we can observe that for every primitive data type a wrapper class has
been defined. These wrapper classes help to wrap a primitive data type in an
object, and hence different functionalities, defined as member methods in a
wrapper class, can be carried out easily.

Fig. 1.4: Class Hierarchy for Wrapper Classes

Source: [Link]
[Link]
For example – the command line arguments which are read in ‘String’ and
need to be converted to respective data type then here for conversion we can use
wrapper classes. To convert ‘String’ to ‘int’ wrapper class is used as shown in
the following instruction –
int number=[Link](arg[0]);
In the above instruction ‘Integer’ is a wrapper class. The class defines a
method ‘parseInt’ which accepts an argument of type ‘String’ and converts to an
integer. Here ‘arg[0]’ denotes the command-line argument, which is discussed
in detail in the next section.

Lcxc"Pcokpi"Eqpxgpvkqpu
Below are some naming conventions of java programming language. They
must be followed while developing software in java for good maintenance and
readability of code. For each element of the program in java, some conventions
are defined. While writing any java program if we follow those then it becomes
16 Introduction to Java easy to differentiate between different elements of the program.

“Only for Private Circulation”

Xctkcdngu Java Programming
• While assigning variable names use small case letters.
• If want to connect two words for example ‘customer’ and ‘name’, then
NOTES
the second word should start with a capital letter like ‘customerName’.
This convention is followed for each element of the program, only there
is a change in the first letter depending on the element.

Encuugu"cpf"Kpvgthcegu
• Class names and interface names should be a noun.
• The first letter of name should be capital letters and remaining in small
letters for example ‘Student’.
• Two connected words should start with a capital letter.
• Use whole words and must avoid acronyms and abbreviations.

Ogvjqfu
• Methods should be a verb.
• Should be in small letters.
• Two connected words should start with a capital letter.

Eqpuvcpv"xctkcdngu
• Should be capital letters with words separated by underscores (“_”).

Rcemcigu
• It should be small letters.

Kprwv"1"Qwvrwv"kp"lcxc
Before writing programs in java, we will discuss input and output in java.
Input statements allow the user to provide input for the program. While output
statements allow the user to display the output of the program. Java provides a
wide variety of input, which is discussed in detail in Chapter 5. Preliminary in
the next subsection we are going to discuss command line arguments.

Kprwv"vjtqwij"Eqoocpf"Nkpg"Ctiwogpvu
Like other programming languages, java allows the user to enter data
through the command prompt. Arguments passed through command prompt are
passed as arguments for function ‘main()’. These arguments are accepted as an
array of strings. The first value passed starts with string array. Following program
shows how command-line argument is passed –
In the above program main accepts arguments from the command prompt
which gets stored with String array ‘arg’. By accessing elements from array ‘arg’
we can read passed arguments. In the program, the argument value is assigned
Introduction to Java 17

“Only for Private Circulation”

 Java Programming to the variable ‘name’ of type String. The following command window shows
the execution of the above program. While executing class we need to pass one
value to the program.
NOTES /*Accepting input through command prompt*/ class Input
{
public static void main(String arg[])
{
String name=arg[0]; [Link]("Your Name is "+name);
}
}
In a program, if the programmer tries to read arguments through command
prompt, but while executing class values are not passed then an Exception is
thrown named as ‘ArrayIndexOutOfBoundsException’. The exception thrown
is shown in the following command window.

While executing the program processor expects some argument from the
command prompt to build an array of Strings with the name ‘arg’. But here as
arguments are not passed, ‘arg’ remains empty array. But in execution, an
instruction tries to read values from the empty array as ‘arg[0]’. Hence processor
throws runtime error, an exception.

When the user passes arguments through command prompt, those all of type
‘String’. In the program, we need a different type of values, and hence these
command-line arguments need to be converted to the intended data type using
conversion methods from Wrapper classes. It is shown with the help of the
following the program –
18 Introduction to Java

“Only for Private Circulation”

 /*Converting command-line arguments to proper data types*/ class Java Programming
Conversion
{
NOTES
public static void main(String arg[])
{
int i=[Link](arg[0]); float f=[Link](arg[1]);
double d=[Link](arg[2]); [Link]("i=
"+i+"\nf="+f+"\nd="+d);
}
}

In the above program, we have used different conversion functions for

converting ‘String’ values to different data types. The output for the program is
shown in the command window.

While passing the input through command prompt values are passed in
sequence as int, float and double. In the same way, you can try for the ‘boolean’
data type.

Ikxkpi"Qwvrwv"wukpi"U{uvgo0qwv0rtkpv*+
In the above-given program, we have used instruction to display values of
variables –
[Link]("Your Name is "+name);
The statement above uses three keywords which we need to understand first.
Here ‘System’ is a class defined in ‘[Link]’ package. The class ‘System’
defines all necessary members which are required by the processor for basic
functionalities. The class ‘System’ defines three basic objects ‘in’, ‘out’ and
‘error’, which helps in handling basic functionalities. ‘out’ is an object on
PrintStream which outputs on the console. Using object ‘out’, which is a member
of the class ‘System’, we call the member method ‘print( )’. ‘print’ method helps
to display passed String on console. Here ‘print’ is a member of object ‘out’,
while ‘out’ is a member of class ‘System’, therefore to access them we use
Introduction to Java 19

“Only for Private Circulation”

 Java Programming membership operator (.) as ‘[Link]’. ‘print’ method accepts one
argument of type ‘String’. Passed ‘String’ value is displayed on the console as
an output. In the above statement, we have passed ‘String’ constant, and hence
NOTES the message is enclosed within double quotes (“…”).
Java has defined a class ‘String’ which helps the user to process strings as
normal data types. Therefore in java working with strings has become easy. In
the message, we have used the ‘+’ operator to add the value of the variable ‘name’
to string constant. The ‘String’ class allows the user to concatenate two string
using the operator ‘+’. Therefore we got a message when the value of ‘name’ is
‘Bharati’ as “Your Name is Bharati”.
In addition to the ‘print’ method, java has one other method ‘println’ which
adds a new line symbol at the end of the message.
Using escape sequences as in ‘c’ we can format the output. ‘\n’ is used to
move the control to the next line, while ‘\t’ is used to move the control to the
next tab stop.

Eqpvtqn"Uvtwevwtgu"kp"Lcxc
Using input, output and operators now it is possible for us to write simple
programs that deal with ‘input+process+output’. To alter the sequential execution
of instructions we need to know about control structures.

Dtcpejkpi"Uvcvgogpvu
When we have a choice of two different processes and have to select one
of these two, then we can go for branching statements. Like in ‘c’, java has also
‘if’ and ‘switch’ statements which allow us for branching.
1. if – Syntax for ‘if’ statement is given below –
if(<condition>)
{
<block to be executed when condition is true>
}
[else
{
<block to be executed when condition is false>
}]

‘if’ is followed by a condition in brackets. While writing condition we

can make use of relational and logical operators. In java relational and
logical operators return a boolean value, hence ‘if’ works depending
on a Boolean value. If the value is ‘true’ it executes the block given
20 Introduction to Java after ‘if’, otherwise the block after else is executed. ‘else’ block after
“Only for Private Circulation”
 ‘if’ is optional and so it is given in square brackets. Syntax for the Java Programming
statement ‘if’ is explained with the help of given flowchart –

NOTES

The following program demonstrates the use of ‘if’.

/*if in java for displaying maximum out of two numbers*/ class Max
{
public static void main(String arg[])
{
int num1=[Link](arg[0]); int num2= [Link]
(arg[1]); if(num1>num2)
{
[Link](num1+" is Maximum");
}
else
{
[Link](num2+" is Maximum");
}
}
}

Introduction to Java 21

“Only for Private Circulation”

 Java Programming The above program accepts two integers as command-line arguments
and using ‘if’ it checks the
relation between these two numbers using relational operator ‘>’.
NOTES When the given relation is satisfied it goes for the execution of block
given after ‘if’, otherwise it goes for block after ‘else’. Output for the
program is shown in the following command window.

Here two values passed are ‘45’, which is assigned to ‘num1’, and ‘82’
is assigned to ‘num2’. When ‘if’ is executed it goes for ‘num1>num2’.
Return of use of this relational operator is ‘false’, hence control goes
for execution of else block.

2. Nested ‘if’
In a situation where we need to check one more condition after
checking a condition then we go for nested ‘if’. In nested ‘if’ one ‘if’
is written within another ‘if’. Syntax for ‘nested if’ is shown below –
if(<condition>)
{
.
.
If(<condition>)
{
<block to be executed when condition is true>
}
else
{
<block to be executed when condition is false>
}
.
.
}
[else
22 Introduction to Java

“Only for Private Circulation”

 { Java Programming
.
.
NOTES
if(<condition>)
{
<block to be executed when condition is true>
}
else
{
<block to be executed when condition is false>
}
.
.
}]

As shown in syntax we can write ‘if’ within another ‘if’. When on the
condition is satisfied we want to check one more condition, then
‘nested if’ is used. 'if’ can be nested within ‘if’ as well as ‘else’ block.
The following program demonstrates the use of nested ‘if’.
/*if in java for displaying maximum out of three numbers*/
/*Nested if*/ class MaxThree
{
public static void main(String arg[])
{
int num1=[Link](arg[0]); int num2=
[Link](arg[1]); int num3=[Link](arg[2]);
if(num1> num2)
{
if(num1>num3)
{
[Link](num1+" is Maximum");
}
else
{
Introduction to Java 23

“Only for Private Circulation”

 Java Programming [Link](num3+" is Maximum");
}
}
NOTES
else
{
if(num2>num3)
{
[Link](num2+" is Maximum");
}
else
{
[Link](num3+" is Maximum");
}
}
}
}

Output for the program is shown below –

3. switch…case –
When a programmer needs to write nested if for multiple conditions,
where only one of the blocks is executed then nested if ladder can be
replaced by ‘switch’. ‘switch’ statement allows the user to check
multiple conditions and also reduces the complexity of the program.
Syntax for ‘switch’ is given below -
switch(<conditional variable>)
{
case <value1> :
<block of statements if value matches with value of variable> case <value2>
:
24 Introduction to Java

“Only for Private Circulation”

<block of statements if value matches with value of variable> Java Programming
.
.
NOTES
.
default :
<block of statements if value matches with value of variable>
}

The keyword ‘switch’ is followed by the name of the conditional

variable. Block for ‘switch’ defines different cases, where for each
case possible value for the conditional variable is given. ‘switch’ block,
thus, defines multiple cases. After all cases, the final case is given as
‘default’. Every case defines its own instruction block which is
executed on the satisfaction of value given after case. Here equality
condition is checked, for every case, it checks if the value of variable
matches with case value. When both values are matched the cases
onwards are executed. The use of ‘switch..case’ is demonstrated with
the help of the following program.
/*switch...case in java */ class Switch
{
public static void main(String arg[])
{
int num1=[Link](arg[0]); int num2=[Link](arg[1]); int
opt=[Link](arg[2]); int result=0;
switch(opt)
{
case 1:
[Link]("You have selected option of
addition.");
result=num1+num2;
[Link]("Result of addition is "+result); break;
case 2:
[Link]("You have selected option of
subtraction.");
result=num1-num2;
[Link]("Result of sutraction is "+result); break; Introduction to Java 25

“Only for Private Circulation”

 Java Programming case 3:
[Link]("You have selected option of
multiplication.");
NOTES
result=num1*num2;
[Link]("Result of multiplication is "+result); break;
case 4:
[Link]("You have selected option of
division.");
result=num1/num2;
[Link]("Result of division is "+result); break;
default:
[Link]("You have selected wrong option.\nPlease execute
program once again by giving option from 1 to 4.");
}
}
}

The program works like a calculator to carry out one of the four
operations on two integers. The program accepts three command-line
arguments from the user, first two are numbers on which arithmetic
operation will be carried out, while third is the option number for the
operation. As the program gives four different options for handling it
nested if it is required, which becomes complex. Here nested if can be
replaced by ‘switch..case’. Every case in switch mentions the option
number when the option is matched with the case, the case is executed.

The above command window shows output for the above program.
Here three executions for the same program are shown. For the first
two executions options are 3 and 1 entered, and according to option
26 Introduction to Java ‘case 3’ and ‘case 1’ is executed respectively. But in the third execution

“Only for Private Circulation”

 option entered is ‘5’ which is not considered by ‘switch’, and hence Java Programming
here the ‘default’ case is executed.
In every case in program, the programmer has used a ‘break’ statement,
which is discussed in the next subsection. NOTES

4. break and continue –

All control structures (branching and looping) goes on the execution
of the assigned block depending on the satisfaction of a condition.
When abnormally we need to break the execution then we can use the
statement ‘break’. As against this to continue with the execution
statement ‘continue’ is used.
As discussed in ‘switch..case’, once a case is satisfied switch goes on
executing all cases sequentially. To break this normal execution
sequence with every case we have used a ‘break’ statement.
You check the output for the same input values after removing the
‘break’ from each case.

Kvgtcvkxg"Uvcvgogpvu
Iterative statements are used when the execution of the same instruction
block is to be repeated. Iterative statements are categorized under two headings
– top tested and bottom tested. As the name suggests top tested statements test
output of condition before entering the block, on the other hand, bottom tested
statements test output of the condition at the end of the block. Both works
depending on the output of Boolean value but the place of accepting Boolean
value changes their nature of execution. As top tested checks value while
entering, if it is false the block is not executed, while bottom tested as tests at
the end though the value is false it is executed at least for one time. ‘for’ and
‘while’ are top tested statements while ‘do..while’ is bottom tested statement.
Now we will discuss each statement in detail.
1. while
It is top tested iterative statement syntax for which is given as –
while(<condition>)
{
<block to be executed iteratively>
}
At the entry of block, it checks for the condition, if the output of the
condition is false, it does not enter the block, and control is passed to
the nested statement after block. The following program shows the
working of the ‘while’ statement.

Introduction to Java 27

“Only for Private Circulation”

 Java Programming /*while iterative statement */
/*Program to print numbers from 1 to n*/ class While
{
NOTES
public static void main(String arg[])
{
int n=[Link](arg[0]); int cnt=1; [Link]("Numbers : ");
while(cnt<=n)
{
[Link](cnt+" "); cnt++;
}
}
}

The program above accepts one command line argument which is an

integer assigned to variable ‘n’. ‘cnt’ is working as a counter, which is
initialized to ‘1’. And then we start with ‘while’, where before entering
in the block it compares the value of ‘cnt’ with the value of ‘n’ and if
the condition is satisfied control enters in block given after ‘while’.
But if the condition is not satisfied control bypasses the block.
The command window below shows output for the program. It shows
output for two executions. For the first execution value for ‘n’ is
passed as ‘5’, and as an output it displays 1 to 5 numbers. For the
second time, the passed value is ‘0’. For this value, while the loop is
not executed as the value of ‘cnt’ is greater than ‘n’ and hence no
numbers are displayed.

2. Do…while
It is bottom tested iterative statement syntax for which is given as –
do
{
<block to be executed iteratively>
} while(<condition>);
28 Introduction to Java

“Only for Private Circulation”

 At the entry of block, it checks for the condition, if the output of the Java Programming
condition is false, it does not enter the block, and control is passed to
the nested statement after block. The following program shows the
working of the ‘while’ statement. NOTES
/*do..while iterative statement */
/*Program to print numbers from 1 to n*/ class DoWhile
{
public static void main(String arg[])
{
int n=[Link](arg[0]); int cnt=1; [Link]("Numbers : ");
do
{
[Link](cnt+" "); cnt++;
} while(cnt<=n);
}
}

The program is the same as our previous program using ‘while’. Here
we have replaced ‘while’ with ‘do..while’ statement. There is no
change in the program, but a change in output can be observed. The
output of the first execution is the same as for ‘while. For the second
execution where value entered for ‘n’ is zero, the number ‘1’ has been
displayed. This is because of the use of ‘do..while’. Though here
condition ‘cnt<=n’ is not satisfied, the block is executed one time.

3. for –
Like while ‘for’ is also a top tested iterative statement. Syntax for the
statement ‘for’ is given as below –
for(<initialization>;<condition>;<increment/decrement>)
{
<block to be executed iteratively>
}
Introduction to Java 29

“Only for Private Circulation”

 Java Programming Advantage of ‘for’ over ‘while’ is, in the syntax of ‘for’ along with the
condition we can initialize and increment or decrement value for
conditional variable. Following program demonstrates the use of ‘for’
NOTES –
/*for iterative statement */
/*Program to print numbers from 1 to n*/ class For
{
public static void main(String arg[])
{
int n=[Link](arg[0]); [Link]("Numbers : "); for(int
cnt=1;cnt<=n;cnt++)
{
[Link](cnt+" ");
}
}
}

The above program replaces ‘while’ statement by ‘for’. So like ‘while’,

here we do not need to initialize and increment ‘cnt’ separately. Output
for the program is the same as ‘while’ which is shown in the following
command window.

Cttc{u"kp"Lcxc
Array is a derived data type that allows the user to define ‘collection’. Hence
an array is defined as –
“ A collection of variables of similar data type which shares the same
name, and are stored in memory contiguously”
Continuous allocation of all elements in an array is one of the characteristics
of array elements. When users need a number of variables used in a program,
which are of the same data type then he can make use of arrays. Another
characteristic of array elements is ‘random access’. Though it is a collection each
element can be accessed randomly like a normal variable. The following
subsections explain the details of the arrays.
30 Introduction to Java

“Only for Private Circulation”

Fgenctkpi"Cttc{u Java Programming
Like normal variables, before using arrays we need to declare arrays. With
the declaration, arrays are not allocated in memory and allocation for an array is
done separately. NOTES
Syntax for declaring arrays is given as –
<data type> array_name[] ; OR
<data type> []array_name; OR
<data type>[] array_name;

Allocation of memory for an array is done using following syntax –

array_name = new <data type>[<size>];
In the above instruction actual memory is allocated for an array. Declaration
and instantiation for an array are done separately when the size of an array is not
known. Collectively, when the size of an array is known while the declaration of
an array, declaration and allocation can be done using the following syntax -
<data type> array_name[] ;= new <data type>[<size>];
Once an array is instantiated it occupies continuous memory in RAM. Total
memory allocated for an array is calculated as –
int arr[]=new int[10];
Total memory for array = size of array X bytes occupied by data type for
array Those many continuous bytes get allocated for an array. Every array
element individually can be referenced by its index number. Suppose we have
declared the array as below –
Then allocation for the array is shown with the help of following
diagram
arr[0] arr[1] arr[2] arr[3] …….. …….. arr[9]
Fig 1.5: Memory Allocation for array ‘arr’
As shown in the above diagram every element in array ‘arr’ occupies four
bytes and for the entire array ‘10X4’ bytes, a total of 40 bytes gets allocated. All
elements from the array ‘arr’ are allocated contiguously. Every element in the
array is initialized with the default value for the data type.

Kpkvkcnk|kpi"cpf"Ceeguukpi"Cttc{"Gngogpvu
In java declaration, allocation and initialization of array as shown below –
int arr[]={34,7,27,81};

the above instruction declares array with instruction ‘int arr[]’ and with the
instruction ‘={34,7,27,81}’ it instantiates and initializes the array. Here
Introduction to Java 31

“Only for Private Circulation”

 Java Programming sequentially the values gets assigned as – arr[0]=34, arr[1]=7, arr[2]=27,
arr[3]=81.
When we want to access array elements we can either access them
NOTES sequentially or randomly. While accessing elements sequentially we can use
iterative statements like ‘for’. In an iteration, we maintain a counter which
indicates the index of an element. Following code shows how we can access
array elements sequentially –
for(int i=0;i<5;i++)
{
[Link](" "+a[i]);
}

While accessing array elements we use index number for an element. An

index of an element is an individual identity for it. Index for an element is
enclosed within square brackets written after the array name. For example–
arr[5]=12;
here above instruction assigns value ’12’ to 6th element in an array. Thus
by using an index of an element, we can randomly access elements from an array.
For sequential access, we can use the ‘for’ loop. Initialization and accessing
array elements are shown in the following program.
/*Arrays in java */ class Array
{
public static void main(String arg[])
{
int a[]={4,7,2,1,7};
[Link]("Elements in Array 'a' are : "); for(int i=0;i<5;i++)
{
[Link](" "+a[i]);
}
}
}

In the above program, we have declared, initialized and instantiated array

‘a’. Using ‘for’ we are displaying all array elements sequentially.

32 Introduction to Java

“Only for Private Circulation”

 Java Programming

NOTES

V{rgu"qh"Cttc{u
Till this time we have discussed only one-dimensional array, now in this
section we will discuss two dimensional arrays. Two-dimensional arrays are a
combination of rows and columns and hence while defining two-dimensional
array we need to mention the number of rows and columns. Syntax for defining
two-dimensional array is given as –
<data type><array name>[][]=new <data type>[<number of
rows>][<number of columns>];
For example, the following instruction shows how a two-dimensional array
can be declared –
int a[][]=new int[2][3] ;
While initializing two-dimensional array every row is written within curly
brackets which is shown with the following instruction –
int a[][]={{2,7,4},{9,1,8}} ;
For accessing array elements sequentially, like in one-dimensional array,
we need to use nested loops.
The outer loop represents rows while the inner loop represents columns.
Accessing array elements sequentially is shown with the following code –
/*Arrays in java */ class Array2D
{
public static void main(String arg[])
{
int a[][]={{2,7,4},{9,1,8}} ;
int j;
[Link]("Elements in Array 'a' are : "); for(int i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
[Link](" "+a[i][j]);
} Introduction to Java 33

“Only for Private Circulation”

 Java Programming [Link]("\n");
}
}
NOTES
}

Output for the above program is given in the command window below.

Uqog"Cttc{"Qrgtcvkqpu
In this subsection, we will see how we can perform some operations on
arrays. The following programs and their outputs demonstrate different
operations carried out on arrays of both types one dimensional and two
dimensional.
1. Adding two one dimensional arrays –
/*Arrays in java */ class AddArray1D
{
public static void main(String arg[])
{
int a[]={2,7,4};
int b[]={9,1,8};
int c[]=new int[3]; int i;
[Link]("Elements in Array 'a' are : "); for( i=0;i<3;i++)
{
[Link](" "+a[i]);
}
[Link]("Elements in Array 'b' are : "); for(i=0;i<3;i++)
{
[Link](" "+b[i]);
}
[Link]("Elements in Array 'c' after addition are : ");
34 Introduction to Java

“Only for Private Circulation”

for(i=0;i<3;i++) Java Programming
{
c[i]=a[i]+b[i];
NOTES
[Link](" "+c[i]);
}
}
}

2. Scalar multiplication for one dimensional array –

/*Arrays in java */ class Scalar1D
{
public static void main(String arg[])
{
int a[]={15,12,17};
int b=6;
int c[]=new int[3];
int i;
[Link]("Elements in Array 'a' are : "); for( i=0;i<3;i++)
{
[Link](" "+a[i]);
}
[Link]("Scalar 'b' is : "+b); [Link]("Elements in
Array 'c' after
Scalar Multiplication are : ");
for(i=0;i<3;i++)
{
c[i]=a[i]*b; [Link](" "+c[i]);
}
}
} Introduction to Java 35

“Only for Private Circulation”

 Java Programming

NOTES

3. Finding largest from one-dimensional array –

/*Arrays in java */ class Largest1D
{
public static void main(String arg[])
{
int a[]={15,12,17,56,23};
int l=a[0]; int i;
[Link]("Elements in Array 'a' are : "); for( i=0;i<5;i++)
{
[Link](" "+a[i]);
}
for(i=0;i<5;i++)
{
if(l<a[i])
{
l=a[i];
}
}
[Link](" Largest Number in Array : "+l);
}
}

36 Introduction to Java

“Only for Private Circulation”

4. Adding two two-dimensional arrays – Java Programming
/*Arrays in java */ class Add2D
{
NOTES
public static void main(String arg[])
{
int a[][]={{15,12,17},{56,23,32}};
int b[][]={{24,82,19},{7,51,29}};
int c[][]=new int[2][3]; int i,j;
[Link]("Elements in Array 'a' are : "); for( i=0;i<2;i++)
{
for( j=0;j<3;j++)
{
[Link](" "+a[i][j]);
}
[Link]("\n");
}
[Link]("Elements in Array 'b' are : "); for( i=0;i<2;i++)
{
for( j=0;j<3;j++)
{
[Link](" "+b[i][j]);
}
[Link]("\n");
}
[Link]("Elements in Array 'c' are : "); for( i=0;i<2;i++)
{
for( j=0;j<3;j++)
{
c[i][j]=a[i][j]+b[i][j];
[Link](" "+c[i][j]);
}
[Link]("\n");
}
}
}

Introduction to Java 37

“Only for Private Circulation”

 Java Programming

NOTES

5. Multiplication of two two-dimensional arrays –

/*Arrays in java */ class Multiplication2D
{
public static void main(String arg[])
{
int a[][]={{2,6,7},{1,3,4},{1,8,3}};
int b[][]={{0,5,2},{3,9,1},{2,6,1}};
int c[][]=new int[3][3]; int i,j,k;
[Link]("Elements in Array 'a' are : "); for( i=0;i<3;i++)
{
for( j=0;j<3;j++)
[Link](" "+a[i][j]); [Link]("\n");
}
[Link]("Elements in Array 'b' are : "); for( i=0;i<3;i++)
{
for( j=0;j<3;j++)
[Link](" "+b[i][j]); [Link]("\n");
}
[Link]("Result After Multiplication : "); for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{ c[i][j]=0;
for(k=0;k<3;k++)
c[i][j]+=a[i][k]*b[k][j];
[Link](c[i][j]+" ");
}
[Link]();
}
}
}
38 Introduction to Java

“Only for Private Circulation”

 Java Programming

NOTES

*****

Introduction to Java 39

“Only for Private Circulation”

 Java Programming

UNIT - 2
CLASS AND OBJECT
NOTES

CONCEPTS

Ejcrvgt"Qdlgevkxgu"
To understand –
o Characteristics of OOP Languages
o Defining and Using Classes
o Hiding data in classes using different Modifiers
o Defining and Using Package
o Exception Handling in Java

Qdlgev/Qtkgpvgf"Eqpegrvu"kp"Lcxc
Object-Oriented Programming is the outcome of the need for providing
security to data to be processed by different programming constructs
(functionalities). The basic requirement of any software is to process data. While
performing different operations on data, one needs to keep the data safe from
processes that change this valuable data. This need had given rise to OOP
concepts which are discussed below.

Fcvc"Jkfkpi"cpf"Fcvc"Cduvtcevkqp
With the POP (Procedure Oriented Programming) paradigm the problem
faced is ‘data security’. In POP there is no provision to provide any protection to
data from processes. These processes may access and change data.
When a user needs data-centric software, where data is valuable and needs
to protect from intended access by processes. This has given rise to the need to
hide data from processes. To provide protection to data from processes there is a
need to hide data. This was the reason why they need for the new paradigm was
felt. Data hiding was the basic concept of OOP.
To hide data from the external environment one needs to abstract data with
the help of the concept of ‘data abstraction’. With the help of data is grouped
together to explain an object. For example, to store data of an employee in a
company, we can group data, which explains an employee like employee id,
employee name, joining date, department, and name this group as ‘Employee’.
Here group name ‘Employee’ is abstraction which helps to hide unnecessary
Class and Object information from others.
40 Concepts

“Only for Private Circulation”

Fcvc"Gpecruwncvkqp Java Programming
Encapsulation means providing protection to internal contents from the
external environment. The concept of encapsulation of data helps to hide data.
The concept of encapsulation, data is kept along with the predefined processes NOTES
which are designed to process data. The concept of data hiding is implemented
through data encapsulation. The concept helps the developer to bind Data and
processes together. These are the processes to which data is directly available
and hence can carry out operations on it. The external environment can have
access to this data through these processes and can carry out those many
operations only. Diagrammatically concept of data encapsulation can be
represented as in figure 2.1.
In the figure, it can be observed that data is surrounded by methods
(functions), who are responsible for protecting data from the external
environment. These methods P1 to P6 can be accessed by the external objects
and can process data.

Fig 2.1: Data Encapsulation

Encuu
Class is a software construct that helps to implement above-discussed
concepts of Data hiding, data abstraction, and data encapsulation. Class allows
the programmer to define their own abstraction. It is a template that helps to bind
data and operations on data together. Class is a blueprint of objects and explains
how objects can store and process data. The class definition also allows adding
visibilities to its members at different levels i.e. visibility at class level, or at the
object level, for derived class and so on.

Qdlgev
Object is a runtime entity. On a class, user can define an object which helps
to store and process data. Class does not occupy any memory space, but the object
occupies memory. Objects hold their own personal data which cannot be shared
with other objects in the system if the class does not permit to share it. For eg.
On class Employee if two objects are defined namely ‘objE1’ and ‘objE2’ then
these two objects are used to store data for two different employees which cannot
be shared or processed by each other if class ‘Employee’ does not define such
method.
Class and Object
Concepts 41

“Only for Private Circulation”

 Java Programming Kpjgtkvcpeg
In real life child (next generation) derives properties from their parents
(previous generation) and hence the property can be reused. On the same basis,
NOTES the concept of ‘Inheritance’ allows to reuse the predefined attributes from its
super or base classes. ‘Inheritance’ helps in data sharing between two classes,
hence defines the relationship between two classes known as ‘Generalization’.
The concept helps in adding new features to existing software with minor changes
in data format. Due to the introduction of inheritance, Object-Oriented software
became more durable and easily upgradable.

Rqn{oqtrjkuo
It is a Greek word which means ‘one thing with many forms’. In OOP from
the programmer's point of view to introduce easiness in programming and to add
the feature of ‘dynamic binding’ or ‘runtime binding’, the concept of
‘Polymorphism’ was introduced. Following two programming constructs helps
to implement polymorphism in programs –
• Method Overloading – The concept allows the developer to define
different function blocks with the same name and varying either number
or type of arguments.
• Method Overriding – inheritance allows the developer to reuse
properties from predefined class, while Overriding allows the developer
to modify functionalities from predefined class without changing their
names.
These two concepts support static binding. For dynamic binding virtual
functions are used which is implemented in java with the help of –
• Dynamic Method Dispatch – As the name suggests it decides runtime
the method for which object is to be executed where references are
defined for classes that are arranged hierarchically.

Oguucig"Rcuukpi"qt"Cuuqekcvkqp
The basics behind the development of the OOP paradigm are to provide
security to data. Hence ‘Object’, the basic entity of the OOP program which is
responsible to carry out major programming tasks, tries to hide data from the
external environment i.e. other components (objects) of system. If every
individual component of the system tries to hide system data from each other,
then the system cannot work properly. Therefore there is a need to have
communication among different components. This communication can be
developed with the help of ‘message passing’ or ‘association’. If any component
from the system, for completing its task needs some data from others, it can send
a message to the component. In return, the associated component will send the
required data. This association is defined with the help of methods added in class.
But the association between two classes needs to be defined at the design level.
Class and Object This message passing takes place between two objects. For [Link] to generate bill
42 Concepts

“Only for Private Circulation”

object on the class ‘Bill’, ‘objB1’, needs the price of product stored with object Java Programming
‘objP1’, then objB1 will send message to objP1. In return, objP1 will send value
stored with its price attribute to objB1. Here objP1 shares only required data,
while other details are hidden. NOTES

Fghkpkpi"c"encuu
In this section, we are going to see how to define a class in java. As
discussed earlier, the class helps the user to encapsulate data and methods
together to implement data abstraction. Class is assigned with name, which is
treated as User Defined Data type in java. Syntax for defining class is given as
below-
<access modifier>class <class name>
{
/*Definition of members*/
}
In the above syntax, we can observe that the class definition starts with an
access modifier, which decides the visibility of class. The access modifier is
optional and if not mentioned java compiler treats it as a default modifier and is
accessible within the same package. Access modifiers are discussed in upcoming
chapters.
After access modifier, the keyword ‘class’ is used, which explains compiler
that a new user-defined data type is being defined. The keyword is followed by
‘class name’.
The class name defines a new user-defined data type, which decides how
and how much bytes should be allocated. The name assigned to class always is
a noun and helps to get an idea about what data is being presented.
The class name is followed by delimiters that define the scope of the class.
The attributes (variables) and methods (functions) defined within these delimiters
are covered under the scope of the class and hence are known as members of the
class.
For example, if a class to be defined to store data of an employee working
in a company, is explained with the help of the following code.
public class Employee
{
/*Definition of members in class Employee*/
}

The above code snippet explains how to start the definition of the class. The
code is explained below- Class and Object
Concepts 43

“Only for Private Circulation”

 Java Programming public – It is a keyword and access modifier.
Employee – It is a class name that defines a new data type with the name
‘Employee’.
NOTES
For completing the class definition we need to add members to it. The
following two sections explain how to add members to the class.

Cffkpi"Cvvtkdwvgu"vq"Encuu
The word ‘attribute’ means the properties or characteristics of an object.
These properties help to describe and understand an object. Properties of an
object are stored with the help of variables which are defined as members within
the class. Syntax for adding attributes in a class is as below –
<access modifier> class <class name>
{
<access modifier><data type><attribute name>;
/*Definition of methods*/
}
Now we will see the explanation for highlighted instruction. The instruction
gives syntax for defining attributes in a class. The syntax is explained below.
• Access modifier – To add visibility to the attribute access modifier is
used. It is optional, if not mentioned ‘default’ access modifier is assigned.
• datatype – Every attribute needs to be defined with data type, which
explains the type of value stored by an attribute.
• attribute name – Name of the attribute which helps in referring it. The
attribute names should follow the same rules as for the variable name.
There is no restriction on the number of attributes can be added to the class.
A class developer can add any number of attributes as per requirement. Following
code, snippet explains how a class can be defined –
public class Employee
{
protectedintempId, private intbasicSal;
private String empName, address;

/*Definition of method members in class Employee*/

}
In the class employee four attributes are defined, empId, basicSal,
empName and address. From these four attributes, empId is ‘protected’ while all
Class and Object remaining are ‘private’. The attributes with ‘protected’ access are accessible to
44 Concepts

“Only for Private Circulation”

the derived class, while ‘private’ attributes are accessible within the class. Java Programming
Datatype of two (empId, basicSal) is ‘int’, which can store whole numbers, while
others are of type ‘String’, which is a system-defined class and allows processing
of character arrays. NOTES
Every object on a class will have its own set of attribute and its values. This
data becomes the object's private data depending on its access modifiers. Object
does not share this data with any other objects.

Cffkpi"Ogvjqfu"vq"Encuu
While discussing data hiding and encapsulation, we have discussed, as an
OOP language, java allows the user to encapsulate (group) data and methods
processing on data together. Methods are user- defined functions that define a
process block to process data. These methods can be executed by an object to
process its own data. As these methods are predefined, other than these methods
any process cannot be carried out on data by the external environment. Syntax
for adding methods to the class is given below–
<access modifier> class <class name>
{
<access modifier><data type><attribute name>;
<access modifier><return data type><method name>(<list of arguments>)
{
<process block>
}
}

The above-highlighted text explains the syntax for defining a method in a

class. It can be observed that the syntax is the same as the syntax for defining
user-defined function; the only difference is adding access modifier to the
method. Every part of the syntax is explained below-
• access modifier – It adds visibility to the method. Mostly methods are
assigned with a ‘public’ access modifier.
• return data type – It explains what type of value will be returned by the
method by its calling function.
• method name – Method name is used to call the method using the object.
While naming the method rules are the same as for naming a function.
• list of arguments – Values that are passed while calling the method are
known as arguments. While defining method in brackets list of arguments
along with their data types separated by commas.
Class and Object
Concepts 45

“Only for Private Circulation”

 Java Programming • process block– After defining function process block is defined within
delimiters. The process block defines the process to be carried out on
data.
NOTES Like attributes, any number of methods can be added to the class. The
following code explains how methods can be added to the class.
public class Employee
{
protected intempId, private intbasicSal;
private String empName, address;
public void setData(inteid, intbsal, String ename, String add)
{
empId=eid; basicSal=bsal; empName=ename; address=add;
}
public StringgetName(void)
{
return(empName);
}
}

In the above code, two methods are defined one is setData and getName.
These two methods are public which are accessible out of class using the object.

Etgcvkpi"Qdlgevu"qp"c"encuu
A class helps the developer to define his own data type which encapsulates
data and methods operating on it together. It is a blueprint of data, but cannot be
used to store and data. Data can be stored and processed with the help of objects
declared on a class. Object is a runtime entity and occupies memory to store data.
Through object methods and attributes, defined with public access specifier can
be accessed. Before defining objects for class make sure that source code for the
class is compiled to generate its bytecode.
Syntax for defining an object on class is given in following code –
<class name> <object name>;
It can be observed that syntax for defining an object is the same as defining
a variable for built-in data types. Java treats the class as a normal data type and
allows to use class name as a data type while defining an object. Following code
explains how an object can be defined on predefined class -
Class and Object Employee objEmp;
46 Concepts

“Only for Private Circulation”

 The above code defines an object on class Employee with name ‘objEmp’. Java Programming
Here compiler firstly searches for ‘Employee’ class file and reference for object
gets allocated. If the compiler does not get the class definition then it will generate
an error. NOTES
The above syntax creates a reference to the object, yet the memory block
to store data is to be assigned. Memory to store data for an object is allocated
with the keyword ‘new’. Its syntax is given below –
<object name> = new <class name>( );
‘new’ is an operator in java which allocates memory for an object and
returns its starting address to the reference of the object. Here class name is used
as a function call, which is actually a call to the constructor for the class. The
constructor is responsible for constructing an object. Constructors are discussed
in detail in the next subtopic. The following code explains how memory gets
allocated for object ‘objEmp’ on class ‘Employee’.
objEmp = new Employee( );
In the above code ‘Employee’ gives a call to the constructor for class
‘Employee’ which constructs an object and ‘new’ keyword is responsible for the
allocation of a memory block for an object ‘objEmp’.

Uvgru"hqt"Etgcvkpi"Qdlgev
Following steps should be followed to avoid errors –
(1) Define a class with proper attributes and methods.
(2) Compile class to have its ‘.class’ file with you.
(3) Compile program which declares object on class.
As discussed earlier, while declaring an object, bytecode (‘.class’ file) for
class definition should be available. The bytecode for each class definition is
generated after compiling ‘.java’ file. There are different methods of how a class
and its object can be declared –

k+ Fghkpkpi"encuu"kp"vjg"ucog"uqwteg"hkng"⁄
Here we are going to discuss how we can define two classes, one is user-
defined while the other is to implement it, in one source file with extension
‘.java’. After compiling this file two bytecode files are generated. While
executing these class files we need to execute the bytecode file for the class which
contains function ‘main()’.
It is explained with the help of following code –
/*Source code file name : [Link]*/
/*Definition for class Employee which is user-defined class*/ class
Employee
Class and Object
{
Concepts 47

“Only for Private Circulation”

 Java Programming protected int empId; private int basicSal;
private String empName, address;
public void setData(int eid,int bsal,String ename, String add)
NOTES
{
empId=eid; basicSal=bsal; empName=ename; address=add;
}
public String getName()
{
return(empName);
}
}
/*Definition for class EmpImp which implements class Employee*/ class
EmpImp
{
public static void main(String arg[])
{
Employee objEmp=new Employee();
[Link](10,20000,"XYZ","Pune");
String name=[Link]();
[Link]("\nEmployee name for objEmp is
"+name);
}
}

The above program defines two classes where ‘Employee’ is a user-defined

class while ‘EmpImp’ is the class for implementing class ‘Employee’. Class
‘EmpImp’ defines only one method ‘main()’, which starts the execution of the
program. As discussed in the steps firstly we need to compile the source code
file. After compiling this single source code file two bytecode files will be
generated, namely ‘[Link]’ and ‘[Link]’. To execute the
program, the class file for the class which defines the method ‘main()’ is
executed. Commands entered at the command prompt and its output is given
below.

Class and Object

48 Concepts

“Only for Private Circulation”

 Java Programming

NOTES

kk+ Fghkpkpi"encuu"kp"cpqvjgt"uqwteg"eqfg"hkng"kp"ucog"fktgevqt{/
Under this option we create two different source code files, one for defining
user defined class while another to implement it. While storing these two files
take care that both files will be in same folder. Following two codes explains the
program.
/*Source code file name : [Link]*/
/*Definition for class Employee which is user defined class*/ public class
Employee
{
protected int empId, private int basicSal;
private String empName, address;
public void setData(int eid,int bsal,String ename, String add)
{
empId=eid; basicSal=bsal; empName=ename; address=add;
}
public String getName()
{
Return(empName);
}
}
Firstly create first source file and save it with name ‘[Link]’. Then
create second source code file and save it with name ‘[Link]’.
While compiling files from command promptnow two different files should
be compiled. First compile file ‘[Link]’, which creates ‘[Link]’.
In the next step compile file ‘[Link]’. This creates class file for
‘[Link]’. to execute the code execute class file ‘EmpImp’, as it contains
function main().
/*Definition for class EmpImp which implements class Employee*/ public
class EmpImp1
{
public static void main(String arg[])
Class and Object
{ Concepts 49

“Only for Private Circulation”

 Java Programming Employee objEmp=new Employee();
[Link](10,20000,"XYZ","Pune");
String name=[Link]();
NOTES
[Link]("\nEmployee name for objEmp is "+name);
}
}
Compiling and execution of the file on command prompt is shown in the
following image.

kkk+ Fghkpkpi"encuu"kp"cpqvjgt"uqwteg"eqfg"hkng"kp"qvjgt"fktgevqt{"⁄
Here with this option a package is created having definition of class and the
package is added to the source code using ‘import’ command. The process of
creating package and using classes from package is explained in section 2.7.

Ceeguukpi"Ogodgtu"htqo"encuu"wukpi"Qdlgev"
In the previous section we have seen that object is used to store data and
process data. Object is an entity which can access members of class depending
on their visibility. In this section we are going to discuss how members in class
can be accessed.
Membership operator (‘.’) is used to access members using object. Syntax
for accessing member is given below –
<object name>.<member name>;
The above syntax helps to access members for class. In the last code snippet
in ‘main()’ function we can observe, how members from class can be accessed
using object on class.
[Link](10,20000,"XYZ","Pune");
In the above code ‘objEmp’ is the object on class Employee, while
‘setData()’ is member method with access modifier ‘public’. When this member
method is to be called, it is called through object on class ‘Employee’ using
membership operator.

Eqpuvtwevqtu
In 2.3 section we have discussed about declaring object on class. While
Class and Object allocating memory space for an object, as mentioned earlier, we use keyword
50 Concepts

“Only for Private Circulation”

‘new’ which allocates memory for an object and class name as a function call Java Programming
which executes constructor who constructs an object. In this section we are going
to discuss about term ‘constructor’ and what is it’s role.
Constructor is a function block which is executed while creating a new NOTES
object on a class. Role of the constructor is to initialize an object. Constructor
definition appears to be same as a method in class. But it cannot be considered
as a method from class as it does not have any return data type. It’s name is same
as class name. Hence on the basis of these two points we can differentiate
between constructor and normal method from class.

Ejctcevgtkuvkeu"qh"Eqpuvtwevqt"
• It is a method without any return data type. Its return type is class type.
Constructor from any class constructs object and return its reference, and
so there is no need to define any data type for constructor.
• Its name is same as class name. Other than constructor any other method
cannot have same name as class name.
• It is executed by processor while creating an object without any explicit
call.
• Its access modifier depends on developer. Developer can decide who can
use the constructor to construct an object. This point is again discussed
in detail while discussing inheritance.

Pggf"qh"Eqpuvtwevqt"
Whenever, an object on a class is defined, needs to be allocated and
initialized. Initialization of an object is the task carried out by the constructor.
Initialization can be done either by processor or user can write his own
constructor.
For example if an object named ‘objEmp’ is declared on class ‘Employee’,
before calling any method using object to process data from object, it needs to
be initialized. It is done explicitly by constructor.

Fghkpkpi"c"Eqpuvtwevqt"kp"c"encuu"
If any class does not define any constructor then also objects on class are
allocated and initialized, but the initial values assigned are same for all objects.
If developer wants to initialize objects with their own personalized values while
being declared, he can add constructor to the class definition. A user defined
constructor in a class helps to initialize an object at the same time when it get
allocated with memory.
Defining constructor is nothing but adding a method to class definition with
same name as class name and without any return data type. While discussing
types of constructors (section 2.4.4) various syntaxes along with sample code for
defining a constructor are discussed in detail. Class and Object
Concepts 51

“Only for Private Circulation”

 Java Programming V{rgu"qh"Eqpuvtwevqt"
There are various ways how a constructor can be defined for a class. In any
OOP language there are three types of constructors –
NOTES
k+ Fghcwnv"Eqpuvtwevqt
Default constructor is also called as ‘constructor without arguments’ or ‘no-
argument constructor’. It does not accept any arguments from user while creating
object. Under this type there are again two types of default constructor –

*3+ U{uvgo"Fghkpgf"Eqpuvtwevqt
We have discussed that any object cannot be declared without constructor,
and therefore every class, while compiling, needs constructor definition. If
developer has not defined constructor in class, compiler adds its own constructor
to class definition. Here the constructor added by compiler is ‘default constructor’
or ‘no argument constructor’. This constructor initializes the object attribute to
either zero or to null depending on its data type.
Following code explains working of a system defined constructor.
/*Source code file name : [Link]*/
/*Definition for class Employee which is user defined class*/ class
Employee
{
protected int empId; private int basicSal;
private String empName, address;
public void setData(int eid,int bsal,String ename, String add)
{
empId=eid; basicSal=bsal; empName=ename; address=add;
}
public void displayEmpData()
{
[Link]("\nID : "+empId+"\nName : " + empName + "\nAddress
: " + address);
}
}
/*Definition for class EmpImp which implements class Employee*/ class
EmpImp
{
public static void main(String arg[])
Class and Object
52 Concepts

“Only for Private Circulation”

 { Java Programming
Employee objEmp=new Employee();
[Link]();
NOTES
[Link](10,20000,"XYZ","Pune"); [Link]();
}
}

Output for the above program is given in following window –

In the above output window data for same object has been displayed for
two times. Firstly when method ‘displayEmpData()’ is executed it shows zero
value for ‘empId’ which is numerical variable, while ‘null’ for ‘empName’ and
‘address’ which are String variables. This initialization is done using system
defined default constructor.
Compiler can add only default constructor to the class definition.

*4+ Wugt"Fghkpgf"Fghcwnv"Eqpuvtwevqt"⁄
If user wants to assign his own initial values to attributes in an object then
he can define his own constructor without any arguments, which is known as
user defined default constructor. User can add his own default constructor by
modifying class definition with following syntax–
<access modifier> class <class name>
{
<access modifier><data type><attribute name>;
<access modifier><class name> ()
{
<process block>
}
Class and Object
<access modifier><return data type><method name>(<list of arguments>) Concepts 53

“Only for Private Circulation”

 Java
Software
Programming
Testing {
<process block>
}
NOTES
}

In the above block of syntax highlighted text shows syntax for adding user
defined default constructor to the class.
The constructor definition starts with access modifier, generally for
constructor it is ‘public’. In certain situations it may be defined as ‘private’ or
‘protected’.
Access modifier is followed by class name. Constructor, as discussed earlier,
is a special method having same name as class name. It does not have any return
data type so though it a method here return data type is not mentioned.
After class name empty brackets are given, which denotes constructor does
not accept values while getting call. It is no argument constructor and therefore
it is known as default constructor.
With the help of following program we can understand use of default
constructor.
/*Source code file name : [Link]*/
/*Definition for class Employee which is user defined class*/ class
Employee
{
protected int empId; private int basicSal;
private String empName, address;
public Employee()
{
empId=0; empName="XXX";address="Pune"; basicSal=1000;
}
public void setData(int eid,int bsal,String ename, String add)
{
empId=eid; basicSal=bsal; empName=ename; address=add;
}
public void displayEmpData()
{

Class and Object [Link]("\nID : "+empId+"\nName : "+empName+"\nAddress

54 Concepts

“Only for Private Circulation”

 : "+address); Java
Software
Programming
Testing
}
}
NOTES
/*Definition for class EmpImp which implements class Employee*/ class
EmpImp
{
public static void main(String arg[])
{
Employee objEmp=new Employee(); [Link]();
[Link](10,20000,"Prashant","Pune"); [Link]();
}
}
In the above code method ‘public Employee()’ defines user defined default
constructor. Following image shows output of the above program. In the output
we can see two different values for ‘objEmp’ data. Before execution of
‘setData()’ method for the object, ‘displayEmpData()’ method displays the object
data which is initialized by user defined default constructor. The constructor
initializes empId to zero, empName to “XXX”, basicSal to 1000 and address to
“Pune”.
After execution of setData() method object is set with new data values.

kk+ Rctcogvgtk|gf"Eqpuvtwevqt
The constructor which accepts arguments is called parameterized
constructor. As against to default constructor, parameterized constructor
initializes the object with passed values and hence every object defined on a class
can have their own personalized values. The syntax for defining a parameterized
constructor is given below –
<access modifier> class <class name>
{
<access modifier><data type><attribute name>;
<access modifier><class name> (<list of parameters along with data type>) Class and Object
Concepts 55

“Only for Private Circulation”

 Java Programming {
<process block>
}
NOTES
<access modifier><return data type><method name>(<list of arguments>)
{
<process block>
}
}
In the above syntax highlighted text explains syntax for defining
parameterized constructor to the class. Only difference in user defined default
constructor and parameterized constructor is it accepts parameters from calling
function.
When a class defines parameterized constructor, required parameters are
passed while defining object on class. Syntax for defining object on a class with
parameterized constructor is given as below –
<class name><object name> = new <class name>(<values to be passed as
parameters>;
Here the syntax is same as defining an object on class. It differs only by
passing values with which the object will be initialized.
Use of parameterized constructor is shown in the following code –
/*Source code file name : [Link]*/
/*Definition for class Employee which is user defined class*/ class
Employee
{
protected int empId; private int basicSal;
private String empName, address;
public Employee(int eid,int bsal,String ename, String add)
{
empId=eid; basicSal=bsal; empName=ename; address=add;
}
public void displayEmpData()
{
[Link]("ID : "+empId+"\nName : "+empName+"\nAddress :
"+address);

Class and Object }

56 Concepts

“Only for Private Circulation”

 } Java Programming
/*Definition for class EmpImp which implements class Employee*/ class
EmpImp
NOTES
{
public static void main(String arg[])
{
Employee objEmp1=new Employee(10,20000,"Prashant","Pune");
[Link]();
Employee objEmp2=new Employee(11,22000,"Poonam","Mumbai");
[Link]();
Employee objEmp3=new Employee(12,24000,"Ankita","Delhi");
[Link]();
}
}
Output after execution of the program is given as –

In the above output data is displayed for three objects, ‘objEmp1’,

‘objEmp2’ and ‘objEmp3’. All these three objects store data for three different
employees. Because of user defined constructor, now instead of using ‘setData()’
method to assign values to objects, use parameterized constructor helps. Now in
this program there is no need to define setData() method. Assigning data and
allocating memory these two different operations are carried out with single
instruction. This is the advantage of parameterized constructor.

kkk+ Eqr{"Eqpuvtwevqt
When data from one object is to be copied to other object, the copy
constructor is defined. Copy constructor is a parameterized constructor which
accepts reference to object. Data from this passed object is to be copied to newly
created object. Following program explains copy constructor.
/*Source code file name : [Link]*/
/*Definition for class Employee which is user defined class*/ class Employee Class and Object
Concepts 57

“Only for Private Circulation”

 Java Programming {
protected int empId; private int basicSal;
private String empName, address;
NOTES
/*First constructor : User defined Default Constructor*/ public Employee()
{
empId=0; basicSal=1000; empName="XXX"; address="Pune";
}
/*Second constructor : Copy Constructor*/ public Employee(Employee e)
{
empId=[Link]; basicSal=[Link]; empName=[Link];
address=[Link];
}
public void setData(int eid,int bsal,String ename, String add)
{
empId=eid; basicSal=bsal; empName=ename; address=add;
}
public void displayEmpData()
{
[Link]("ID : "+empId+"\nName : "+empName+"\nAddress :
"+address);
}
}
/*Definition for class EmpImp which implements class Employee*/ class
EmpImp
{
public static void main(String arg[])
{
Employee objEmp1=new Employee();
[Link](10,20000,"Prashant","Pune");
[Link]();
Employee objEmp2=new Employee(objEmp1);
[Link]();
}
}
Class and Object
58 Concepts

“Only for Private Circulation”

 In class Employee there are two constructors. Defining two constructors in Java Programming
a class is known as ‘Overloading of Constructor’. The concept of overloading is
explained in Chapter 3.
Here first constructor is ‘user defined default constructor’, which helps to NOTES
create blank objects. Hence in this class we have defined method ‘setData( )’ to
assign data values to object attributes. The second constructor is copy constructor.
It is parameterized constructor as it accepts one parameter while getting executed.
For the constructor argument is reference of the object whose values are to be
copied. In java, unlike other OOP languages, object name itself is treated as
reference. We have already discussed this in the section 2.2 creating objects on
a class.
Two objects namely ‘objEmp1’ and ‘objEmp2’ are defined on class
‘Employee’. Object ‘objEmp1’ is a blank object, created using default
constructor, for which data is assigned using method ‘setData( )’.
While for creating ‘objEmp2’ copy constructor is used. For the constructor
reference for ‘objEmp1’ is passed as argument. When copy constructor is
executed data from ‘objEmp1’, in constructor which is named as ‘e’, is copied
to each attribute for newly allocated object. And therefore new object is initialized
with data from the object received as argument to copy constructor.
Following image gives output for the above program. First data here is for
first original object ‘objEmp1’, while next data is for its copied object ‘objEmp2’.

Rcuukpi"xcnwgu"vq"hwpevkqpu
Every function block stores its values as local values and accessible within
the block only. When a call to another function block is given and if a block need
values from calling function block these values need to be passed while giving
call. These passed values are known as arguments. Following program shows
why one needs to pass values to functions –
/*Passing values to functions*/ class PassArguments
{
static int sqWithArg(int c)
{
return(c*c); Class and Object
Concepts 59

“Only for Private Circulation”

 Java Programming }
static int sqNoArg()
{
NOTES
return(2*2);
}
public static void main(String args[])
{
int a;
a= [Link](args[0]); int s1=sqWithArg(a);
[Link]("\nSquare of "+a+" is "+s1); int s2= sqNoArg();
[Link]("\nSquare of 2 is "+s2);
}
}
Following image shows output for the above program. In the program two
user defined functions are defined, one with name ‘sqWithArg’ and ‘sqNoArg’.
First function with name ‘sqWithArg’ accepts one argument of type integer and
returns after calculating square for the number passed by calling function and
hence every time returned resultant value depends on value passed by the calling
function. While the second one is without argument which calculates square of
number ‘2’ and returns it, hence every time it returns answer as ‘4’. This is
because value of variable ‘a’ is local to block main( ), and not accessible to
function ‘sqNoArg’. Consequently when a function block needs to process values
from calling function, those need to be passed to function.

In any programming language a function accepts values from calling

function. While passing values two basic concepts are used –
• Pass by value
• Pass by Reference
Following two subsections discuss about ‘pass by value’ and ‘pass by
reference’. These concepts define how these arguments are passed to the function
blocks. When a variable is stored in RAM it has two references, one is it name
Class and Object and other is its memory location address, in ‘c’ which is referred as pointer. Using
60 Concepts

“Only for Private Circulation”

any of these two references variable value can be referred. On this basis these Java Programming
two concepts are based.

Rcuu"d{"Xcnwg NOTES
In pass by value first type of reference to value is used. While giving call
to function name of the variable is passed to called function. Here value of the
variable, whose name is mentioned, is passed to block and is copied to passed
function block with new variable name, and so the concept is known as ‘pass by
value’.
The program given above is the function with ‘call by value’. Here while
giving call to function ‘sqWithArg()’ variable ‘a’ is passed to function. When
control is transferred to function ‘sqWithArg()’ from ‘main( )’ it is transferred
with value of ‘a’ and it is assigned to variable ‘c’. The value of ‘c’, which is
actually value of ‘a’, is processed and resultant value is returned to calling
function.
Drawback of ‘pass by value’ is, if called function does not return value to
calling function, calling function cannot get result.

Rcuu"d{"Tghgtgpeg
In pass by reference, instead of passing value its memory address is passed
to calling function. Now calling function can access value from the address
directly and hence the process on value is carried out at the memory location
directly. So in this concept though calling function does not return any value, the
original value is changed.
But java does not support ‘pass by reference’. While discussing
characteristics of java, it is discussed that java does allow user to access memory
directly. It is to make it platform independent, JVM decides strategies for
managing memory. But this feature does not allow java developer to write
functions for pass by reference.

Hwpevkqp"Qxgtnqcfkpi
Concept of function over loading comes under Polymorphism. Using a
single function name with either different number of arguments or different type
of arguments is known as ‘Function Overloading’. The concept is discussed in
detail in chapter 3 under Inheritance and Polymorphism.

Oqfkhkgtu
While defining functions and variables along with data type different
modifiers can be added to add some more features to their accessibility while
execution of program. All modifiers are classified under four categories which
are discussed in following sub sections.

Class and Object

Concepts 61

“Only for Private Circulation”

 Java Programming Ceeguu"Oqfkhkgtu
Any OOP language provides these three keywords which helps add
visibility and accessibility to members from class. While discussing OOP
NOTES concepts in section 2.1, we have discussed that ‘class’ helps developer to achieve
objective of data hiding and data encapsulation, and to hide data from external
processes access modifiers helps to add visibility to class members at different
levels. There are three access modifiers –
• Private
• Public
• Protected
These three are used as keywords and can be used only with members
defined within class. Every access modifier is discussed below in detail –

k+ Rtkxcvg"
It is a keyword used with members which are accessible within class
definition only. Delimiters given after class name define scope of class. Private
members scope is within class, i.e. these members can be accessed within these
two delimiters. Following syntax shows scope of private members –
class <class name>
{
private <data type><member name>;
.
.
.
}
Highlighted area shows scope for the private members. Member definition
is preceded by keyword private. Private member is accessed like a normal
variable. Though it is a member of a class, to access private member there is no
need of object. Following program shows how a private member can be defined
and used.
class PrivateDemo
{
private int n;
}
Here ‘n’ is an integer variable whose access modifier is ‘private’ and hence
it is accessible within class definition. If we execute following code it will
generate compilation error –
Class and Object
class PrivateDemo
62 Concepts

“Only for Private Circulation”

 { Java Programming
private int n;
}
NOTES
class PrivateDemoImp
{
public static void main(String arg[ ])
{
PrivateDemo objPrivateDemo = new PrivateDemo(); objPrivateDemo.n=5;
}
}

Vjg"gttqt"ikxgp"d{"eqorkngt"ku"ikxgp"cu"⁄

Therefore when these private members need to be initialized it needs to be

accessed using some different methods, which we are going to discuss in next
subsection. Generally data members which will be used to store sensitive data
and needs to be protected are assigned with private access modifier.

kk+ Rwdnke
This is another keyword which allows user to add other type of accessibility
to members. These are members who are accessible in class as well as outside
the class definition. When public members are accessed within class it can be
accessed directly like normal variables, but outside the class definition these are
accessed through object. Following syntax shows how to declare and access data
members.
class <class name>
{
public <data type><member name>;
}
Here as the scope of public member is outside the class also, so there is no
highlighted text. Class and Object
Concepts 63

“Only for Private Circulation”

 Java Programming <class object name>.<member name>;
Following syntax shows how public member can be accessed outside the
class using its object.
NOTES
Following program code shows how public members are helpful in
accessing private members outside the class –
class PublicDemo
{
private int n;
public void setData(int a)
{
n=a;
}
public void display()
{
[Link]("n="+n);
}
}
class PublicDemoImp
{
public static void main(String arg[ ])
{
PublicDemo objPublicDemo = new PublicDemo();
[Link](5); [Link]();
}
}
Now we can observe that using public methods user can initialize data and
process data. This concept of binding data and processes together already is
discussed in OOP concepts. Output for the above program is shown in figure as
–

Class and Object

64 Concepts

“Only for Private Circulation”

kkk+ Rtqvgevgf" Java Programming
While implementing inheritance, where a sub-class derives members from
its super class, protected access modifier is used. When a member from super
class is defined with access modifier ‘protected’, the member is accessible within NOTES
super class as well within its sub class. But it is accessible within scope of both
classes, and not outside the class, even using their objects. To understand the
concept of protected, it is necessary to discuss first ‘inheritance’. The concept of
inheritance will help to understand use of protected access modifier, which is
discussed in detail in chapter 3.

Fghcwnv
The modifier assigned to members by default is called as ‘default’. When,
while defining member in a class no modifier is specified then its access is
default. The default access allow the member to be accessed within the folder
where the class is defined.

Uvcvke
‘static’ is a keyword used with declaration of variables or functions. It is a
modifier which changes scope and lifespan of a variable as well as functions.
Firstly we will discuss effect of static with variables and then with functions.

K0 Uvcvke"Xctkcdngu"⁄
Static variable in a class is treated differently than a normal member
variable. Characteristics of a static variable are given as –
• It is initialized automatically by data type’s initial value.
• It is allocated commonly and accessed commonly in different function
calls.
• It’s last value is retained within different function calls.
• Only static methods can access static variables.
Use of static variables in a function block is explained with the help of
following program –
/*Static Variable in Function*/ class StaticTrial
{
static int sn;
static void staticTest()
{
int n=0; n++;
sn++;
[Link]("\nNormal Variable n="+n+"\nStatic Variable sn="+sn); Class and Object
Concepts 65

“Only for Private Circulation”

 Java Programming }
public static void main(String args[])
{
NOTES
staticTest(); staticTest(); staticTest();
}
}
The above program defines class ‘StaticTrial’, which contains three
members, one is static integer variable ‘sn’, and other two are ‘static’ methods
namely ‘staticTest’ and ‘main’. The method ‘main’ gives three calls to method
‘staticTest’. Method ‘staticTest’ defines one integer, which is normal and local
to it. The method increment values of both integers, ‘n’ and ‘sn’, and display
their values. Output for the above program is given below.

Htqo"vjg"qwvrwv"yg"ecp"qdugtxg"vjcv"⁄
- Value for ‘n’ is common for all function calls. As it is a normal variable
for every call it gets allocated and initialized.
- Value for ‘sn’, on the contrary, goes on changing for each call. This is
because when function is called for the first time ‘sn’ is allocated and
initialized to zero, and same is used by next function calls. As it is
allocated in shared memory, same value is shared and retained in different
calls. Therefore for first call value is ‘0’ which is incremented to ‘1’, in
next call ‘1’ is incremented to ‘2’ and in third it becomes ‘3’.

KK0 Uvcvke"Ogodgtu"
The methods, defined as members in a class, uses static modifier does not
need object on a class to access it. It can be accessed without object using only
class name. Syntax for accessing static members is given as –
<class name>.<member name>;
So here while accessing static members object on class is not required.
Though the object on class is not defined, yet static members can be accessed.
Following program helps to understand concept of static members in a class
–
/*Static Method in a class*/ class StaticMethod
Class and Object
{
66 Concepts

“Only for Private Circulation”

 static private int sn; private int n; Java Programming
public StaticMethod(int a)
{
NOTES
sn++; n=a;
[Link]("\nIt is Object number : "+sn);
}
public static void staticShow()
{
[Link]("\nNumber of objects created
"+sn+"\n");
}
public void display()
{
[Link]("Value of n in object is "+n);
}
}
class StaticImp
{
public static void main(String args[])
{
[Link]();
StaticMethod sm1=new StaticMethod(34); [Link]();
[Link]();
StaticMethod sm2=new StaticMethod(1); [Link]();
[Link]();
StaticMethod sm3=new StaticMethod(45); [Link]();
[Link]();
}
}
In the above program we have defined two classes, one is user defined and
other is user defined class.
- The class ‘StaticMethod’ defines one static integer member ‘sn’ and one
normal integer ‘n’. It defines three methods, ‘StaticMethod()’ is a
Class and Object
parameterized constructor, ‘display()’ is normal method while Concepts 67

“Only for Private Circulation”

 Java Programming ‘staticShow()’ is static method. All methods are public. The constructor
initializes object and at the same time increments static member, which
helps to keep track of number of objects created on class. ‘display()’ helps
NOTES to display object data. While static method ‘staticShow()’ helps to display
value of static member.
- The class ‘StaticImp’ helps to implement class ‘StaticMethod’. ‘main()’
method firstly, though objects on class ‘StaticMethod’ yet to be defined,
calls static method. While calling static method class name is used, and
not an object.
Following is the output for the above program. The first line is the number
of objects created on class, here which is ‘0’, as yet no object is defined on class.
As and when objects are created on class, the number of objects goes on
increasing. Here from the output we can observe that the data stored by objects
on class ‘StaticMethod’ is of two types –
- Objects personal data
- Common or shared data to all objects
Our class ‘StaticMethod’ defines two variables, from which ‘n’ is personal
data for each object, while ‘sn’ is the common or shared data by all objects
declared on the class. Hence in output we can see value of n for each object goes
on changing, but value of ‘sn’ is same for all objects.

Hkpcn
It is a keyword used with two contexts –
- With variable values
- With members of a class in inheritance
- With class
In this sub section we will see how it can be used with variable values.
When we need to define constants, we can use ‘final’ keyword. For example
Class and Object
68 Concepts final float PI=3.14f;

“Only for Private Circulation”

 In the above instruction a variable ‘PI’ is defined of type ‘float’. The Java Programming
declaration is preceded by keyword ‘final’, which declares value of variable to
be constant. If in a program user tries to change value for a final variable it gives
an error. It can be observed in following program – NOTES
/*Defining constants with keyword 'final'*/ class FinalChange
{
public static void main(String args[])
{
int r=5;
final float PI=3.14f; r=10;
PI=(float)(22.0f/7.0f); [Link](PI);
}
}
In the above program ‘PI’ is defined as ‘final’ variable and hence its value
cannot be changed. But the instruction –
PI=(float)(22.0f/7.0f);
Tries to assign new value to ‘PI’, and hence compiler raises an error as -

If we remove the keyword ‘final’ from declaration of ‘PI’, the program will
execute successfully. Following program shows how we can use ‘final’ to declare
constant variables.
/*Defining constants with keyword 'final'*/ class FinalImp
{
public static void main(String args[])
{
int r=5;
final float PI=3.14f; float area=PI*r*r;
[Link]("Area of Circle = "+area);
}
}
Class and Object
Concepts 69

“Only for Private Circulation”

 Java Programming Output for the above program is given as -

NOTES

Other use of ‘final’ keyword is discussed in chapter 3.

Cttc{"qh"Qdlgevu
Just like ‘array of variables’ defined for primitive data types, ‘array of
objects’ can be defined on user-defined datatype. Syntax for defining an array of
objects is given below –
<class name>[ ] <array name> = new <class name>[<size of array>];
An array of objects helps the user to store data for multiple objects, which
are allocated contiguously in memory. The following program explains how to
declare and access array elements.
/*Array of objects*/ import [Link].*; class Employee
{
private String name; private int empId; public void getData()
{
Scanner s=new Scanner([Link]); [Link]("Enter Employee
Name : "); name=[Link]();
[Link]("Enter Employee Id : "); empId=[Link]();
}
public void display()
{
[Link]("Employee Name : "+name+"\nEmployee Id : "+empId);
}
}
class ArrayObject
{
public static void main(String arg[])
{
Employee[] arrEmp=new Employee[4];
Class and Object //Initialization of Array Elements for(int i=0;i<4;i++)
70 Concepts

“Only for Private Circulation”

 arrEmp[i]=new Employee(); Java Programming
//Accepting Data for each element in array for(int i=0;i<4;i++)
arrEmp[i].getData();
NOTES
//Displaying Data for each element in array for(int i=0;i<4;i++)
arrEmp[i].display();
}
}
The above program shows how an array of objects can be declared and used.
The class ‘Employee’ defines a user-defined datatype using which an array object
named ‘arrEmp’ of size four has been declared. Like normal array elements,
objects in an array are referred using index. The index written within square
brackets denotes the object for which currently the method will be executed.
Unlike a normal array, every object in the collection of objects needs to be
constructed separately and hence the first ‘for’ loop in program constructs each
object in an array.
Next two for loops are for executing methods ‘getData()’ and ‘display()’ for
each object in an array. Output for the above program is shown below -

Rcemcigu
The Package is defined as –
‘a collection of classes and interfaces which can be used in other programs
by importing it’.
Classes which need to be grouped together, as they share common
functionalities, then the concept of package is used.
For example suppose in a software system developed for ‘Hospital’ defines
different classes for processing data of patients and their health data, as well as
bills paid by them. Patients visiting hospital are categorized as OPD patients and
IPD patients. According to type of patient, format of their health data and bill
data goes on changing. For processing this data various classes are defined, from Class and Object
Concepts 71

“Only for Private Circulation”

 Java Programming which some handle OPD data while some handle IPD data. According to their
usage they can be grouped together as OPD package and IPD package.
When classes are grouped together as a package, it allows user to add
NOTES visibility to members and even to classes at different levels. Like some classes
may be visible only inside the package while some are accessible outside the
package. This visibility can be added differently to members also. Some members
from class may be accessible within the class or within the package or outside
the package.
In the next sub section we will discuss how a package can be created.

Uvgru"kp"Fghkpkpi"c"Rcemcig
By applying following steps a package can be created –
1. Create a folder with package name. The folder resides in same
directory where package will be used.
2. Every class or interface defined as a part of package starts with
package definition. Syntax for package definition is given as –
package <package name>;
The keyword ‘package’ explains that the class file is a part of package.
It should be the very first line in file, and is followed by ‘import’ if
necessary.
3. The class or interface, which is defined as part of a package, needs to
be assigned with proper access modifier. If the class is to be used
outside the package then its access modifier should be defined as
‘public’, if not then no need to define any access modifier as it is
assigned with ‘default’ access modifier.
4. Like normal program file save file with extension ‘.java’. If access
modifier used for class is ‘public’ then save the file with same name
as class name. For each class and interface in a package create a
separate file.
5. Compile each file and store its ‘.class’ file in the same folder.
These steps are to be followed while creating our own package. In this
section we have discussed only about creating single package. So package will
have only collection of classes and interfaces, and no other packages. The next
sub section discusses about defining packages in hierarchy.

Etgcvkpi"jkgtctej{"qh"rcemcig
While forming hierarchy of packages, we will have nested packages. In
simple language we will have one package inside the other package. The
following diagram explains diagrammatically how hierarchy can be formed.

Class and Object

Suppose for the above discussed hospital management system where we
72 Concepts need to store and process data for OPD and IPD patients, so we have separated

“Only for Private Circulation”

 Java Programming

NOTES

classes for OPD and IPD. Now we have two packages OPD and IPD, and
collectively these two packages are kept as a group in one package i.e. ‘Hospital
Package’. So it forms hierarchy of packages.
The hierarchy of packages can be created by creating directory hierarchy.
For eg. In ‘HospitalPackage’ we have two sub packages ‘OPD’ and ‘IPD’ then
in current working directory we will have subdirectory ‘MyPackage’. In
‘MyPackage’ we will have subdirectories ‘MyPack1’ and ‘MyPack2’.
While defining classes in ‘OPD’ the package will be defined as –
package [Link];

Korqtvkpi"rcemcig
In the above sections we have seen how packages can be created. Now the
section discusses about using predefined packages. When a package is to be used
make assure that the package folder is in the same directory where you are using
it. Before using classes from the package in a program for declaration of objects,
the package for the class should be made available. Here to make class definition
available from package ‘import’ statement from java is used. Syntax for using
‘import’ is given below –
import <super package>.<sub package>…<class>;
Whenever a package is to be used so that the member of package will be
available for use (classes, interface, & methods defined in package) then using
statement import user can import the package while importing the package the
user can make use of ‘.’ operator to specify the member name from the package.
For example, we need definition of class ‘Card’ to define its object in a
program then we can import package ‘OPD’ as –
import [Link];
Here ‘HospitalPackage’ is a package at higher level while OPD is its
member package, and in OPD package we have class ‘Card’. Using dot operator
(‘.’) we can access one package nested in other.

ß Wug"qh"Uvct"*,+"yknfectf
It is a wildcard which denotes ‘all’ members from package when instead of
Class and Object
specifying a particular class or interface user wants to use all members from the Concepts 73

“Only for Private Circulation”

 Java Programming package in that case instead of class name in import user can use star (*).
For example, to import all classes and interfaces defined in package OPD
we can use ‘*’ as shown below –
NOTES
import [Link].*;
Here all members from package OPD are available now because of use of
‘*’.

Gzegrvkqp"Jcpfnkpi
The section discusses about the handling of runtime errors. Programmers
while compiling and executing programs face different kind of errors. Depending
on type of error, error handling techniques are applied to remove it and execute
the program smoothly. Java provides a powerful error handling technique which
helps in handling runtime errors known as exceptions and hence known as
‘Exception Handling’. Before starting with different types of exception handling
we need to know about types of errors discussed in next section.

V{rgu"Gttqtu
Different errors which may occur while executing program are roughly
categorized under three headings. Each type of error along with its example is
discussed below –

k+ U{pvcz"Gttqtu
The errors which can be detected by compiler are termed as Syntax errors.
These errors are also known as compilation errors. Mistakes in keyword
spellings, errors in punctuation marks, and use of undeclared variables,
unmatched blocks are syntax errors. If the program has any syntax errors,
compiler cannot complete the compilation process and hence the program cannot
be executed. The program having syntax/compiler errors is possible to execute
only after removing these errors.
For Example following code shows a syntax error –
Class Trial
{
public static void main(String arg[])
{
[Link]("Welcome to Java");
}
}
If the above given program is compiled, then java compiler cannot complete
the compilation and lists syntax error as shown in figure below –
Class and Object
74 Concepts

“Only for Private Circulation”

 Java Programming

NOTES

This error is due to the using keyword as ‘Class’ instead of ‘class’. Java is
case sensitive and hence java compiler differentiates in these two words, hence
cannot complete compilation. Here the class file is also not generated for the
program.

kk+ Nqikecn"Gttqtu
Though the program is compiled and executed successfully, when the
desired output is not given then it is known as logical errors. Logical errors are
caused due to wrong sequence of instructions, wrong use of operators or wrong
data type. These errors are hard to found and to remove and programmer needs
to take pains for removing these errors.
Following program shows how logical errors can occur –
/*Program to display largest out of two*/ class Logical
{
public static void main(String arg[])
{
int a=10,b=15; if(a<b)
[Link]("a is largest.");
else
[Link]("b is largest.");
}
}
Above program outputs the largest variable name as an output. The program
is compiled and executed successfully. But the output is unexpected. Here we
should get output as ‘b is largest’ but it displays ‘a is largest’. This is because of
wrong use of operator. While comparing two variable values, a and b,
programmer has used ‘less than’ (<), but here it should be ‘greater than’(>). This
is the reason why the program is not giving right output. It is the logical error.

Class and Object

Concepts 75

“Only for Private Circulation”

 Java Programming kkk+ Twpvkog"Gttqtu
The error which cannot be detected by compiler, and stops execution of
program is known as runtime error. This error occurs due to certain instructions
NOTES which cannot be executed by processor in given conditions. For example ‘Divide
by zero’ is an arithmetic exception and is occurred when value of divisor variable
is zero. Whenever the processor comes across such instructions it stops execution
of program though the remaining program can be executed correctly and throws
an exception. Such instructions which terminates program abnormally are known
as exceptions. These exceptions need to be managed runtime, so that the
remaining program execution can be completed. The technique which helps
programmer to manage exceptions is known as ‘Exception Handling’.
Following program shows due to an exception how program stops execution
abnormally.
/*Program to display division after dividing a by b*/
/*Program accepts command line arguments*/ class Runtime
{
public static void main(String arg[])
{
int a=[Link](arg[0]); int b=[Link](arg[1]); float c=a/b;
[Link]("Division = "+c);
}
}
Above program is very simple program which accept two command line
arguments which are two integers, while displays division of these two numbers.
Following image shows output of the program. The program is compiled and
executed successfully. In the output we can observe that the program is executed
twice correctly, while third time when value of b is passed as ‘0’, it generates an
exception namely ‘Arithmetic Exception’.

All such different exceptions which may abort the program execution are
defined in package ‘[Link]’. In next sub sections we will discuss how these
exceptions can be handled in java.

Class and Object

76 Concepts

“Only for Private Circulation”

Wukpi"vt{."ecvej"Dnqem"hqt"Gzegrvkqp"Jcpfnkpi Java Programming
As discussed in the previous section exceptions are thrown by processor,
need to be caught and handled so that abnormal program termination may be
avoided. NOTES
If a processor encounters any abnormal execution for an instruction due to
which processor is not able to continue with the execution of remaining program
and hence terminates the execution abnormally. While terminating the execution
it returns an error to calling program. Process of returning an error to calling
program is termed as ‘Throwing an Exception’. The thrown exception can be
caught and handled so that processor can continue with the execution of
remaining program. Mechanism of catching and managing exceptions is known
as ‘Exception Handling’.
Java provides two keywords ‘try’ and ‘catch’ which helps in handling
exceptions. These two keywords are followed by the block of instructions which
are executed as per the requirement. The keyword ‘try’ intimates processor about
forthcoming sensitive instructions which needs to be handled carefully as they
may throw exception.
‘try’ block is followed by ‘catch’ block. As the name suggests, ‘catch’ block
catches the exception thrown by the instruction in try block.
In the exception handling block is given as –
try
{
<statements to monitor for errors>;
}
catch (<exception type1><exception object>)
{
<procedure to handle an exception>
}
For handling exception, as discussed above ‘try’, ‘catch’ and ‘finally’ blocks
are used. Every block as shown above has its own role.

flvt{‚"Dnqem
The instructions which might get runtime error are written within ‘try’
block. Whenever try block is executed every instruction in try block is executed
carefully. As and when exception (runtime error) occurs, it is thrown to be caught
by corresponding ‘catch block’ which handles that exception.

flecvej‚"Dnqem
‘catch’ block is always written after end of try block. The catch block Class and Object
accepts ‘Exception’ type as an argument. When an exception is thrown by try Concepts 77

“Only for Private Circulation”

 Java Programming block, its type is matched with the type of exception to be caught by catch block;
if it is matched the corresponding catch block is executed.
Following program shows how an exception for ‘Divide by Zero’ can be
NOTES handled.
/*Program to display division after dividing a by b*/
/*Program accepts command line arguments*/ class DivideZero
{
public static void main(String arg[])
{
int a=[Link](arg[0]); int b=[Link](arg[1]); int c;
try
{
c=a/b;
}
catch(ArithmeticException e)
{
[Link]("Arithmetic Exception has Occured.\nNow it will be
handled by catch block and program will continue");
b=1;
c=a/b;
}
[Link]("Division = "+c);
}
}
Here previous program has been modified by adding try and catch block.
In try block an instruction has been added which is suspected and may throw an
exception. ‘try’ block is followed by the ‘catch’ block which catches the thrown
exception. As stated above catch block specifies which exception to be caught.
Here in program the catch block specifies the exception as
‘ArithmeticException’. When an instruction throws ‘ArithmeticException’ it is
caught by catch block. In catch block we can write remedial block of instructions
so that an exception can be handled. After completion of catch block execution
the processor continues with execution of remaining program. Following
command window shows output of the program. For first two executions
program has worked correctly, but for third execution an exception was thrown
where value assigned to ‘b’ was zero. The ‘ArithmeticException’ was thrown
and was caught by the catch block. After execution of catch block processor
Class and Object continues with the remaining program block.
78 Concepts

“Only for Private Circulation”

 Java Programming

NOTES

The above command window shows how arithmetic exception is handled

and program has completed execution successfully.

Ownvkrng"flecvej‚"dnqemu"hqt"ukping"flvt{‚
In the program discussed in previous sub section other instructions also can
throw other type of exceptions. Here program is accepting input as command
line arguments. If user fails to provide it, the program terminates with an
exception namely ‘ArrayIndexOutOfBounds’. Command line arguments are
accepted as an array of strings, which are passed as arguments to function
‘main()’. If user does not pass any values, but in program instruction tries to read
elements from String array as –
a=[Link](arg[0]);
then the instruction throws an exception, which need to be caught and
handled. Following command window shows how exception is thrown when no
command line arguments are passed to ‘main()’ –

Here as program is small a single try block can handle all exceptions with
the help of multiple catch blocks. We can modify the previous program to handle
these multiple exceptions. Following program shows modification of previous
program to handle these multiple exceptions.
/*Program to display division after dividing a by b*/
/*Program accepts command line arguments*/ import [Link].*;
class DivideZero
{
public static void main(String arg[])
{
int a,b,c; a=0;b=0;c=0; Class and Object
Concepts 79

“Only for Private Circulation”

 Java Programming try
{
a=[Link](arg[0]); b=[Link](arg[1]); c=a/b;
NOTES
}
catch(ArithmeticException e)
{
[Link]("Arithmetic Exception has Occured.\nNow it will be
handled by catch block and program will continue");
b=1;
c=a/b;
}
catch(ArrayIndexOutOfBoundsException e)
{
[Link]("Array Index Out of Bounds Exception has
Occured.\nNow it will be handled by catch block and program will continue");
Scanner s=new Scanner([Link]); if([Link]==0)
{
[Link]("Enter Value of a : "); a=[Link]();
[Link]("Enter Value of b : "); b=[Link]();
}
else
{
[Link]("Enter Value of b : "); b=[Link]();
}
c=a/b;
}
[Link]("Division = "+c);
}
}
Here one try block is followed by two catch blocks defined to handle two
different type of exceptions.
In a try block we have added all instructions which may throw an exception.
Following output window shows execution of program for four different
Class and Object situations.
80 Concepts

“Only for Private Circulation”

 In the first run program has executed successfully. Java Programming
While in the second run user has provided only one command line
argument, hence processor throws ‘ArrayIndexOutOfBounds’ exception which
is caught and handled by second catch block. According to instructions given NOTES
with ‘catch’ block, program accepts key board input for single variable and
continues with the execution of remaining program.
The third run, where no command line argument is passed, throws again
‘ArrayIndexOutOfBounds’ exception which is caught and handled by second
catch block again. According to instructions given with ‘catch’ block, program
accepts key board input for both variable, a and b, and continues with the
execution of remaining program.
In the fourth run user has passed two command line arguments, but the value
assigned to ‘b’ is zero. Consequently it throws ‘ArithmeticException’ which is
caught and handled by first catch block. According to instructions given with
‘catch’ block, b is assigned with value ‘1’, and continues with the execution of
remaining program.

flhkpcnn{‚"dnqem
In the previous execution of multiple blocks we have seen that there is no
proper sequence for execution of catch blocks and it may alter all execution
sequence. When exceptions are thrown, execution in a method takes a rather
abrupt, nonlinear path that alters the normal flow through the method. Depending
upon how the method is coded, it is even possible for an exception to cause the
method to return prematurely. This could be a problem in some methods. For
example, if a method opens a file upon entry and closes it upon exit, then you
will not want the code that closes the file to be bypassed by the exception-
handling mechanism. The finally keyword is designed to address this
contingency. finallycreates a block of code that will be executed after a try/catch Class and Object
block has completed and before the code following the try/catch block. The Concepts 81

“Only for Private Circulation”

 Java Programming finally block will execute whether or not an exception is thrown. If an exception
is thrown, the finally block will execute even if no catch statement matches the
exception. Any time a method is about to return to the caller from inside a
NOTES try/catch block, via an uncaught exception or an explicit return statement, the
finally clause is also executed just before the method returns. This can be useful
for closing file handles and freeing up any other resources that might have been
allocated at the beginning of a method with the intent of disposing of them before
returning. The finally clause is optional. However, each try statement requires at
least one catch or a finally clause. Syntax for using finally block is given below
–
try
{
<statements to monitor for errors>;
}
catch (<exception type1><exception object>)
{
<procedure to handle an exception>
}
catch (<exception type2><exception object>)
{
<procedure to handle an exception>
}
:
:
:
finally
{
<procedure to be executed as final>
}
Following program demonstrates use of finally block.
/*Program to display division after dividing a by b*/
/*Program accepts command line arguments*/ import [Link].*;
class DivideZero
{

Class and Object public static void main(String arg[])

82 Concepts

“Only for Private Circulation”

{ Java Programming
int a,b,c; a=0;b=0;c=0;
try
NOTES
{
a=[Link](arg[0]); b=[Link](arg[1]); c=a/b;
}
catch(ArithmeticException e)
{
[Link]("Arithmetic Exception has Occured.\nNow it will be
handled by catch block and program will continue");
b=1;
c=a/b;
}
catch(ArrayIndexOutOfBoundsException e)
{
[Link]("Array Index Out of Bounds Exception has
Occured.\nNow it will be handled by catch block and program will
continue");
Scanner s=new Scanner([Link]); if([Link]==0)
{
[Link]("Enter Value of a : "); a=[Link]();
[Link]("Enter Value of b : "); b=[Link]();
}
else
{
[Link]("Enter Value of b : "); b=[Link]();
}
c=a/b;
}
finally
{
[Link]("Block finally has been
executed."); Class and Object
Concepts 83

“Only for Private Circulation”

 Java Programming }
[Link]("Division = "+c);
}
NOTES
}
The command widow shows the output for the above program. Here we can
observe that for all executions finally block is executed.

Pguvgf"vt{"Uvcvgogpvu
The try statement can be nested. That is, a try statement can be inside the
block of another try. Each time a try statement is entered, the context of that
exception is pushed on the stack. If an inner try statement does not have a catch
handler for a particular exception, the stack is unwound and the next try
statement’s catch handlers are inspected for a match. This continues until one of
the catch statements succeeds, or until all of the nested try statements are
exhausted. If no catch statement matches, then the Java run-time system will
handle the exception.
Nesting of ‘try’ block can be shown with the help of following program –
/*Program to display division after dividing a by b*/
/*Program accepts command line arguments*/ import [Link].*;
class DivideZero
{
public static void main(String arg[])
{
int a,b,c; a=0;b=0;c=0;
try
{
Class and Object a=[Link](arg[0]); b=[Link](arg[1]); c=a/b;
84 Concepts

“Only for Private Circulation”

} Java Programming
catch(ArithmeticException e)
{
NOTES
[Link]("Arithmetic Exception has
Occured.\nNow it will be handled by catch block and program will
continue");
b=1;
c=a/b;
}
catch(ArrayIndexOutOfBoundsException e)
{
[Link]("Array Index Out of Bounds Exception has
Occured.\nNow it will be handled by catch block and program will
continue");
Scanner s=new Scanner([Link]); if([Link]==0)
{
[Link]("Enter Value of a : "); a=[Link]();
[Link]("Enter Value of b : "); b=[Link]();
}
else
{
[Link]("Enter Value of b : "); b=[Link]();
}
try
{
c=a/b;
}
catch(ArithmeticException ex)
{
[Link]("Arithmetic Exception has Occured in catch block for
ArrayIndexOutOfBounds.
\nNow it will be handled by catch block and program will continue"); b=1;
c=a/b; Class and Object
Concepts 85

“Only for Private Circulation”

 Java Programming }
}
[Link]("Division = "+c);
NOTES
}
}
In the program first try block handles the division instruction by defining
catch block with ArithmeticException. But other catch block again uses same
instruction for division after accepting values for ‘a’ and ‘b’. While inserting
values for ‘a’ and ‘b’ again user may assign zero to ‘b’ which may cause
exception, and hence need to be handled. So here we have nested try block within
catch block. Output for the program is shown below in command window, where
exception has been handled by the catch block nested within catch for
‘ArrayIndexOutOfBounds’.

*****

Class and Object

86 Concepts

“Only for Private Circulation”

 Java Programming

UNIT - 3
INHERITANCE
NOTES

AND POLYMORPHISM

Ejcrvgt"Qdlgevkxgu"
To understand –
o Concept and Importance of Inheritance
o Types of Inheritance
o Polymorphism and Implementation of Overloading and Overriding
o Dynamic Binding with the help of Dynamic Method Dispatch
o Multiple inheritance with Interface

Eqpegrv"cpf"Korqtvcpeg"qh"Kpjgtkvcpeg
Inheritance is the mechanism which allows a class to use properties
(attributes) and behaviour (methods) from its parent class. The feature helps to
define a new system based on the existing system. With the help of inheritance
properties predefined with previously defined class can be used by newly defined
class. Here previously defined class is known as ‘parent class’ or ‘super class’
while newly defined class is known as ‘child class’ or ‘sub class’. The sub class
derives members from super class hence it is also known as ‘derived class’.
Diagrammatically inheritance can be represented as –

Fig 3.1 : Inheritance

In the above diagram ‘Animal’ is the super class, while ‘Dog’ is a sub class.
Hence ‘Dog’ inherits properties form class ‘Animal’.
The concept proved to be very useful in upgrading existing system without
major changes in user interface and data. Previously when user needs to introduce
some minor features, entire existing system needs to be removed and develop
entire new system. The concept gives opportunity to developers to add new
additional features to existing system on the basis of existing system features.
Inheritance
and Polymorphism 87

“Only for Private Circulation”

 Java Programming This concept also helps to implement concept overriding of methods.
‘is-a’ Relationship
A system is defined as ‘a set of components working together as parts of a
NOTES
mechanism or an interconnecting network which is a complex as a whole’. As
the definition says any system consists of components with complex relations.
In OOP classes and their objects forms basic components of the system.
These objects hold their data not to violate the objective of data hiding and data
abstraction. Hence they won’t share data with each other.
But any system cannot work without sharing their data. For sharing data
between two objects one need to relate these objects properly so that both
objectives of OOP systems can be satisfied. Firstly data should be secure and
secondly the system will work smoothly. These relations are defined at the time
of design phase, when all classes are being designed.
Two classes can relate with each other using three types of relations – ‘is-
a’ relation, ‘has-a’ relation and ‘part-of’ relation. ‘has-a’ and ‘part-of’ relation
are design time relation which are implemented with association of classes. In
this section we are going to discuss about ‘is-a relation’. It is the relation
implemented with the help of concept of ‘inheritance’. As discussed earlier,
inheritance helps to derive properties from previously defined class. Hence it is
called as ‘the subclass is a type of super class’. The subclass defines some
additional properties to the properties derived from its super class.
For example in section 3.1 the diagram shows the ‘is-a’ relation between
two classes ‘Animal’ and ‘Dog’. Here we can read the relation as ‘Dog is-a type
of Animal’.

V{rgu"qh"Kpjgtkvcpeg
The concept of inheritance can be implemented in various types. These
categories or types are based on the number of super classes used for
implementing inheritance. While implementing inheritance through programs
depending on number of super classes use to drive or define sub-classes different
categories can be defined as –
i) Simple or Single inheritance
ii) Multiple inheritance
iii) Multilevel inheritance
iv) Hierarchical inheritance
v) Hybrid inheritance
Every category or type of inheritance along with the program is explained
in next sub sections. Before discussing all types in detail there is need to
understand how to implement inheritance.
Inheritance
88 and Polymorphism

“Only for Private Circulation”

Uwrgt"Encuu"Fghkpkvkqp"⁄ Java Programming
Super class is a normal class and hence syntax for defining super class is
same as defining a class. Class definition should start with proper access modifier
as discussed in Chapter 2. The only difference while defining super class is NOTES
decision for assigning access modifiers to the members which are to be shared
with its sub classes. While designing super class a thought should be given ‘how
class can be modified in future’ and accordingly access modifiers to members
should be assigned, so that will be available for it sub classes. Members which
need to be shared should have their access modifier as ‘protected’.

Uwd"Encuu"Fghkpkvkqp"⁄
Sub class definition starts like a normal class, but is extended with super
class name using keyword ‘extends’. The concept of inheritance helps to relate
two classes which help in data sharing. The relation of inheritance is defined with
keyword ‘extends’. The keyword ‘extends’ define the sub class as extension of
its super class. Syntax for defining sub class by using keyword ‘extends’ is given
as –
<access modifier> class <sub class name> extends <super class name>
{
<definition of sub class>
}

In the above syntax highlighted line shows how sub class definition should
start. As we can see class definition starts like a normal class. After class name
the keyword ‘extends’ explains the class is a sub class of the class whose name
is mentioned after keyword.
For example if class ‘Parent’ is super class for class ‘Child’,
diagrammatically which is represented as –

Fig 3.2 : Inheritance Example

Definition of class ‘Parent’ will be normal class definition except access
modifier for members to be shared will be ‘protected’. And definition for class
‘Child’ will use keyword ‘extends’. Definitions for both classes are represented
in following code –

Inheritance
and Polymorphism 89

“Only for Private Circulation”

 Java Programming class Parent
{
/*code for the class definition*/
NOTES
}
class Child extends Parent
{
/*code for the class definition*/
}
In implementation class when an object on ‘Child’ class is declared and
allocated, memory for members from ‘Child’ as well as memory for protected
and public members from ‘Parent’ is also allocated. In next sections all types of
inheritance are discussed.

Ukorng"qt"Ukping"kpjgtkvcpeg"
When sub class is derived from a single super-class then the type of
inheritance is known as simple or single inheritance. Diagrammatically it is
represented as –

Fig 3.3: Simple Inheritance

In the above diagram two classes are represented, class A and class B. Arrow
is pointing towards A which is the super-class and B is a sub-class. B as sub-
class derives members from A whose access modifiers are protected and public.
When an object defined on class A memory will be allocated for all
members from class A like an object on a normal class. While object defined on
class B will have protected & public members from class A and all members
(private + protected + public) from class B. It is explained with the help of
following program –
/*Program demonstrates Simple Inheritance*/
/*Here ‘A’ is a super class while ‘B’ is sub class*/ class A
{
protected int a,b;
public void setDataA(int i, int j)

Inheritance {
90 and Polymorphism
“Only for Private Circulation”
a=i;b=j; Java Programming
}
public void displayA()
NOTES
{
[Link]("\nObject OF class A: \nClass A: a= "+a+"\nb= "+b);
}
}
class B extends A
{
private int c;
public void setDataB(int i,int j, int k)
{
[Link](i,j);
c=k;
}
public void displayB()
{
[Link]("\nObject
OF class A: a="+a+"\nb= "+b+"\nClass B: c= "+c);
}
}
class SimpleInheritance
{
public static void main(String arg[])
{
A obA=new A(); B obB=new B();
[Link](4,5);
[Link]();
[Link](40,50,60);
[Link]();
}
}
Inheritance
and Polymorphism 91

“Only for Private Circulation”

 Java Programming In the above program three classes are defined one is class ‘A’, second is
class ‘B’, which are user defined classes, and third is class ‘SimpleInheritance’
which is the class for implementation. Class ‘A’ and class ‘B’ are related with
NOTES each other by the relation of ‘inheritance’.
Here class ‘A’ defines two attributes namely ‘a’ and ‘b’ of type integer and
access modifier as protected while two methods namely ‘setDataA()’ and
‘displayA() which are public. While class ‘B’ defines one attribute namely ‘c’
with access modifier ‘private’ and two methods setDataB() and displayB() whose
access modifier is public.
Class ‘SimpleInheritance’ defines objects for both classes. For ‘obA’, when
gets allocated, occupies memory to store two integers and two methods. On the
other hand for ‘obB’ memory is allocated for its own members that is ‘c’,
‘setDataB()’ and ‘displayB()’ as well as for its derived members from super class
‘A’, namely ‘a’, ‘b’, ‘setDataA()’ and ‘displayA()’. So though class ‘B’ defines
only one variable its object can store data for three variable, one for its own and
other two from its super class. Output for the above program is shown below –

Ownvkngxgn"kpjgtkvcpeg"
In multilevel inheritance a sub class is derived from a single super class
which is again sub class of another super class. Diagrammatically it is represented
as –

Fig 3.4 : Multilevel Inheritance

Inheritance
92 and Polymorphism
“Only for Private Circulation”
 The diagram shows three classes, class A, B and C. Here class A is super Java Programming
class of class Band class B is super class of class C. Hence object defined on
class A will have all members from class A (private + protected + public). An
object defined on class B will have protected & public members from class A NOTES
and all members from class B. While an object defined on class C will have
members from class B as well as class A (protected + public) and all members
(private + protected + public) from class C. Following code explains
implementation of ‘Multilevel Inheritance’. While implementing it we need four
classes namely ‘class A’, ‘class B’, ‘class C’ and implementation class
‘MultiInheritance’.
/*Program demonstrates Multilevel Inheritance*/
/*Here ‘A’ is a super class for class ‘B’, while ‘B’ is super class for class
‘C’*/
class A
{
protected int a,b;
public void setDataA(int i, int j)
{
a=i;b=j;
}
public void displayA()
{
[Link]("\nObject
\nFrom class A: a="+a+"\nb= "+b);
}
}
class B extends A
{
protected int c;
public void setDataB(int i,int j, int k)
{
[Link](i,j); c=k;
}
public void displayB()
{
Inheritance
[Link]("\nObject for class B:\nFrom class A: a= "+a+"\nb= and Polymorphism 93

“Only for Private Circulation”

 Java Programming "+b+"\nFrom class B: c= "+c);
}
}
NOTES
class C extends B
{
private String n;
public void setDataC(int i,int j, int k,String l)
{
[Link](i,j,k); n=l;
}
public void displayC()
{
[Link]("\nObject for class C:\nFrom class A: a= "+a+"\nb=
"+b+"\nFrom class B: c = "+c+"\nFrom class C: n= "+n);
}
}
class MultiInheritance
{
public static void main(String arg[])
{
A obA=new A(); B obB=new B(); C obC=new C();
[Link](4,5); [Link]();
[Link](40,50,60); [Link]();
[Link](400,500,600,"ABC");
[Link]();
}
}
In the above program four classes are defined first is class ‘A’, second is
class ‘B’ and third is class ‘C’ which are user defined classes, and fourth is class
‘MultiInheritance’ which is the class for implementation. Class ‘A’, class ‘B’ and
class ‘C’ are related with each other.
Here class ‘A’ defines two attributes namely ‘a’ and ‘b’ of type integer and
access modifier as protected while two methods namely ‘setDataA()’ and
‘displayA() which are public. Class ‘B’ defines one attribute namely ‘c’ with
Inheritance
94 and Polymorphism access modifier ‘protected’ and two methods setDataB() and displayB() whose

“Only for Private Circulation”

access modifier is public. Class ‘C’ defines one attribute ‘n’ of type String and Java Programming
access modifier ‘private’.
Class ‘MultiInheritance’ defines objects for all three classes. For ‘obA’,
when gets allocated, occupies memory to store two integers and two methods. NOTES

For ‘obB’ memory is allocated for its own members that is ‘c’, ‘setDataB()’
and ‘displayB()’ as well as for its derived members from super class ‘A’, namely
‘a’, ‘b’, ‘setDataA()’ and ‘displayA()’.
While for ‘obC’, which is object on class ‘C’, memory is allocated for its
own members namely ‘n’, ‘setDataC()’, ‘displayC()’. From class ‘B’ and hence
class ‘A’ it derives members ‘c’, ‘setDataB()’ and ‘displayB()’ as well as ‘a’, ‘b’,
‘setDataA()’ and ‘displayA()’ respectively. So though class ‘C’ defines only one
variable, its object can store data for four variable, one for its own and other three
from its super classes.
Output for the above program is shown below –

Jkgtctejkecn"kpjgtkvcpeg"
When from a super class more than one sub classes are derived then the
type is known as hierarchical inheritance. Diagrammatically it is represented as
–

Fig 3.5 : Hierarchical Inheritance

The diagram shows three classes, class A, B and C. Here classes ‘B’ and Inheritance
‘C’ have same super class namely ‘A’. This type of inheritance is used when and Polymorphism 95

“Only for Private Circulation”

 Java Programming developer wants to define different types defining their own attributes, but need
to share some common attributes. In the case these common attributes are defined
in a class, here class ‘A’, and all other classes are derived from this common
NOTES super class. Here class ‘B’ and class ‘C’ derives protected and public members
from class ‘A’.
Following program explains hierarchical inheritance
/*Program demonstrates Hierarchical Inheritance*/
/*Here ‘A’ is a super class for class ‘B’ and class ‘C’*/ class A
{
protected int a,b;
public void setDataA(int i, int j)
{
a=i;b=j;
}
public void displayA()
{
[Link]("\nObject for class A: \nFrom class A: a="+a+"\nb= "+b);
}
}
class B extends A
{
private int c;
public void setDataB(int i,int j, int k)
{
[Link](i,j); c=k;
}
public void displayB()
{
[Link]("\nObject for class B:\nFrom class A: a= "+a+"\nb=
"+b+"\nFrom class B: c= "+c);
}
}
class C extends A

Inheritance {
96 and Polymorphism
“Only for Private Circulation”
 private String n; Java Programming
public void setDataC(int i,int j, String k)
{
NOTES
[Link](i,j); n=k;
}
public void displayC()
{
[Link]("\nObject for class C:\nFrom class A: a= "+a+"\nb=
"+b+"\nFrom class C: n= "+n);
}
}
class HierarchicalInheritance
{
public static void main(String arg[])
{
A obA=new A(); B obB=new B(); C obC=new C();

[Link](4,5); [Link]();

[Link](40,50,60); [Link]();

[Link](400,500,"ABC");
[Link]();
}
}
Above program defines four classes as in previous one. Classes are named
as class ‘A’, class ‘B’, class ‘C’ and class ‘HierarchicalInheritance’, from which
first three are user defined classes, and fourth is class for implementation. Here
class ‘B’ and class ‘C’ are related with Class ‘A’, but these two classes does not
have any relation with each other.
Here class ‘A’ defines two attributes namely ‘a’ and ‘b’ of type integer and
access modifier as ‘protected’ while two methods namely ‘setDataA()’ and
‘displayA() which are public.
Class ‘B’ defines one attribute namely ‘c’ with access modifier ‘private’ and
two methods setDataB() and displayB() whose access modifier is public. Inheritance
and Polymorphism 97

“Only for Private Circulation”

 Java Programming Class ‘C’ defines one attribute ‘n’ of type String and access modifier
‘private’.
Class ‘HierarchicalInheritance’ defines objects for all three classes. For
NOTES ‘obA’, when gets allocated, occupies memory to store two integers and two
methods.
For ‘obB’ memory is allocated for its own members that is ‘c’, ‘setDataB()’
and ‘displayB()’ as well as for its derived members from superclass ‘A’, namely
‘a’, ‘b’, ‘setDataA()’ and ‘displayA()’.
While for ‘obC’, which is an object on class ‘C’, memory is allocated for
its own members namely ‘n’, ‘setDataC()’, ‘displayC()’. From class ‘A’ it derives
members ‘a’, ‘b’, ‘setDataA()’ and ‘displayA()’ respectively.
Here objects on class ‘B’ and class ‘C’ do not share any data from each
other. Output for the above program is shown below –

Ownvkrng"kpjgtkvcpeg"
In multiple inheritance, a single subclass is derived from two or more
superclasses.

Fig 3.6: Multiple Inheritance

The diagram for multiple inheritance again represents relation among three
classes, class ‘A’, class ‘B’ and class ‘C’. Here class ‘C’ is subclass with two
superclasses namely class ‘A’ and class ‘B’. As class ‘C’ has two superclasses, it
derives protected and public members from class ‘A’ and class ‘B’. Though
multiple inheritance is defined, the latest OOP languages like Java do not support
Inheritance it. Hence in Java, if we try to implement multiple inheritance we get a
98 and Polymorphism compilation error. The languages developed prior to java like ‘c++’ supports

“Only for Private Circulation”

multiple inheritance. While implementing multiple inheritance subclass is Java Programming
followed by names of super classes from which it is to be derived.
The following program tries to explain the concept with sample code for
multiple inheritance. But as stated earlier java gives compilation error for the NOTES
code.
class A
{
protected int a,b;
public void setDataA(int i, int j)
{
a=i;b=j;
}
public void displayA()
{
[Link]("\nObject for class A: \nFrom class A: a="+a+"\nb=
"+b);
}
}
class B
{
protected int c;
public void setDataB(int k)
{
c=k;
}
public void displayB()
{
[Link]("\nObject for class B:\nFrom class B: c= "+c);
}
}
class C extends A,B
{
private String n;
public void setDataC(int i,int j, int k, String l) Inheritance
and Polymorphism 99

“Only for Private Circulation”

 Java Programming {
[Link](i,j); [Link](k); n=l;
}
NOTES
public void displayC()
{
[Link]("\nObject for class C:\nFrom class A: a= "+a+"\nb=
"+b+"From class B: c= "+c+"\nFrom class C: n= "+n);
}
}
class MultipleInheritance
{
public static void main(String arg[])
{
A obA=new A(); B obB=new B(); C obC=new C();
[Link](4,5); [Link]();
[Link](40); [Link]();
[Link](400,500,600,"ABC");
[Link]();
}
}
The above program defines three user defied classes, class ‘A’, class ‘B’
and class ‘C’. Class ‘C’ is a sub class derived from two super classes, class ‘A’
and class ‘B’. Therefore class definition for class ‘C’ starts as –
class C extends A,B
This definition, after compilation, gives compilation error as shown below.

If we try to execute same program written using ‘c++’, by adding syntaxes

for ‘c++’, it executes without error and gives proper output. Hence we can see
Inheritance that java does not support multiple inheritance.
100 and Polymorphism
“Only for Private Circulation”
Yj{"pqv"ownvkrng"kpjgtkvcpegA Java Programming
Latest languages does not support multiple inheritance to avoid future
ambiguity which may be generated due to multiple copies of single variable in
an object for sub class. While compiling a class compiler takes care that a single NOTES
class does not defines more than one variable with same name, to avoid
ambiguity while executing it. But in case of multiple inheritance compiler cannot
check for repetition of members if they are defined with two different super
classes and may give rise to ambiguity.
This can be explained with an example. Suppose two classes ‘A’ and ‘B’
define a common attribute whose name is ‘id’. Now class ‘C’ is derived from
these two classes ‘A’ and ‘B’ using multiple inheritance. And so object on ‘C’
derives member ‘id’ from both classes. When object on ‘C’ tries to access ‘id’, it
creates ambiguity which id is to be accessed from ‘A’ or from ‘B’.
Note : If a member name is repeated in a super class and sub class, member
from sub class overrides to member from super class. The concept of overriding
is explained in section 3.4.2.

Jqy"vq"cejkgxg"ownvkrng"kpjgtkvcpeg"yjgp"kv"pggfA
When a developer needs to implement multiple inheritance as per the
demand of design of the system, instead of using class he can use interface. The
concept of interface is discussed in detail in section 3.6.

J{dtkf"kpjgtkvcpeg"⁄
In hybrid inheritance a combination of different types of inheritance can be
used. Following diagram explains how hybrid inheritance can be implemented:

Fig 3.7 : Hybrid Inheritance

In the diagram, it can be observed that here three types of inheritance how
been used. For class A, B and C it is hierarchical inheritance. For class B, C and Inheritance
D it is multiple inheritance. For class A, B, C and D it is multilevel inheritance. and Polymorphism 101

“Only for Private Circulation”

 Java Programming So object on class ‘D’ derives all protected and public members from class ‘A’,
‘B’ and ‘C’. while actually it receives two copies of ‘A’, one from ‘B’ and one
from ‘C’ (as ‘B’ and ‘C’ sub classes of ‘A’ they each already have a copy of ‘A’).
NOTES It gives rise to ambiguity while accessing members from ‘A’ using object for
class ‘D’.
As the name of type of inheritance suggests it is combination of different
types of inheritance, java does not support it because it does not support multiple
inheritance.

Eqpegrv"qh"Rqn{oqtrjkuo
It is a Greek word derived from two words ‘poly’ means ‘many’ and
‘morphism’ means ‘forms’. It can be explained as ‘one thing having many forms’.
When applied to any programming language, in simple language, it can be
explained as ‘One Name which can be used in Various Forms’. Polymorphism
is very powerful concept of OOP language which helps to implement late
binding. Following programming constructs helps to implement polymorphism
1. Function Overloading
2. Member Overriding
3. Dynamic Binding(Virtual Functions)
These concepts adds more flexibility in program which helps developer to
make decision while runtime which is also known as dynamic binding. Binding
of the program takes place at two different levels – Static Binding and Dynamic
Binding. While binding, which can be resolved at compilation time is known as
static binding or early binding. Always static, final and private methods are
cannot be overridden. While in dynamic binding or late binding compiler does
not decide the method to be called. Member overriding is the best example of
dynamic binding. Following sub sections discusses all concepts in detail.

Hwpevkqp"qt"Ogvjqf"Qxgtnqcfkpi
The concept of function overloading helps developer to use same name for
different function blocks. The ambiguity while execution can be avoided by
differentiating every definition either by –
• Number of arguments passed
OR
• Type of arguments passed to function.

Pggf"qh"Hwpevkqp"Qxgtnqcfkpi"
In different situations we can prefer function overloading. The one situation
where there is need of writing function blocks where either process block is
similar but data type of arguments go on changing then we can use function
Inheritance overloading. For example programmer need to write a program to add two
102 and Polymorphism
“Only for Private Circulation”
numbers where user need to add either two integers or float or double values Java Programming
depending on his requirement. In case process is same for all function blocks,
while only data type goes on changing. In language like ‘c’, one need to write
functions as sumInt(int a, int b), sumFloat(float a, float b), sumDouble(double a, NOTES
double b) for adding integer, float and double respectively. But in java by using
concept of function overloading functions can be written as sum(int a, int b),
sum(float a, float b), sum(double a, double b). In case of function overloading
user of function need to remember only name of the function as ‘sum’ instead of
using different names for functions. It is shown in the following program –
/*Function overloading for different datatypes*/ class FunOverload
{
public static int sum(int a,int b)
{
[Link]("Function for Integers - "); int c=a+b;
return(c);
}
public static float sum(float a,float b)
{
[Link]("Function for Floats - "); float c=a+b;
return(c);
}
public static double sum(double a,double b)
{
[Link]("Function for Doubles - "); double c=a+b;
return(c);
}
public static void main(String arg[])
{
int s1=sum(5,3);
[Link]("Sum of Integers : "+s1); float s2=sum(5.6F,8.9F);
[Link]("Sum of Floats : "+s2); double s3=sum(5.67,8.93);
[Link]("Sum of Doubles : "+s3);
}
}
Output for the above program is shown in the command window given
Inheritance
below. Here function ‘sum’ has three definitions with different data types. In
and Polymorphism 103

“Only for Private Circulation”

 Java Programming command window below we can observe how different functions get executed.

Above program shows how same function names can be have different data
types for the arguments. Now we will see how we can differ arguments in number
of arguments.
/*Function overloading for different number of Arguments*/ class
FunOverloadNum
{
public static int area(int l,int b)
{
[Link]("Function for area of Rectangle - "); int c=l*b;
return(c);
}
public static int area(int s)
{
[Link]("Function for area of Square - "); int c=s*s;
return(c);
}
public static float area(float r)
{
[Link]("Function for area of Circle - "); float c=3.14f*r*r;
return(c);
}
public static void main(String arg[])
{
int ar=area(5,3);
[Link]("Area of Rectangle : "+ar); int as=area(5);
[Link]("Area of Square : "+as); float ac=area(5.6f);
[Link]("Area of Circle : "+ac);
}

Inheritance }
104 and Polymorphism
“Only for Private Circulation”
 Above program defines three functions for calculating area for different Java Programming
shapes. The first function accepts two arguments for calculating ‘area of
rectangle’, while second accepts only one argument to calculate ‘area of square’.
Here the third definition of function ‘area’ again accepts one argument but of
type ‘float’, so that it will not be confused with function definition for ‘area of
square’. Output for the above program is shown below.

Qxgtnqcfkpi"Ogvjqfu"kp"c"Encuu"
Like normal functions, we can also overload methods in a class. While
defining a class we can define methods which shares same functionality, but
differ in either type or number of arguments, with same names but different
arguments. Following program explains method overloading in a class.
/*Method overloading in a class*/
class MethodOverload
{
private int i,j;
public void getData()
{
i=0; j=0;
}
public void getData(int a)
{
i=a; j=0;
}
public void getData(int a,int b)
{
i=a; j=b;
}
public void displayData()
{
[Link]("i = "+i+"\tj = "+j);
} Inheritance
and Polymorphism 105

“Only for Private Circulation”

 Java Programming }
class MethodOverloadImp
{
public static void main(String arg[])
{
MethodOverload obj1=new MethodOverload(); MethodOverload obj2=new
MethodOverload(); MethodOverload obj3=new MethodOverload();
[Link]();
[Link](5); [Link](50,70); [Link]("For obj1 : ");
[Link](); [Link]("For obj2 : "); [Link]();
[Link]("For obj3 : ");
[Link]();
}
}
In the program ‘MethodOverload’ is a user defined class which defines two
private data members ‘i’ and ‘j’, while four methods which are public, hence
accessible outside the class using object. From these four methods three are
having same name as ‘getData’ but they differ in number of arguments passed to
them. First definition for ‘getData’ is without any arguments while second accepts
one argument and the third accepts two arguments. Functionality for all methods
named as ‘getData’ is same, to initialize the members for the object. Output for
the program is shown in the command window below.

Qxgtnqcfkpi"qh"Eqpuvtwevqtu"
In previous chapter we have discussed about the constructor, is a method
which helps in constructing an object on a class. Like other methods in a class,
it is possible to overload constructor in a class. In the previous section we have
seen how methods in a class can be overloaded. Following program demonstrates
overloading of constructor.
/*Constructor overloading in a class*/ class ConstructorOverload
{
private int i,j;
public ConstructorOverload()
Inheritance {
106 and Polymorphism
“Only for Private Circulation”
 i=0; j=0; Java Programming
}
public ConstructorOverload(int a)
{
i=a; j=a;
}
public ConstructorOverload(int a,int b)
{
i=a; j=b;
}
public void displayData()
{
[Link]("i = "+i+"\tj = "+j);
}
}
class ConstructorOverloadImp
{
public static void main(String arg[])
{
ConstructorOverload obj1=new ConstructorOverload();
ConstructorOverload obj2=new ConstructorOverload(5);
ConstructorOverload obj3=new ConstructorOverload(50,70);
[Link]("For obj1 : ");
[Link](); [Link]("For obj2 : "); [Link]();
[Link]("For obj3 : "); [Link]();
}
}
The class ‘ConstructorOverload’ defines three constructors, from which one
is default constructor while two are parameterized constructor. Now user of the
class can initialize his object using one of these three options. First default
constructor initializes object members to zero. Second constructor initializes
object values with single value passed as an argument to the constructor. While
Third constructor accepts two different values from user and use to initialize the
object. How the object will be initialized depends on the use of constructor while
defining the object. In the program ‘obj1’ is defined using first default constructor Inheritance
and Polymorphism 107

“Only for Private Circulation”

 Java Programming hence both members in object are initialized to zero. While ‘obj2’ is using second
constructor and hence both members in object are initialized with single value,
that is 5. ‘obj3’ has used third constructor which accepts two arguments, and
hence it is initialized with two values 50, 70. Output of the program is shown in
following command window.

Ogodgt"Qxgttkfkpi
The concept of member overriding is similar to member overloading. The
difference in these two is in member overloading more than one member with
same name are defined in same class definition. While in member overriding,
members having same name are defined in two different classes which are related
with each other through the relation of inheritance. Prerequisite for member
overriding is inheritance.
As discussed earlier, inheritance help to share members from predefined
class, known as super class, with its sub class. All protected and public members
from super class are available to its sub class, either within sub class definition
or outside the class using its object. For example if method ‘display’ is defined
in a super class as public, then sub class object can call method ‘display’ though
it is defined in its super class. While executing method ‘display’, though the
object is defined over sub class, method from super class is executed.
In method overriding sub class also defines members with same name as in
super class. Now, when sub class object calls method processor checks if sub
class has defined it, if so it executes method from sub class itself and not from
super class.
Following program demonstrates method overriding.
/*Method Overriding demonstration through inheritance*/ class SuperClass
{
public void method1()
{
[Link]("Method1 from Super class");
}
public void method2()
{
[Link]("Method2 from Super class");
Inheritance }
108 and Polymorphism
“Only for Private Circulation”
 } Java Programming
class SubClass extends SuperClass
{
public void method2()
{
[Link]("Method2 overrides method2 from Super Class");
}
}
class MethodOverridingImp
{
public static void main(String arg[])
{
SuperClass objSuper=new SuperClass(); SubClass objSub=new SubClass();
[Link]("For object on Super Class : "); objSuper.method1();
objSuper.method2();
[Link]("For object on Sub Class : "); objSub.method1();
objSub.method2();
}
}
In the above program defines three classes, ‘SuperClass’, ‘SubClass’ and
‘MethodOverridingImp’. From these three classes ‘SubClass’ is derived from
class ‘SuperClass’.
‘SuperClass’ defines two member methods named as ‘method1’ and
‘method2’ which are ‘public’. Class ‘SubClass’ which is derived from
‘SuperClass’ defines one method ‘method2’. The public members from super
class are accessible to object on sub class, hence both methods from super class
are accessible to object on sub class.
In function ‘main’ one object for each class ‘SuperClass’ and ‘SubClass’
are defined. ‘objSub’ object, object on class ‘SubClass’, calls two methods
‘method1’ and ‘method2’. When object calls ‘method1’, which is defined with
‘SuperClass’ gets executed. For ‘method2’, now processor has two options one
from ‘SuperClass’ and one from its own. But here preference is given to its own
method. Hence we say that ‘method2’ from ‘SubClass’ overrides ‘method2’ from
‘SuperClass’. Output for the program is shown in command window below.

Inheritance
and Polymorphism 109

“Only for Private Circulation”

 Java Programming

F{pcoke"Ogvjqf"Fkurcvej"*FOF+
Dynamic Method Dispatch, also known as virtual functions, can be
considered as the next step of method overriding. While implementing the
concept, methods from different classes are executed by using a reference to the
superclass. When one needs to implement DMD, all the classes need to have
hierarchical inheritance. In simple words, all classes should be derived from a
single Superclass. Reference to this superclass is used to call methods
dynamically from different classes. DMD is the real example of dynamic binding
where which method is to be executed is not known while compilation time, but
is decided at runtime.
A method that is commonly defined in all classes is executed using
reference. A reference to the class only points to an object. Already we have
discussed the concept of ‘reference’ while defining an object for a class, in
chapter 2. Reference for a superclass can point to object for the class as well as
to the objects defined on its derived classes also. Thus using reference to their
superclass own methods can be executed. The concept of DMD is shown in the
following program.
/*Method Overriding demonstration through inheritance*/ class SuperClass
{
public void method1()
{
[Link]("Method1 from Super class");
}
public void method2()
{
[Link]("Method2 from Super class");
}
}
class SubClass1 extends SuperClass
{
public void method2()
{
Inheritance
110 and Polymorphism [Link]("Method2 from SubClass1, overrides method2

“Only for Private Circulation”

 from Super Class"); Java Programming
}
}
class SubClass2 extends SuperClass
{
public void method2()
{
[Link]("Method2 from SubClass2, overrides method2 from
Super Class");
}
}
class DMDImp
{
public static void main(String arg[])
{
SuperClass refSuper;
SuperClass objSuper=new SuperClass(); SubClass1 objSub1=new
SubClass1(); SubClass2 objSub2=new SubClass2();
[Link]("Reference for Super Class is referring to object for
SubClass1 : ");
refSuper=objSub1; refSuper.method2(); refSuper.method1();
[Link]("\nReference for Super Class is referring to object for
SubClass2 : ");
refSuper=objSub2; refSuper.method2(); refSuper.method1();
[Link]("\nReference for Super Class is referring to object for
SuperClass : ");
refSuper=objSuper; refSuper.method2(); refSuper.method1();
}
}
Here three classes are defined. One is the superclass named ‘SuperClass’.
From it, two subclasses are derived namely ‘SubClass1’ and ‘SubClass2’. The
main method defines a reference to ‘SuperClass’ and objects for all classes that
is to superclass and its derived classes. As and when the reference goes on
pointing to different objects ‘method2’ from that particular class is executed. But Inheritance
and Polymorphism 111

“Only for Private Circulation”

 Java Programming it does not happen for ‘method1’. Both subclasses of superclasses do not define
‘method1’ and hence though the reference refers to subclass object ‘method1’ is
executed from the superclass.
The output for the program is shown in the command window given below.

Mg{yqtfu"Wugf"kp"Kpjgtkvcpeg"cpf"Rqn{oqtrjkuo
i) abstract – It is a keyword in java that can be used with the class or a
method in a class. In some situations, the user may need to define
classes that should not be instantiated, but for defining some common
characteristics the class is defined. Then the class is defined as
‘abstract’ class. The abstract class is used as a superclass for the classes
which need to share these common characteristics. The following
program explains the use of the ‘abstract’ keyword.
/*Abstract Class in inheritance*/ abstract class SuperClass
{
public void method1()
{
[Link]("Method1 from Super class");
}
}
class SubClass1 extends SuperClass
{
public void method2()
{
[Link]("Method2 from SubClass1");
}
}
class SubClass2 extends SuperClass
{
Inheritance public void method1()
112 and Polymorphism
“Only for Private Circulation”
{ Java Programming
[Link]("Method1 from Sub class2, overrides method1 from
Super Class");
}
public void method2()
{
[Link]("Method2 from SubClass2");
}
}
class AbstractClass
{
public static void main(String arg[])
{
//SuperClass objSuper=new SuperClass(); SubClass1 objSub1=new
SubClass1(); SubClass2 objSub2=new SubClass2();
[Link]("Object for SubClass1 : "); objSub1.method2();
objSub1.method1(); [Link]("Object for SubClass2 : ");
objSub2.method2();
objSub2.method1();
}
}
The above program defines two subclasses ‘SubClass1’ and
‘SubClass2’ which are derived from an abstract superclass
‘SuperClass’. Here superclass is an abstract class and hence it cannot
be instantiated. If the user tries to define an object on an abstract class
compiler gives compilation error which is shown in the command
window below.

If we comment the line

SuperClass objSuper=new SuperClass then the program is compiled
successfully and the output is given as shown in the command window
below. Inheritance
and Polymorphism 113

“Only for Private Circulation”

 Java Programming The abstract class ‘SuperClass’ defines one common method namely
‘method1’ which is shared by its sub classes. Here ‘SubClass1’ does
not define ‘method1’ and hence its object can use ‘method1’ from its
super class. While ‘SubClass2’ overrides ‘method1’.

The keyword ‘abstract’ also can be used with the method in an abstract
class. When a method is defined as an abstract method, it will give
only its signature in class, is compulsorily implemented by its derived
classes. The following program shows the use of the abstract method
in the abstract class.
/*Use of Abstract Method in Abstract Class in inheritance*/ abstract class
SuperClass
{
public void method1()
{
[Link]("Method1 from Super class");
}
abstract public void method2();
}
class SubClass1 extends SuperClass
{
public void method2()
{
[Link]("Method2 from SubClass1");
}
}
class SubClass2 extends SuperClass
{
public void method1()
{

Inheritance [Link]("Method1 from Sub class2, overrides method1 from

114 and Polymorphism
“Only for Private Circulation”
Super Class"); Java Programming
}
public void method2()
{
[Link]("Method2 from SubClass2");
}
}
class AbstractMethod
{
public static void main(String arg[])
{
SubClass1 objSub1=new SubClass1(); SubClass2 objSub2=new
SubClass2(); [Link]("Object for SubClass1 : ");
objSub1.method2();
objSub1.method1(); [Link]("Object for SubClass2 : ");
objSub2.method2();
objSub2.method1();
}
}
The difference in first program is abstract class defines one additional
method ‘method2’ which is abstract method, and hence does not have
any definition for it. Derived classes from class ‘SuperClass’ need to
implement the method. Here we can observe that definition of
‘method1’ is optional for sub classes. If a sub class does not define the
method, it is executed from their super class. But ‘method2’ has to be
implemented by derived classes. In the following command window
output for the above program has been given. You can check by
commenting the definition of ‘method2’ in ‘SubClass2’ and the error
message given by the compiler.

ii) final – Already we have discussed about keyword ‘final’ in chapter 1,

while defining constants in a [Link] this sub section we are going Inheritance
and Polymorphism 115

“Only for Private Circulation”

 Java Programming to discuss how the key word can be used witheither class or a method
which helps to finalize their definitions. It has two different
applications as per its use either with class or a method. But as the
name suggests it finalizes the definition for both.
If the keyword is used with a class, the class cannot be modified further
by using inheritance. Any class cannot be derived from a final class.
Inheritance allows user to modify the previously defined class. But
here the class, as defined as ‘final’, cannot be used to derive any class.
The error raised by compiler when a final class is used in inheritance
is demonstrated with the help of following program.
/*Defining a final class and using it in inheritance*/ final class SuperClass
{
public void method1()
{
[Link]("Method1 from Super class");
}
}
class SubClass extends SuperClass
{
public void method2()
{
[Link]("Method2 from SubClass");
}
}
class FinalClass
{
public static void main(String arg[])
{
SubClass1 objSub=new SubClass(); [Link]("Object for
SubClass : "); objSub.method2();
objSub.method1();
}
}
Above program tries to extend the ‘SubClass’ from ‘SuperClass’ which
Inheritance is ‘final’ class, and hence while compilation of the program we get
116 and Polymorphism compilation error as shown below.
“Only for Private Circulation”
 Java Programming

In the same manner if we define a method to be final method, it cannot

be overridden by derived classes. When a sub class overrides any
method from super class, sub class is modifying the original method.
In situation where a method from super is to be declared as final
process and should not be modified in future, then it can be defined as
‘final’ method. The class defining final method can be used for
deriving a new class. But the sub class is not allowed to modify the
method from super which is ‘final’. The use of final method is
demonstrated in the following program –
/*Defining a final method and using it in inheritance*/ class SuperClass
{
final public void method1()
{
[Link]("Method1 from Super class");
}
}
class SubClass1 extends SuperClass
{
public void method2()
{
[Link]("Method2 from SubClass1");
}
}
class FinalMethod
{
public static void main(String arg[])
{
SubClass1 objSub1=new SubClass1(); [Link]("Object for
SubClass1 : "); objSub1.method2();
objSub1.method1();
}
}
Inheritance
and Polymorphism 117

“Only for Private Circulation”

 Java Programming In class ‘SuperClass’, which is super class for ‘SubClass1’, only one
method ‘method1’ is defined which is final. Hence ‘SubClass1’ cannot
override ‘method1’.Output for the program is shown in following
command window.

If sub class tries to override the method ‘method1’, compilation error

is given. The error is shown in following window –

iii) super – Inheritance helps to relate two classes where protected and
public members from super class are accessible to sub class definition.
Within subclass definition members from super class needs to be
accessed from processing. The keyword ‘super’ helps in accessing
super class members within sub class definition.
The keyword ‘super’ is used with two different contexts. It can be used
as an object or as a method (constructor). When ‘super’ is used as
object, it is used along with ‘.’ (dot operator), while using super as a
method (constructor from super class) is used with brackets. Use of
‘super’ keyword is demonstrated with the help of following program.
/*using super keyword for accessing members from super class*/ import
[Link].*;
class SuperClass
{
protected int i;
public SuperClass(int a)
{
i=a;
}
public void getData()
{
Scanner s= new Scanner([Link]); [Link]("Enter Value for i :
"); i=[Link]();
Inheritance
118 and Polymorphism }

“Only for Private Circulation”

public void displayData() Java Programming
{
[Link]("Value of i : "+i);
}
}
class SubClass extends SuperClass
{
private int j; public SubClass()
{
super(0); j=0;
}
public SubClass(int a, int b)
{
super(a);
j=b;
}
public void get()
{
[Link]();
Scanner s= new Scanner([Link]); [Link]("Enter Value for j :
"); j=[Link]();
}
public void display()
{
[Link](); [Link]("Value of j : "+j);
}
}
class SuperImp
{
public static void main(String arg[])
{
SuperClass objSup=new SuperClass(18); [Link]("Object for
Inheritance
SuperClass : "); [Link]();
and Polymorphism 119

“Only for Private Circulation”

 Java Programming SubClass
objSub=new SubClass(45,20); [Link]("Object for SubClass :
"); [Link]();
[Link]();
}
}
Above program shows how a keyword super helps to access members
from super class. In definition for class ‘SubClass’, the highlighted
part of code shows how same keyword ‘super’ can be used as
constructor or object. When

Kpvgthceg
Interface is a kind of class which cannot be instantiated i.e. an object cannot
be declared on an interface, but it can be implemented by other classes using
inheritance. Interface allows user to fully abstract a class which can be
implemented using multiple inheritance.

Fghkpkpi"Kpvgthceg
Interface is defined using keyword interface. The syntax for defining
interface is as given below-
<access modifier> interface <interface name>
{
< member methods and attributes>;
}
The interface definition starts with ‘access modifier’. Access modifier is
either public or not to be mentioned. It defines access of interface. If the access
modifier is not given the interface is accessible within package in which it has
been defined, but the public access gives public access to interface.
The ‘interface’ keyword starts definition of an interface class which cannot
be instantiated but can be implemented by other classes by deriving it. Every
interface like classes has member methods and member attributes. Member
methods in an interface are abstract methods defined without definition hence
syntax for definition of member methods ends with ‘;’, as shown in syntax below.
Inheritance
120 and Polymorphism
“Only for Private Circulation”
 <return data type><method name>( <parameter data type list> ); Java Programming
While the member attributes are final attributes and need to be assigned
with value, which is fixed while implementation and cannot be changed during
use. The syntax for definition of member attributes is given as-
<data type> final <member name> = <value> ;
All members in interface are implicitly public and static. Following code
demonstrates how a interface can be defined –
interface Shape
{
static final float pi=3.14F;
void getData(); void setData(int s);
void setData(int a,int b); void area();
void perimeter(); void display();
}
Above given code defines an interface with name ‘Shape’. As an interface
it defines one data member which is assigned with a final value and is of type
float, whose value cannot be changed. While other are signatures for the methods
‘getData’, ‘area’, ‘perimeter’, ‘display’ and the overloaded method ‘setData’. All
methods are defined with number and type of arguments and return data types.
While implementing interface ‘Shape’, the class need to implement all these
methods as per their signatures. If any method from interface class does not want
to implement then it can be defined with empty block.
After defining an interface user can compile the interface to create its
bytecode. And whenever need to implement the interface, by importing the
package the interface can be implemented by the class.

Wukpi"Kpvgthceg
Once defined interface can be implemented by any number of classes. To
implement an interface clause ‘implements’ is added with the class definition.
The class which implements interface needs to implement all methods from an
interface. Syntax for implementation of interface while defining class is given
as –
class <class name> [extends <superclass>] [implements <interface1>,
<interface2>, …]
{
<members from class>
}
Inheritance
and Polymorphism 121

“Only for Private Circulation”

 Java Programming Above syntax is given for implementation of an interface. Any class defined
using java cannot support multiple inheritance, but it can implement more than
one interface. A single class can be extended from a super class and at the same
time it can implement more than one interface which are followed by clause
‘implements’ and separated by commas. If a class implements two interfaces that
declare the same method, then the same method will be used by clients of either
interface. The methods that implement an interface must be declared public. Also,
the type signature of the implementing method must match exactly the type
signature specified in the interface definition.
Following code explains how we can use interface.
/*Inheriting Single interface*/ import [Link].*;
import [Link].*; interface Shape
{
static final float pi=3.14F; void getData();
void setData(int s);
void setData(int a,int b); void area();
void perimeter(); void display();
}
class Square implements Shape
{
private int p,s,a;
public void setData(int i)
{
s=i;
}
public void area()
{
a=s*s;
}
public void perimeter()
{
p=4*s;
}
public void display()
Inheritance {
122 and Polymorphism
“Only for Private Circulation”
 [Link]("\nSide of Square : "+s+"\nArea of Square : Java Programming
"+a+"\nPerimeter of Square : "+p);
}
public void getData() { } public void setData(int a,int b){ }
}
class Triangle implements Shape
{
private int base,height; private float a;
public void getData()
{
Scanner b=new Scanner([Link]); [Link]("\nEnter Base of
Triangle : "); base=[Link]();
[Link]("Enter Height of Triangle : "); height=[Link]();
}
public void area()
{
a=0.5F*(float)base*(float)height;
}
public void display()
{
[Link]("Base and Height of Triangle: "+base+"
"+height+"\nArea of Triangle : "+a);
}
public void setData(int a,int b)
{
base=a; height=b;
}
public void setData(int i){ } public void perimeter(){ }
}
class Circle implements Shape
{
private int r; private float a,p;
public void setData(int i) Inheritance
and Polymorphism 123

“Only for Private Circulation”

 Java Programming {
r=i;
}
public void area()
{
a=pi*r*r;
}
public void display()
{
[Link]("\nRadius of Circle: "+r+"\nArea of Circle :
"+a+"\nPerimeter of Circle : "+p);
}
public void perimeter()
{
p=2*pi*r;
}
public void setData(int a,int b){ } public void getData() { }
}
class InterfaceDemo
{
public static void main(String arg[])
{
Square s=new Square(); [Link](5);
[Link](); [Link](); [Link]();
Triangle t=new Triangle(); [Link]();
[Link]();
[Link]();
Circle c=new Circle ();
[Link](6);
[Link](); [Link](); [Link]();
}
}
Inheritance
124 and Polymorphism
“Only for Private Circulation”
 In the program class Square, Triangle and Circle implements interface Java Programming
‘Shape’. The interface ‘Shape’ tries to define all necessary data and processes as
per need for any shape. Each implementing class implements methods as per the
requirement of the shape, while remaining methods which are not required to
implement are written with empty blocks.
Following command window shows output for the above program.

Kpvgthceg"cpf"Encuu
In the previous chapter we have discussed class in detail, and in this section
we have discussed interface in detail. From the discussion we can conclude that
a class can be instantiated while an interface cannot. For a class user can define
an object, which can occupy memory and can store and process data. But, on the
other hand, for an interface it is not possible. For an interface an object cannot
be created and hence cannot store or process data. We can use interface only by
implementing it through a class. If we try to declare an object for an interface it
gives a compilation error. The error is demonstrated with the help of following
program.
interface Shape
{
static final float pi=3.14F; void getData();
void setData(int s);
void setData(int a,int b);
void area();
void perimeter(); void display();
}
class InterImp
{
public static void main(String arg[])
{
Shape objs=new Shape();
}
} Inheritance
and Polymorphism 125

“Only for Private Circulation”

 Java Programming For an interface ‘Shape’ class ‘InterImp’ tries to define an object. When the
program is compiled it gives a compilation error as ‘Shape is abstract’. This error
message explains the fact that though the ‘Shape’ is defined with keyword
‘interface’ JVM treats it as an abstract class. Therefore though we can see
‘[Link]’ file after compiling an interface, it is an abstract.

Cfxcpvcigu"qh"flkpvgthceg‚"qxgt"flcduvtcev"encuu‚"cpf"flcduvtcev"ogvjqf‚
The usage of abstract class and interface are similar, but any subclass cannot
be extended from more than one abstract class but any subclass can implement
more than one interface.
The abstract class can implement methods defined in it, hence if its subclass
does not implement the method, method from super class is executed. While
methods from interface needs to be implemented by the class who implements
the interface.

*****

Inheritance
126 and Polymorphism
“Only for Private Circulation”
 Java Programming

UNIT - 4
CONCURRENT PROGRAMMING

Ejcrvgt"Qdlgevkxgu"
To understand –
o Multitasking Programming and Threading
o Thread Synchronization

Eqpegrv"qh"Ownvkvcumkpi"cpf"Vjtgcfu
When a sequential process is being executed, it is assigned to a processor
and depending on its requirements processor goes on allocating resources to it.
Hence the processor is busy with the single process till it does not end. This is
known as Single Tasking.
With the development of multi core high speed processors the operating
systems became multitasking. In multitasking different processes reside in
memory and user can easily switch among processes. Like two different
applications like command window and notepad are open at the same time and
user can switch between these two applications. Some processes may be executed
simultaneously, which is achieved with parallelism. For example in background
some downloading is in progress, while in foreground user is editing some file.
In short, executing more than one process at a single time is known Multitasking
Programming. Multitasking programming can be achieved with two different
concepts –
• Process Based Multitasking
• Thread Based Multitasking
In process based multitasking two different independent processes are being
executed. These processes has their own space and own data. They do not share
any data among each other. This type of multitasking is controlled by operating
system, and programmer does not have any control on it.
While in thread based multitasking a single process is divided into small
independent units or sub- processes referred as ‘thread’. The multithreaded
program shares same memory, as it is anyhow a single process, and therefore
data can be shared among different threads. Programmer can control the
execution of threads. The concept of multi core processor has given rise to the
concept of threads. Here thread can be seen as threads working with a single
puppet to move its different parts simultaneously. In programming, while
Concurrent
implementing the concept of parallelism, a single program is divided in multiple
Programming 127

“Only for Private Circulation”

 Java Programming parallel tasks which are executed by different cores of the processor. Every task
from the program is assigned with a thread, which is used by the corresponding
core to execute the task. Therefore a thread can be defined as – “A lightweight
process being executed”. Along with introducing parallelism within multiple
cores, the concept of thread is more popular in network programming. When
different devices connected on a network are used in shared. Various resources
available on network can be used efficiently through multithreading concept. For
example when on a network different resources can be shared by multiple threads
being executed simultaneously, some threads may work in background like
writing data to database or taking print, while some may work in foreground like
accepting input from user etc.

Ownvkvjtgcfkpi"kp"lcxc
Java as a powerful programming language developed for network
programming, multithreading is one of its key characteristic. The package
‘[Link]’ defines classes and interfaces required for multithreading
programming. As discussed earlier ‘[Link]’ is the package which provides
basic functionalities required for writing program. So java provides thread as a
basic concept in programming, and to implement it programmer does not need
to take any extra efforts. In this chapter we are going to discuss about how we
can write programs supporting multiple threads.
Lifecycle of Threads [[Link] [[Link]]
Before writing programs implementing threads, we need to understand the
lifecycle of the thread. As thread is defined as a lightweight process, like every
process, it also needs to work in different states. States through which and
according to which execution of thread is defined, defines its lifecycle.
Java defines four basic states for a thread. When a thread is defined, it can
be in one of the four states. For every state its behavior can be defined. These
four 4 states in thread life cycle in java are ‘new, runnable, non-runnable or
blocked and terminated’. In addition to these four states, for better understanding
of lifecycle of thread we can add some more states like ‘waiting, timed-waiting’.
These different states are defined with help of different abstract methods which
are overridden by the implementing class. JVM controls different threads being
executed through these methods. All these states are explained as follows–
• New
A thread that is just instantiated is in new state. When a start() method
is invoked, the thread moves to the ready state from which it is
automatically moved to runnable state by the thread scheduler.

• Runnable (ready_running)
A thread executing in the JVM is in running state.
Concurrent
128 Programming
“Only for Private Circulation”
 • Non-Runnable (Blocked) Java Programming
A thread that is blocked waiting for a monitor lock is in this state. This
can also occur when a thread performs an Input / Output operation and
moves to next (runnable) state.

• Waiting
A thread that is waiting indefinitely for another thread to perform a
particular action is in this state.

• Timed_Waiting (sleeping)
A thread that is waiting for another thread to perform an action for up
to a specified waiting time is in this state. The thread from runnable
state can move to sleeping state by invoking sleep() method.

• Terminated (dead)
A thread that has exited is in this state. With the completion of
execution of run() method the thread is terminated.

Fig 4.1 : Lifecycle of Threads

Source :Object Oriented Programming with Java: Essentials and
Applications by Dr. Rajkumar Buyya

Etgcvkpi"Vjtgcfu
Though java provides thread technique as a basic functionality defined in
‘[Link]’, we need to make aware to processor of different thread, otherwise
the process will be executed as a single thread. For the purpose java provides
two methods to create threads in a program by using– Concurrent
Programming 129

“Only for Private Circulation”

 Java Programming 1. Thread class
2. Runnable interface.
Java defines two different methods how threads can be implemented, one
is using inheritance and other is by implementing interface. Next sub sections
discusses Thread class and Runnable interface long with some important abstract
methods defined by them.

Vjtgcf"Encuu
Class ‘Thread’ is defined in package ‘[Link]’. When programmer uses
threads, the class is derived from class ‘Thread’. Its syntax is shown below –
class <class name> extends Thread
{
/*Member definitions*/
}
Here programmer’s class is now sub class of class Thread. Hence members
from class Thread can be overridden by the programmer. The object defined on
the class is a threaded object and can be executed simultaneously with other
threads. This object is not like a normal class object and hence we need to execute
it differently. A threaded object needs to be assigned with the process which will
be executed without any interruption. This process can be defined by overriding
the abstract method ‘run( )’ in threaded class. Along with all members in a class
we can override a method ‘run( )’ which will change state of a thread from new
to ‘runnable’. Thus the thread class definition changes as –
class <threaded class name> extends Thread
{
/*Other member definitions*/ public void run()
{
/*Instructions to be executed as a process for thread*/
}
}
So now it can be observed that the threaded class definition has added with
a method ‘run( )’. The method run is responsible for defining the process which
will be executed as a thread.
The thread execution starts through threaded class object, which invokes
the ‘start()’. Method start is a method defined in class ‘Thread’, which is
responsible for starting execution of thread. When the method is called using
threaded class object, JVM calls method ‘run( )’ from threaded class. It syntax is
given below –
Concurrent
130 Programming
“Only for Private Circulation”
 class < threaded class name> extends Thread Java Programming
{
/*Other member definitions*/ public void run()
{
/*Instructions to be executed as a process for thread*/
}
}
class <implementation class name>
{
public void main(String arg[])
{
/*Define object on threaded class*/
<threaded class name><object name> = new <threaded
class name>;
/*Starting with thread execution*/
<object name>.start();
}
}
The above declarations can be understood better with the help of following
program –
/*defining and executing thread*/ class ThreadTrial extends Thread
{
public void run()
{
[Link]("Thread Execution Started");
}
}
/*Thread Implementation class*/ class ThreadImp
{
public static void main(String argv[])
{
ThreadTrial objTh=new ThreadTrial(); [Link]();
}
}
Concurrent
Programming 131

“Only for Private Circulation”

 Java Programming Here two classes are defined: ‘ThreadTrial’ and ‘ThreadImp’. Class
‘ThreadTrial’ is user defined thread class, while class ‘ThreadImp’ is class used
to define and use object on class ThreadTrial. The class ‘ThreadTrial’ defines
only one member, namely the method ‘run( )’, which gives message for starting
of thread execution. Output given by above program is shown below –

In the output message is displayed when the instruction –

[Link]();
is executed.
Following table [[Link]] [[Link]]lists some
methods defined in class ‘Thread’, which can be overridden by the threaded class.

Concurrent
132 Programming
“Only for Private Circulation”
 Java Programming

Twppcdng"Kpvgthceg
Other method to implement threads in our program is to implement interface
‘Runnable’. In this method instead of extending the class, whose object is to be
executed by thread, it implements interface. In the subsection we will discuss
sequence of steps for implementing Runnable interface.
The package [Link] defines this interface. The interface ‘Runnable’
defines the method ‘run’, which is to be overridden by the class implementing
interface.
Concurrent
Programming 133

“Only for Private Circulation”

 Java Programming Following syntax explains how a class can implement interface ‘Runnable’
–
/*Class implementing Runnable interface*/ class <class name> implements
Runnable
{
/*class members*/ public void run()
{
/*Process to be executed by thread*/
}
}

The above syntax shows how a user defined class can implement the thread.
The class definition starts with the keyword ‘class’ followed by ‘class name’ like
a normal class definition, but is followed by the keyword ‘implements’ and the
interface name ‘Runnable’. Implementation of interface ‘Runnable’ avails the
definition of the method ‘run’ to start with the thread process. The class can define
its own members along with the method definition for method ‘run’. The method
‘run’ defines, as discussed earlier while discussing class Thread, process to be
executed by thread.
The thread defined by the class can be executed through instance on class
Thread. Here the Thread object needs to be linked with object or reference class
implementing ‘Runnable’ interface to its object. So here to execute thread we
need two objects. One is for implementing class and one for class ‘Thread’. The
Thread class object needs reference to the implementing class object. Therefore
while declaring ‘Thread’ object parameterized constructor is used accepting
reference for implementing class object. Syntax for the for declaring and linking
class ‘Thread’ object is given below –
<class name><object name> = new <class name>( );
Thread <thread object name> = new Thread(<object name>);
Here <class name> is name of the class which implements ‘Runnable’
interface and <object name> is name of the object on implementing class. Same
object’s reference is passed as argument to constructor for Thread object.
Following code explains how to use ‘Runnable’ interface.
/*defining and executing thread using Runnable interface*/ class
RunnableTrial implements Runnable
{
intthid;

Concurrent publicRunnableTrial(int i)
134 Programming
“Only for Private Circulation”
 { Java Programming
thid=i;
}
public void run()
{
[Link]("Thread"+thid+" Execution Started
usingRunnableinterface ");
}
}
/*Thread Implementation class*/ class RunnableImp
{
public static void main(String argv[])
{
RunnableTrialobjRun=new RunnableTrial(1); Thread objTh= new
Thread(objRun); [Link]();
}
}
Above code defines two classes – first is the class which implements
‘Runnable’ interface to define thread, named ‘RunnableTrial’, while other to
execute thread named ‘RunnableImp’. The class ‘RunnableTrial’ defines a
parameterized constructor and overrides method ‘run’ from interface ‘Runnable’.
The class ‘RunnableImp’ executes thread using an object on class ‘Thread’
referencing to object on class ‘RunnableTrial’. Therefore firstly object on class
‘RunnableTrial’ (objRun) is created, whose reference is passed to thread object.
The object on class ‘Thread’ is created using constructor accepting object
reference as a parameter. After declaration of objects the thread execution is
started using method ‘start()’ from class ‘Thread’ which executes ‘run()’ method
from class ‘RunnableTrial’. Output for the following program is shown below –

Vjtgcf"encuu"Xu"Twppcdng"Kpvgthceg
Above subsections has discussed about two different methods for threading.
Both, the class and the interface, help to implement thread mechanism in
program. Now it is need to discuss their advantages and disadvantages over each
other. Concurrent
Programming 135

“Only for Private Circulation”

 Java Programming i. Class Thread: If a class extends class Thread, the class becomes a
thread itself and thus can easily implement all functionalities defined
by class Thread. Extending a class from thread is a powerful
functionality for threading.
But as we have discussed earlier if a user want to extend the class from
any other class along with Thread, then in java it is not possible in
java, as java does not support multiple inheritance.
For example suppose if class ‘B’ need to be a thread class so we derive
it from class ‘Thread’ as well as it need some functionalities from other
predefined class ‘A’, and so we need ‘A’ also as its super class so its
definition is written as –
Class B extends Thread, A
This will give compilation error. So here we need to implement
‘Runnable’ interface as shown below.
Class B extends A implements Runnable
The conclusion is though extending class ‘Thread’ provides more
powerful mechanism for implementing thread; it cannot be used with
multiple inheritances.
ii. Interface Runnable: The class implementing ‘Runnable’ interface
cannot execute thread mechanism without object on class ‘Thread’.
But as discussed earlier when user wants to implement multiple
inheritance he has to go with interface ‘Runnable’.

Vjtgcf"U{pejtqpk|cvkqp"<"Kpvtqfwevkqp
When more than one thread are sharing same resources, like data, memory
or input/output devices, we need to stop this parallel execution and make other
threads to wait till active thread completes its task so that proper output for the
program can be given. This is known as ‘Synchronization of Threads’.
Java provides a keyword ‘synchronized’ which helps in synchronizing
threads. The keyword can be used at two different levels –
• For a member method – Methods in class can be declared as
synchronized methods. A class for which multiple threads may be
defined, for methods of the class ‘synchronized’ keyword can be
applied. From the class if any method which uses sensitive resource
and if executed parallel mwy generate erroneous results can be defined
with synchronized keyword. Syntax used to define a method as
‘synchronized is given as –
<access modifier> synchronized <return type><method
name>(<arguments>);
• A block in ‘run’ – In run method also we can write the process block
Concurrent
136 Programming within ‘synchronized’ block. A set of instructions or call to methods

“Only for Private Circulation”

 which need to be synchronized and should not be called parallel we Java Programming
can enclose those instructions within ‘synchronized’ block. Following
syntax explains how ‘synchronized’ block can be defined in method
‘run’.
public void run()
{
.
.
synchronized
{
<instructions to be synchronized>
}
.
}
Following program explains how keyword helps to synchronize threads in
multithreading –
/*Synchronization of threads*/ import [Link].*;
[Link].*;
//class of which objects will be executed in parallel by multiple threads class
Array1D
{
privateint a[],n; public Array1D(int x)
{
n=x;
a=new int[n]; for(int i=0;i<n;i++)
a[i]=0;
}
public void getData()
{
Scanner s=new Scanner([Link]);
[Link]("Enter Array "+n+" Elements for object :");
for(int i=0;i<n;i++)
a[i]=[Link]();
} Concurrent
Programming 137

“Only for Private Circulation”

 Java Programming public void scalar(int s)
{
for(inti=0;i<n;i++)
a[i]=a[i]*s;
}
public void largest()
{
int l=a[0];
for(int i=0;i<n;i++)
if(l<a[i])
l=a[i];
[Link]("Largest element in array : "+l);
}
public synchronized void display()
{
[Link]("Array Elements : "); for(int i=0;i<n;i++)
[Link](""+a[i]);
[Link]("\n");
}
}
//Class which implement threads for class Array1D class ThreadedArray
extends Thread
{
Array1D array; private Thread t;
ThreadedArray(Array1D obj)
{
array = obj;
}
public void run()
{
synchronized(array)
{
[Link]();
}
[Link](); [Link](5); [Link]();
}
}
Concurrent class SyncDemo1
138 Programming
“Only for Private Circulation”
 { Java Programming
public static void main(String args[])
{
Array1D obj1=new Array1D(5); Array1D obj2=new Array1D(5);
ThreadedArray t1 = new ThreadedArray(obj1); ThreadedArray t2 = new
ThreadedArray(obj1); [Link]();
[Link](); try
{
[Link]();
[Link]();
}
catch(Exception e)
{
[Link]("Interrupted");
}
}
}
In the above program we have demonstrated how ‘synchronized’ keyword
can be used. Program uses the keyword for method ‘display()’ as well as, as a
block. The method ‘getData()’ which is not synchronized by definition, its call
is given within synchronized block. While method ‘display()’ is synchronized at
definition level, hence call to display method can be given like normal method
in ‘run’. Output for the above program is shown in following command window

Here we have executed two threads, but as both are sharing same data,
output for ‘display’ is same for both threads.
You can check the output by removing synchronized keyword, check what
happens.
***** Concurrent
Programming 139

“Only for Private Circulation”

 Java Programming

UNIT - 5
JAVA INPUT / OUTPUT

Ejcrvgt"Qdlgevkxgu"
To understand –
o What is Stream?
o Types of Streams
o Input/output in java

Eqpegrv"qh"Uvtgcou"]jvvr<11kkvk0ce0kp_
Like any other programming languages, java also defines functionalities for
basic input and output. For the purpose java provides two packages. First package
deals with console input and output while the second package for developing
GUI (Graphical User Interface), which defines different components for
accepting input and output. In short java provides three types of I/O operations
• Console Input /Output
• File Input / Output
• GUI Input / Output
A stream can be understood as a sequence of objects that supports various
methods which can be pipelined to produce the desired result. A stream is linked
to a physical device by the Java I/O system. As the all streams behave in same
manner, the same I/O classes and methods can be applied to any type of device.
For example the input may come from different sources like, it may be from file
on a disk or may be from keyboard or from a network socket, but the stream does
not [Link] means an ‘input stream’ can abstract many different kinds
of input. Likewise, an output stream may refer to the console, a disk file, or a
network connection. So streams only deals with input and output being ignorant
of source or destination. Java implements streams within class hierarchies defined
in the [Link] package. The class hierarchy defined in java package is shown in
following image -

140 Java Input / Output

“Only for Private Circulation”
 Fig 5.1 : Class Hierarchy in [Link] package for Byte Stream Java Programming
Source :[Link]
In the above diagram class hierarchy for byte stream is shown. The same
kind of hierarchy exists for character streams. We can observe that a wide variety
of I/O streams has been defined by java, for all hierarchy the only super class is
‘Object’, hence there exist uniformity in different streams. In the next section we
are going to discuss about types of streams.

V{rgu"qh"Uvtgcou
Streams can accept input or gives output using two basic types –
• Byte Streams
• Character Streams
These two types defines data represention using streams. Previously in
earlier versions of java was having only ‘byte stream’, but later on one stream
type was introduced for reading characters, known as character stream. Both
these streams are discussed in following subsections. At the system level still
byte stream is used, character stream is to add efficiency for handling characters.

D{vg"Uvtgcou
As the name suggests byte stream reads data in binary format. In hierarchy
for byte stream InputStream and OutputStream are two abstract classes at very
super level. These abstract classes have several concrete subclasses. These
subclasses are responsible for handling differences between various
[Link] classes are available in ‘[Link]’ package, and can be used after
importing this package. Mostly these classes are used to read data from disk files
and network connections. The most used methods used for byte streams are read(
) and write( ). These are abstract methods defined in classes InputStream and
OutputStream, which are overridden by their subclasses and creates a unique
environment for all streams.

Ejctcevgt"Uvtgcou
The class hierarchy for character stream defines two super classes, Reader
and Writer. These are the abstract classes designed to handle Unicode. These
classes define abstract methods which are overridden by their subclasses. ‘read(
)’ and ‘write( )’ methods are commonly used to read and write characters
respectively. Methods with same name are defined with byte streams also, and
this brings uniformity in both streams. These stream definitions are best examples
of dynamic method dispatching.

Kprwv"Qwvrwv"Jkgtctejkgu
While writing java program, if the program is using basic instructions, we
don’t need to import any package. The program itself imports ‘[Link]’ package
automatically. The package ‘[Link]’ defines all basic classes for example
Java Input / Output 141

“Only for Private Circulation”

 Java Programming Wrapper Classes etc. Along with these classes ‘[Link]’ defines a class ‘System’
which defines various aspects of run-time environment which are related with
core system. For console input and output we use class ‘System’ and some
predefined members from it which are discussed in detail in next sub sections.

U{uvgo
‘System’ class is defined in package ‘[Link]’. The class ‘System’ defines
various data members and methods which are helpful in satisfying basic system
related requirements of the programmer. For example to read current date and
time etc. The method for garbage collection ‘gc()’ is defined in class ‘System’.
When user want to terminate the program before completing its execution the
method used is ‘exit()’, it is also defined in class System. The functionalities
related with time, currency, copying a part of one array to other all such basic
functionalities which user may need to use as basic functionalities are defined
with class System.
Along with these members the class also defines three stream variables, ‘in’
for referring to standard input, ‘out’ to refer standard output and ‘err’ to refer to
standard error stream. All these variables are public and static and hence without
using object on class System we can use these variables.

U{uvgo0qwv
As discussed in previous sub-section ‘out’ is public static member defined
as instance on ‘[Link]’ in class ‘System’. ‘out’ always refers to
standard output stream. Most of the times it is console. When programmer want
togive message on console then using ‘print()’ or ‘println()’ method from class
‘PrintStream’ is used. Use of these methods we have already discussed in chapter
1, while discussing output.

U{uvgo0kp
Like ‘out’, ’in’ is an instance define on ‘InputStream’ class. It is a public
static member and is accessed through ‘System’ class. The object ‘in’ always
refers to standard input, which is a keyboard by default. The object helps to read
input from keyboard. In next sections when we will discuss about keyboard input,
objects defined on ‘Scanner’ is initialized with the object ‘[Link]’.

U{uvgo0gtt
[Link] refers to the standard error stream and an instance on class
‘PrintStream’. The object helps to print standard error.

Kprwv"Uvtgco
InputStream class is the superclass of all input classes. Itdeals with input
operations from input source through byte stream. As discussed earlier while
accepting input using keyboard we need to use object ‘in’ which an instance of
class InputStream. Other than keyboard, class InputStream and other different
142 Java Input / Output
“Only for Private Circulation”
classes derived from it helps to accept input from various sources without any Java Programming
realization of internal complexities.

Qwvrwv"Uvtgco"encuu
The [Link] class is the superclass of all classes representing
an output stream of bytes. An output stream accepts output bytes and sends them
to some sink.

Hkng"encuu
‘InputStream’ and ‘OutputStream’ are classes defined to deal with input
output of data through standard devices like keyboard and monitor. But when we
need to read and write data from or to file ‘File’ class in java helps. The File class
is Java’s representation of a file or directory path name. When in java there is
need to handle a file class ‘File’ is instantiated. The instance/object created on
file refers to the memory space where the file is stored temporarily. It also helps
in reading and writing data from file. Actually the object not only stores data
about file but also about location of file on external storage [Link] also provides
different methods which helps in processing on file location.
Syntax for defining object on class ‘File’ is given as below –
File <object name> = new File(String <filepath>);
Constructor in class file is overloaded, and hence an object on class ‘File’
can create with different methos. In the above syntax mostly used process for
creation of object for class ‘File’ is given. In the above syntax we have called
the constructor which accepts one argument of type ‘String’. Here String may
be file name, if it stored in the same folder, or otherwise it may be path. Following
code shows how to create ‘File’ object.
File fRef = new File(“Trial”);
Above instruction either creates (if not existing) or retrieves (if existing)
file with name “Trial”. The object created on class ‘File’ named as ‘fRef’ refers
to current file location and stores all details about file “Trial”.

Tgcfgt"encuu
It is an abstract class defined in package ‘io’ which is used as a super class
for all classes based on character stream. As we have discussed earlier java
defines two different hierarchies one for byte stream and other for character
stream. Earlier discussed classes are used for byte stream, while the class
‘Reader’ defines new hierarchy for character stream. It defines method to read
so that any class overriding method ‘read()’ can use it in any format.

Ytkvgt"encuu
Like class ‘Reader’ it is a super class for all classes in hierarchy supporting
character stream. The class defines basic output methods those all are
implemented by the classes in hierarchy. One of the mostly used method is
‘write()’.
Java Input / Output 143

“Only for Private Circulation”

 Java Programming FileReader an FileWriter [[Link]
Java FileWriter and FileReader classes are used to write and read data from
text files. It is recommended not to use the FileInputStream and
FileOutputStream classes if you have to read and write any textual information
as these are Byte stream classes.

ß Hkng"Tgcfgt
FileReader is useful to read data in the form of characters from a ‘text’
[Link] class inherit from the InputStreamReader Class. The constructors of this
class assume that the default character encoding and the default byte-buffer size
are appropriate. To specify these values yourself, construct an InputStreamReader
on a [Link] is meant for reading streams of characters. For
reading streams of raw bytes, consider using a FileInputStream.
Following program demonstrates how a file can be read using ‘FileReader’
// Demonstrate FileReader. import [Link].*;
classFileReaderDemo
{
public static void main(String args[]) throws Exception
{
FileReaderfr = new FileReader("[Link]"); BufferedReaderbr
= new BufferedReader(fr);
String s;
while((s = [Link]()) != null)
{
[Link](s);
}
[Link]();
}
}
The above program uses object on class ‘FileReader’ which throws
‘IOException’ which need to be handled and hence we define main as ‘throws
Exception’. ‘fr’ is an object on class ‘FileReader’ which executes constructor
accepting file name as an argument. The constructor opens file for reading. The
object ‘fr’ now refers to file and store entire details for file which are needed for
processing file. For reading data from file we have used ‘BufferedReader’ object
which helps in reading data using buffer. The ‘BufferedReader’ constructor
accepts reference to ‘FileReader’ object, as here the source for reading data is
file.
144 Java Input / Output
“Only for Private Circulation”
 Java Programming

ß Hkng"Ytkvgt
Class ‘FileWriter’ is used to create a text file. This class is subclass of the
class‘OutputStream’.The constructors of this class assume that the default
character encoding and the default byte-buffer size are acceptable. The
constructor on ‘FileWriter’ accepts file name as an argument which is created if
not existing, otherwise is overwritten. Following program demonstrates use of
‘FileWriter’ class.
// Demonstrate FileWriter. import [Link].*;
classFileWriterDemo
{
public static void main(String args[]) throws Exception
{
String source = "Welcome to the world of java file"; char buffer[] = new
char[[Link]()]; [Link](0, [Link](), buffer, 0); FileWriter
f = new FileWriter("[Link]");
for (int i=0; i <[Link]; i ++)
{
[Link](buffer[i]);
}
[Link]();
}
}
In the above program ‘buffer’ is defined as a character array, which is acting
as a buffer and helps in reading one by one character. ‘f’ is an object on class
‘FileWriter’ which refers to file ‘[Link]’. ‘for’ loop helps in reading character
by character from buffer and the method ‘write’ writes the character to the file
referred by object ‘f’. Following command window shows output for above
program.
Java Input / Output 145

“Only for Private Circulation”

 Java Programming

Hkng"Kprwv"Uvtgco
File Input Stream is useful to read data from a file in the form of sequence
of bytes. FileInputStream is meant for reading streams of raw bytes such as image
data.
//Reaing Data from file import [Link].*;
classReadFromFile
{
public static void main(String[] args) throws IOException
{
File f=new File("[Link]"); int c;
FileInputStreamfis=new FileInputStream(f); while((c=[Link]())!=-1)
[Link]((char)c); [Link]();
}
}
The program’s output is same as program for ‘FileReader’. But here
‘FileInputStream’ uses byte stream, and more useful for other type of files which
stores data in binary format than text files.

Hkng"Qwvrwv"Uvtgco
File Output Stream is meant for writing streams of raw bytes such as image
data. In such situations, the constructors in this class will fail if the file involved
is already open.
//Writing Data to file import [Link].*; class WriteTOFile
{
public static void main(String[] args) throws IOException
{

146 Java Input / Output

“Only for Private Circulation”
 String s=new String("Welcome to java file handling."); byte Java Programming
b[]=[Link]();
File f=new File("[Link]"); FileOutputStreamfos=new
FileOutputStream(f); [Link](b);
[Link]("File Created."); [Link]();
}
}
The program demonstrates writing of text file, but as the class
‘FileOutputStream’ uses byte stream it is more useful for binary data. For text
files ‘FileWriter’ class can be used.

Ugtkcnk|cvkqp
In some situations where we need to convert the data in object to byte
stream, where object is an instance on user defined class, or vice a versa then an
interface in ‘[Link]’ package named ‘Serializable’ is used. Mostly ‘Serializable’
interface is used when objects need to be transferred from one node to another
on network or to write an object to file. As against to ‘Serializable’, the byte
stream is deserialized which converts byte stream to corresponding object.
Deserialization is used to read object from file, as it is read as byte stream and
need to be converted to corresponding object, or when byte stream is received to
destination node it again need to be converted to corresponding object.
When one need to convert object to byte stream and byte stream to object
interface ‘Serializable’ is implemented. If the super class implements
‘Serializable’ sub class need not implement it. Following program explains use
of interface ‘Serializable’.
//Using Serializable interface to write and read object to and from file import
[Link].*;
class Student implements Serializable
{
private String name,course; public Student()
{
name="";course="";
}
public Student(String n,String c)
Java Input / Output 147

“Only for Private Circulation”

 Java Programming {
name=new String(n); course=new String(c);
}
void display()
{
[Link]("\n"+name+"\t\t "+course);
}
public String getName()
{
return([Link]);
}
public String getCourse()
{
return([Link]);
}
public void writeToFile()
{
/*writing object to file*/ try
{
FileOutputStreamfos=new FileOutputStream("student",true);
ObjectOutputStreamoos=new
ObjectOutputStream(fos); [Link](this);
[Link]();
[Link]();
}
catch(IOException e)
{
[Link]("Exception during Serialization : "+e); [Link](0);
}
}
public static void readFile()
{
Student f=new Student();
148 Java Input / Output
“Only for Private Circulation”
/*Reading object from file*/ try Java Programming
{
FileInputStreamfis=new FileInputStream("student"); while(true)
{
ObjectInputStreamios=new
ObjectInputStream(fis); f=(Student)[Link]();
if(f!=null)
{
if(f instanceof Student)
[Link]();
}
else
break;
}
//[Link]();
}
catch(EOFException e)
{
//[Link]("Exception during serialization : "+e);
//[Link](0);
}
catch(Exception e)
{
[Link](e);
}
//[Link]();
}
}
public class FileDemo1
{
public static void main(String a[])
{
Student f1=new Student("XYZ","BCA"); Student f2=new
Java Input / Output 149

“Only for Private Circulation”

 Java Programming Student("ABC","MCA"); Student f3=new Student("PQR","BCA");
[Link]("Data to be written to file:\n"); [Link]();
[Link]();
[Link]();
/*Adding data to file*/ [Link](); [Link](); [Link]();
/*Reading data from file*/
[Link]("\nData from File : \nName\t\tCourse");
[Link]();
}
}
Above program defines a class ‘Student’ which stores data of a student as
object. The program requires to store data of a student in a file, hence the class
implements the interface ‘Serializable’. The class defines all normal methods,
till this chapter we have discussed, other than ‘writeToFile’ and ‘readFile’.
Method ‘writeToFile’ is for adding a record at the end of file if file is already
existing otherwise create a [Link] writing data to file the method uses object
on‘FileOutputStream’. For the object‘fos’ constructor from ‘FileOutputStream’
accepts two arguments, filename and a Boolean value which sets toggle for
append to ‘true’, by default it is ‘false’. Here only class ‘FileOutputStream’
cannot help us to write data to file, as it is not a normal text file but a record file
which is an object. Hence we need the object of class ‘Student’ to be converted
to byte stream. For this conversion we use the object for class
‘ObjectOutputStream’. The object on ‘ObjectOutputStream’ refers to object on
‘FileOutputStream’. Class ‘ObjectOutputStream’ defines a method ‘writeObject’,
accepts one argument of type object, which gives output to the destination to
which it’s object is referring after converting it to byte stream. In this program it
writes to file ‘student’.
The method ‘readFile’ is a static method which is called through class and
not through object. It, as opposite to ‘writeToFile’ reads data from file as byte
stream and converts it to corresponding object. For retrieving file it uses object
on class ‘FileInputStream’, which opens file in read mode. For reading record as
byte stream and converting it to corresponding object, object on class
‘ObjectInputStream’ is required. Object on ‘ObjectInputStream’ is referring to
‘fis’, object on ‘FileInputStream’, from where record is to be read. For reading
record as byte stream and converting it to object ‘ios’ calls method ‘readObject’
from class ‘ObjectInputStream’. Here we need to use typecasting for converting
object to Student.

150 Java Input / Output

“Only for Private Circulation”
 Output for the above program is shown in the command window below. Java Programming

Dwhhgtgf"Uvtgcou
Buffer is an internal memory which can be described as array of bytes. It is
a temporary storage used in between the real stream and program variable. For
example while reading data from file, every time we read data of same length
which can be hold by variable and assign it to that variable. We process the data
in variable and again control goes to file stream to read next data. Here while
every time reading data from file a call to OS is generated, which becomes more
time consuming. Instead of this if we add a buffer between file and variable,
where size of buffer is large as compared to variable size. Once the buffer is
added, large size of data which can be accommodated in buffer is read from file
stream and is kept with buffer. Whenever, now read operation is to be carried out
instead of generating system call, now data is directly available in buffer. The
read operation on buffer is carried out till buffer is not empty.
Java defines ‘BufferedInputStream’ and ‘BufferedOutputStream’ for reading
and writing from and to buffer respectively.

Dwhhgtgf"Kprwv"Uvtgco"]jvvr<11lcxcfkhh0uqwteghqtig0pgv_
A ‘BufferedInputStream’ adds functionality to another input stream-namely,
the ability to buffer the input and to support the mark and reset methods. When
the BufferedInputStream is created, an internal buffer array is created. As bytes
from the stream are read or skipped, the internal buffer is refilled as necessary
from the contained input stream, many bytes at a time.

Dwhhgtgf"Qwvrwv"Uvtgco
[Link] class implements a buffered output stream.
By setting up such an output stream, an application can write bytes to the
underlying output stream without necessarily causing a call to the underlying
system for each byte written.

Java Input / Output 151

“Only for Private Circulation”

 Java Programming Dwhhgtgf"Tgcfgt"]jvvr<11uvcemqxgthnqy0eqo_
Reads text from a character-input stream, buffering characters so as to
provide for the efficient reading of characters, arrays, and lines.
The buffer size may be specified, or the default size may be used. The
default is large enough for most purposes.
In general, each read request made of a Reader causes a corresponding read
request to be made of the underlying character or byte stream.
It is therefore advisable to wrap a BufferedReader around any Reader whose
read() operations may be costly, such as FileReaders and InputStreamReaders.
Following program demonstrates how input can be accepted through
standard input using BufferedReader –
//Demonstrating BufferedReader import [Link].*;
classBufferedReaderDemo
{
public static void main(String args[]) throws IOException
{
BufferedReader b=new BufferedReader(new
InputStreamReader([Link])); [Link]("Enter an Integer : ");
int i=[Link]([Link]()); [Link]("Entered Integer is
"+i); [Link]("Enter a Float : ");
float f=[Link]([Link]()); [Link]("Entered Float is
"+f); [Link]("Enter a String : "); String s=[Link]();
[Link]("Entered String is "+s);
}
}
Output for the above program is shown in given command window.

Dwhhgtgf"Ytkvgt"]jvvru<11yyy0iggmuhqtiggmu0qti_

Bufferreader class writes text to character-output stream, buffering

[Link], providing efficient writing of single array, character and strings.
A buffer size needs to be specified, if not it takes Default value.
An output is immediately set to the underlying character or byte stream by
the Writer.
*****
152 Java Input / Output
“Only for Private Circulation”
 Java Programming

UNIT - 6
JAVA APPLETS AND GUI

Ejcrvgt"Qdlgevkxgu"<
To understand –
o What isApplet?
o Creating Simple Applet
o AppletLifecycle
o Concept ofAWT
o AWTcontrols

Crrngv"Eqpegrv
One of the major characteristics of Java Programming Language is to
support Internet Technologies and was found to be powerful as Network
Programming Language. Initially the language started its network programming
with ‘Applets’. In this chapter we are discussing about ‘Java Applets’. ‘Java
Applets’ are one of the popular application development tools for network. The
technology helps to develop small applications which executes as a part of web
document on internet server. Java from the scratch of development is worried
about security of resources on which the application is being executed. Applets
are executed on client’s machine with limited access to resources on client
machine. Hence it executes without introducing the risk of viruses or breaching
data integrity. While adding security features to applet technology it has given
rise to some drawbacks, because of which it has become outdated technology
and new versions of browsers do not support applets. Following points discuss
what developers cannot achieve using applets –
• An applet cannot read, write data on and from client’s machine and hence
cannot store any data permanently on client’s machine.
• It cannot call any program from client’s machine.
• It cannot discover any information about user from client’s machine like
user name or password.
• It cannot open network connections other than server from which the
applet is loaded.
In next sections we will see how we can develop and use applets to develop
internet applications.
Java
Applets and GUI 153

“Only for Private Circulation”

 Java Programming Etgcvkpi"Dcuke"Crrngv
An applet application is always derived from class Applet, defined in
package ‘applet’. Structure of the Applet program is different than normal object
oriented programs. The class ‘applet’ helps to execute this Graphical User
Interface (GUI) application using java enabled internet browser or using an
application known as ‘java appletviewer’. The application is developed in two
parts –
• Applet application (source code ‘.java’ and executable code ‘.class’)
• Hypertext code
Firstly source code for an applet application is written and compiled as a
java application. So any application will have two files, source code with
extension ‘.java’ and compiled code with extension ‘.class’.
As per earlier discussion, it is not a normal application and need to be
executed on internet browser, one another file or code we need to add. The code
written in ‘HyperText Markup Language (HTML)’, which explains browser
about the class file to be executed. When applet is to be executed using internet
browser we need to write different ‘.html’ file. If the applet is executed using
appletviewer embedded html code is written in commented section, which can
be read and executed by appletviewer.

Crrngv"Crrnkecvkqp"⁄
Firstly we will see structure of simple applet application shown in following
table, which is saved with extension ‘.java’.
/*Import necessary packages required to execute applet */ import [Link].*;
[Link].*;
/*start applet extension of class Applet*/
public class <Applet Class Name> extends Applet
{
public void paint(Graphics g)
{
/*Code to execute an applet*/
}
}
Above code gives syntax for developing a small and simple applet
application. An applet application starts with import statement. While designing
an applet we need to import minimum two packages, which make us available
necessary classes required to develop a minimum applet.

Java
154 Applets and GUI
“Only for Private Circulation”
 The first package is ‘[Link]’, which helps us to develop GUI for Applet. Java Programming
The second package is ‘[Link]’ which avails class ‘Applet’, used as
super class for our applet application. Every applet application is supposed to be
sub class of class ‘Applet’. Derivation of class ‘Applet’ is shown in figure given
below –

As shown in figure 6.1, class ‘Applet’ is extension of class ‘Panel’, defined

in ‘awt’ package, which facilitate user to define an area where he can develop
window based application (GUI). Class ‘Panel’ is a container class which can
hold different individual controls as a group. This is because it derives properties
derived from its super class ‘Container’. Class ‘Container’ defines a category of
components whose properties are different than other components, which are
hierarchically managed as subclasses of class ‘Component’, which is super class
for all these classes. So it can be observed that here ‘Multi Level Inheritance’ is
implemented.
Applet class defines various methods which can be overridden by the user.
These methods help to define lifecycle of an applet as well as to control the
applet. All methods are described in sub sections

80304"cpf"803050
After ‘import’, definition of applet application starts. The applet application
class is always defined as ‘public’, so that the class definition will be publically
accessible to external applications like ‘html’ code file or appletviewer. It is
followed by the keyword ‘class’ and class name for the applet application. The
class name is nothing but applet application name. As discussed above we need
to define applet application class as sub class of class ‘Applet’. The class extends
system class ‘Applet’, so class name is followed by ‘extends Applet’, so that all
methods from class ‘Applet’ are available to user.
The class definition defines processes for applet application which is
implemented through different overridden methods from class ‘Applet’. Every
applet application starts execution from method ‘paint()’, which is same as
‘main()’ method in any java application. Applet can override methods from class
‘Applet’, which helps to add processes to be executed depending on its life state
like ‘init()’, ‘start()’ and many more.

Java
Applets and GUI 155

“Only for Private Circulation”

 Java Programming JVON"eqfg"⁄
After completing applet application, the second part for the application
needs to be written, which is ‘HTML’ code to execute an applet. Minimum
HTML code to be written is given in following block –
<html>
<body>
<applet code="AppletClassName" width=200 height=60>
</applet>
</body>
</html>
The code uses html tags, necessary to execute an applet application. Only
new tag used is ‘applet’.

Vjg"vci"flcrrngv‚"ku"wugf"ykvj"vjtgg"cvvtkdwvgu"⁄
Code – Value of attribute is the class name of an applet application. Width
– It is assigned with the initial width of an applet application. Height – It is
assigned with the initial height of an applet application.
If developer wishes to run an applet using appletviewer application, in case
same HTML code is embedded in ‘.java’ file within comments. These html tags
are not known to the java compiler hence html code is written within comments
as non-executable code. Appletviewer application can execute this commented
code and can execute the application. The format to add HTML code in ‘.java’
file of an applet is shown in following block –
/*Import necessary packages required to execute applet */ import
[Link].*;
[Link].*;
/*HTML code for appletviewer*/
/*<html>
<body>
<applet code="AppletClassName" width=200 height=60>
</applet>
</body>
</html>*/
/*start applet extension of class Applet*/
public class <AppletClassName> extends Applet
{
Java
156 Applets and GUI public void paint(Graphics g)

“Only for Private Circulation”

 { Java Programming
/*Code to execute an applet*/
}
}

k0 Crrngv"Crrnkecvkqp"wukpi"Dtqyugt
Following program shows a simple applet application with name
‘WelcomeApplet’. The first block is code for applet while in second block code
for html file is given. Explanation for the code is given below code.
import [Link].*; import [Link].*;
public class WelcomeApplet extends Applet
{
public void paint(Graphics g)
{
[Link]("Welcome to the world of Applet", 20, 20);
}
}
As discussed earlier firstly we import two packages, package ‘awt’ and
package ‘applet’, ‘awt’ helps to interact with user using GUI while ‘applet’ avails
class ‘Applet’ definition.
The next line in the program declares the public class ‘WelcomeApplet’,
hence the file is saved with name ‘[Link]’. Inside WelcomeApplet,
paint( ) is declared. ‘paint( )’ is called each time to redisplay its output. The paint(
) method has one parameter of type Graphics. This parameter contains the
graphics context, which describes the graphics environment in which the applet
is running. This context is used whenever output to the applet is required.
Inside paint( ) is a call to drawString( ), which is a member of the Graphics
class. This method outputs a string beginning at the specified ‘x, y’ location. It
has the following general form:

xqkf"ftcyUvtkpi*Uvtkpi"oguucig."kpv"z."kpv"{+
Here, message is the string to be output beginning at x,y which represents
coordinates of output screen. In a Java window, the upper-left corner is location
0,0. The call to drawString( ) in the applet causes the message “Welcome to the
world of Applet” to be displayed beginning at location 20,20.
Following block shows html code to be executed using browser –
<html>
<body> Java
Applets and GUI 157

“Only for Private Circulation”

 Java Programming <applet code="WelcomeApplet" width=200 height=60>
</applet>
</body>
</html>
Above code shows minimum html code to execute the ‘WelcomeApplet’.
This file is saved with extension ‘.html’ and is opened with browser. If the
browser is java enabled then the message ‘Welcome to the World of Applet’ is
displayed in browser window.

Gzgewvkqp"Uvgru"hqt"Crrngv"Crrnkecvkqp"wukpi"dtqyugt"⁄
1. Write source code for applet application and save file with extension
‘.java’.
2. Compile source code with command ‘javac [Link]’. it
will create class file for source code.
3. Create HTML file and save with extension ‘.html’ in same directory
where class file for source code is stored.
4. Open html file using java enabled browser, which executes the applet.

kk0 Crrngv"Crrnkecvkqp"wukpi"CRRNGVXKGYGT
When an applet is to be executed using appletviewer, same applet
application code is written along with html code as discussed above. The code
for ‘WelcomeApplet’ is given in the block below.
import [Link].*; import [Link].*;
/*
<html>
<body>
<applet code="WelcomeApplet" width=200 height=60>
</applet>
</body>
</html>
*/
public class WelcomeApplet extends Applet
{
public void paint(Graphics g)
{
[Link]("Welcome to the world of Applet", 20, 20);
Java
158 Applets and GUI
“Only for Private Circulation”
 } Java Programming
}
It can be seen that here both programs i.e. ‘[Link]’ and
‘[Link]’ are written in single file named as ‘[Link]’.
Execution steps are given as below –

Gzgewvkqp"Uvgru"hqt"Crrngv"Crrnkecvkqp"wukpi"crrngvxkgygt"⁄
1. Write source code for applet application and save file with extension
‘.java’.
2. Compile source code with command ‘javac [Link]’. It
will create class file for source code.
3. Execute the program using following command at command prompt
The command executes appletviewer application. It accepts source code
filename, and works on commented html code from source code.
Following image shows execution of an applet ‘WelcomeApplet’ through
appletviewer.

Crrngv"Nkhge{eng
We have already discussed every applet application is derived from class
‘Applet’ and it overrides methods defined in class ‘Applet’. These methods help
developer to define state specific behavior to applet application as well as to
control applet execution. In this section we are going to discuss about methods
which define different life cycle events of an applet. These methods help the
browser or applet viewer interfaces to the applet and controls its execution. Four
of these methods are —
• init( ) – Here ‘init’ stands for initialization. It is the method from which
applet execution starts. The method is executed when applet is executed
for the first time. Generally it is defined to initialize all data members as Java
it is executed only one time. Applets and GUI 159

“Only for Private Circulation”

 Java Programming • start( ) – The method is executed right after execution of ‘init’ is
completed as well as when the control enter the applet. In multitasking
systems when a control from one application returns to the applet, the
method is executed. Generally the method defines process to start or
resume with an application. Mostly the method defines process to start
with animation.
• stop( ) – As opposite to ‘start’ the method is executed when the control
changes to other application from the applet application. It is executed
to stop the thread of animation.
• destroy( ) – The method as opposite to ‘init’ and is executed when user
closes the applet application.
• paint( ) – The paint( ) method defined in AWT, is called each time your
applet’s output must be redrawn. This situation can occur for several
reasons. For example, the window in which the applet is running may be
overwritten by another window and then uncovered. Or the applet
window may be minimized and then restored. paint( ) is also called when
the applet begins execution. Whatever the cause, whenever the applet
must redraw its output, paint( ) is called. The paint( ) method has one
parameter of type Graphics. This parameter will contain the graphics
context, which describes the graphics environment in which the applet
is running. This context is used whenever output to the applet is required.
From above discussion we can diagrammatically we can represent sequence
for call of methods as below –

The following code block represents skeleton for writing an applet with all
above defined methods –
// An Applet skeleton. import [Link].*; import [Link].*;
/*
Java <applet code="AppletSkel" width=300 height=100>
160 Applets and GUI
“Only for Private Circulation”
 </applet> Java Programming
*/
public class AppletSkel extends Applet
{
// Called first. public void init( )
{
// initialization
}
/* Called second, after init(). Also calledwhenever the applet is restarted.*/
public voidstart()
{
// start or resume execution
}
// Called when the applet is stopped. public void stop()
{
// suspends execution
}
/* Called when applet is terminated. This is the last method executed. */
public void destroy()
{
// perform shutdown activities
}
// Called when an applet's window must be restored. public void
paint(Graphics g)
{
// redisplay contents of window
}
}
It is important to understand the order in which the various methods shown
in the skeleton are called.
When an applet begins, the AWT calls the following methods, in this
sequence:
• init( )
Java
• start( ) Applets and GUI 161

“Only for Private Circulation”

 Java Programming • paint( )
When an applet is terminated, the following sequence of method calls takes
place:
• stop( )
• destroy( )

Eqpvtqnnkpi"Crrngv"Eqpvgpv
Applets have graphical user interface, and for the purpose as mentioned
above AWT classes are used to add graphics to an applet. Some of the methods
from AWT which help to design applet are as follows-

k0 ftcyUvtkpi*"+"<
It is a member of the Graphics class and so while calling it we need object
on class ‘Graphics’. Typically, it is called from within either update( ) or paint(
). It has the following general form –
voiddrawString(String message, intx, inty);
Here, messageis the string to be output beginning at x,y. In a Java window,
the upper-left corner is location 0,0. The drawString( ) method will not recognize
newline characters. If you want to start a line of text on another line, you must
do so manually, specifying the precise x,y location where you want the line to
begin.
For eg. the method draw string can be used as –
[Link](“Welcome to Applet”,20,20);
Here ‘g’ is an object on class ‘Grphics’. An applet window is referred as
‘Graphics’ object named ‘g’. The string passed as message is displayed at given
position by x and y.

kk0 ugvDcemitqwpf*"+."ugvHqtgitqwpf*"+<
setBackground( ) and setForeground( ) are used to design a colourful
[Link] color for an applet’s window can be set using
‘setBackground( )’, while to set the foreground color ‘setForeground( )’ is used.
These methods are defined by Component, and they have the following general
forms –
voidsetBackground(Color newColor);
void setForeground(Color newColor);
Both methods accepts color name as argument. ‘Color’ is the class defined
in Component hierarchy, which has defined different constants as variety of
colors. Different Color constants are shown here that can be used to specify
colors –
Java
162 Applets and GUI
“Only for Private Circulation”
 [Link], [Link], [Link], [Link], [Link], Java Programming
[Link], [Link], [Link], [Link], [Link],
[Link], [Link]
For example, to set the background color to green and the text color to
yellow these methods can be used as –
setBackground([Link]);
setForeground([Link]);
Generally background and foreground colors are set in init( ) method for
an applet, from where applet execution starts. Runtime these colors can be
changed as per the requirement in any method. The default foreground color is
black. The default background color is light gray.

kkk0 igvDcemitqwpf*"+.igvHqtgitqwpf*"+"<
When we need to check background and fore ground colors for the current
applet, then these two methods can be used. These methods are defined by
Component. Syntax for these two methods is given as here –
Color getBackground( );
Color getForeground( );
Both these methods return ‘Color’ constant name.

kx0 ftcyNkpg*"+"<
The method from class Graphics draws line of 1 pixel thick joining two
pixels, start and end. With the method we need to pass start position and end
position, by specifying its x and y co-ordinates. Syntax for drawLine() method
is given as –
voiddrawLine(int x1, int y1, int x2, int y2);
For example –
[Link](10,10,30,40);
It uses current set color to draw line.

x0 ftcyTgev*"+."hknnTgev*"+"<
Both these functions defined in class ‘Graphics’ draws rectangle of given
size. First function ‘dawRect( )’ draws rectangle while ‘fillRect( )’ draws and
fills the rectangle by currently set color. Both methods accepts four arguments –
‘x’ coordinate, ‘y’ coordinate, width and height. According to width and height
arguments it calculates the ending position and draws the rectangle. Syntax for
both methods is given as –
voiddrawRect(int x1, int y1, int width, int height);
void fillRect(int x1, int y1, int width, int height); Java
Applets and GUI 163

“Only for Private Circulation”

 Java Programming For example –
[Link](10,10 50,60);
[Link](10,10 50,60);

xk0 ftcyRqn{iqp*"+."hknnRqn{iqp*"+
These polygon method draws closed polygon. Methods need all points to
be connected as polygon, which are passed as argument. Therefore a collection
of all points is passed as arrays, one for ‘x’ co-ordinates and other for ‘y’ co-
ordinates, as well as number of points to be plotted in polygon. The array is one
dimensional and is even in size, as two adjacent elements in array are co-ordinates
for one point in polygon. As arguments passed are coordinates for x and y and
hence size of both arrays should be same. Following syntax shows how we can
use methods ‘drawPolygon’ and ‘fillPolygon’.
voiddrawPolygon(int x[], int y[], intnumberOfPoints);
void fillPolygon(int x[], int y[], intnumberOfPoints);
For example –
intx[]={10,20,35,25};
inty[]={20,30,15,10};
[Link](x,y,4);
[Link](x,y, 4);

Ogvjqf"tgrckpv*+
When we want to add animation to applet then we need to use method
‘repaint()’. As discussed earlier method paint() is executed only once in sequence,
but when we want to add some moving objects to applet we can call repaint().
Following Program shows use of ‘repaint()’ method. The program uses concept
of ‘Thread’ which we discussed in chapter IV.
/*<applet code=BouncingBallSmooth width=500 height=500>
</applet> */
[Link].*; import [Link].*;
public class BouncingBallSmooth extends Applet implements Runnable
{
intx,y; intdx,dy; Thread t;
public void init()
{ x=40; y=40;
dx=30; dy=30;

Java t=new Thread(this); [Link]();

164 Applets and GUI
“Only for Private Circulation”
} Java Programming
public void run()
{
while(true)
{
if(x<40 ||x>260)
dx=-dx; if(y<40 ||y>230)
dy=-dy;
x+=dx;
y+=dy; try
{
[Link](200);
}
catch(Exceptione)
{
[Link](e);
}
repaint();
}
}
public void paint(Graphics g)
{
[Link](10,10,300,270); [Link]([Link]); [Link](x,y,30,30);
}
}
Output for the above program is given below -

Java
Applets and GUI 165

“Only for Private Circulation”

 Java Programming Cduvtcev"Ykpfqy"Vqqnmkv*CYV+"⁄"Kpvtqfwevkqp
So far in previous chapters we have discussed different concepts in java and
programs executed using command prompt. Introduction of AWT allows
programmer to develop GUI based input and output. Package AWT defines a
wide variety of classes which makes java rich in GUI. These classes helping in
development of GUI are defined in package ‘[Link]’, and before using it we
need to import the package. Classes in awt package are arranged in hierarchies,
where each class defines its own characteristics and behavior. Every class in ‘awt’
is referred as a ‘control’. These controls helps user to control input, output and
process for an application. When a java application is developed with GUI, it
functions at three different levels – first is the ‘business logic’ which helps
application to store and process system data, second is GUI developed using
‘awt’ controls behind which the business logic executes and third is DBMS which
helps to store application data permanently. In this section we are going see
introduction to use of controls.

CYV"Eqpvtqnu
As stated in introduction package ‘awt’ provides wide variety of classes
helping to develop GUI for an application and these classes are arranged
hierarchically. The hierarchy of classes in ‘awt’ package is represented with the
help of following diagram shown in figure 6.1.
The classes in ‘awt’ acting as controls are derived from a super class
‘Component’. These controls are divided under three categories –
• Container classes – As the name suggests objects created on container
classes can store references to other control objects, and hence create
group of controls. The class ‘Container’ defines two sub classes –
‘Window’ and ‘Panel’. Sub classes from class ‘Window’, ‘Frame’ and
‘Dialogue’, are used for a desktop applications while the ‘Panel’ is used
for development of ‘Applets’. Responsibility of container objects is to
refer its controls collectively.
• Input controls – ‘TextField’, ‘TextArea’, ‘CheckBox’ etc. are input
controls which helps user to accept input from user. These are individual
controls and can be used as a part of a container.
• Output controls – ‘Label’ is a output control helps to give corresponding
messages for input.
• Processing Controls – the controls which are responsible for carrying
out process are the processing controls. ‘Button’ is a processing control.
• Navigation Controls – ‘Menu’ is acting as a navigation control which
helps to change control among different forms.

Java
166 Applets and GUI
“Only for Private Circulation”
 Java Programming

Fig. 6.1 : Class Hierarchy for package ‘awt’ Source

:[Link]
In the next sub-sections we will discuss some frequently used controls and
their associated events. For adding controls to GUI, an object is defined on the
corresponding class. While defining an object constructor from the corresponding
class is used to initialize it. Every control class defines methods which helps to
carry out certain processes which is known as ‘Event Driven Programming’. All
event handlers are interfaces which helps to use more than one listener at a time.
These events are categorized under different headings and accordingly different
event handling interfaces are defined like ActionListener, MouseListener,
KeyListener etc. As response to different activities undertaken by user proper
listener gets activated and a functionality written by programmer is executed.
Following are general steps which helps to design GUI –
1. Derive a GUI class from container class OR define an object for
container class.
2. Define objects for all required controls as per the requirement. Every
object should be assigned with unique name. Multiple objects for
single control can be defined.
3. Using ‘setBounds()’ method for each control fix position and size for
each control on the form. It is derived method by super class and hence
available for all controls.
4. Add all controls to container object, using ‘add()’ method defined by
container classes.
Java
Applets and GUI 167

“Only for Private Circulation”

 Java Programming 5. Add proper listener and add method to be executed as response to
event.
This completes designing of GUI. In the following sub sections we will
discuss different controls and their uses. At the end of discussion for all controls
we will see one small program to display largest out of three numbers using ‘awt’.

Dwvvqp
It is an action based control defined in ‘awt’ package. Every button is
assigned with a ‘label’ which describes action in short taken by the ‘Button’,
hence labels for Buttons are action based words.
Following syntax explains how an object button can be defined –
Button <object name> = new Button(<label for Button>);
With the above syntax a Button object is created on class Button and is
assigned with the label passed as argument to constructor.
For example –
Button btnAdd = new Button(“Add”);
Above instruction defines a Button object which is referred by name
‘btnAdd’ and is assigned with label “Add”. The prefix used with every control
helps us to differentiate between different controls. For Button we use prefix as
‘btn’.
For finalizing its size and position method ‘setBounds()’ is executed.
‘setBounds’ accepts four arguments – first two arguments are its ‘x’ and ‘y’
positions, while last two arguments are width and height of the control. Following
instruction shows how method is called –
[Link](50,100,40,30);
For a Button we can add‘ActionListener’and to handle the action of ‘click’
add method ‘actionPerformed()’.

Ncdgn
It is an output control which helps to improve user interaction. When an
input control is expecting some input from user, it is explained with the help of
labels.
Following is the syntax for defining a label –
Label <object name> = new Label(<text for label>);
Label lblFNum = new Label(“Enter First Number : ”);
For example –
Here we have defined a Label with name ‘lblFNum’. While defining label
String is passed which will be displayed as it is. From the message given in
Java example you can understand that it is for explaining user of application about
168 Applets and GUI
“Only for Private Circulation”
the input value. Hence proper use of labels helps to improve user interface. Next Java Programming
is to ‘add’ label to container object and setting size of label using ‘setBounds()’
method. Like Button for label we can add ‘ActionListener’.

Vgzv"Hkgnf"
It is an input control. Generally when we need some input from user we can
use ‘TextField’. It can accept a single line text.
Syntax for defining object on ‘TextField’ is given below –
TextField<object name> = new TextField( );
For example –
TextFieldtxtFNum = new TextField( );
Here we have defined a new TextField object with name ‘txtFNum’. After
defining object add object to container and set size and position for the control.
For TextField we can add ‘KeyListener’ and override method ‘keyPressed’
or ‘keyTyped’ using which we can scan the input given by user.

Vgzv"Ctgc
It is same as TextField and have same properties and syntaxex. The only
difference between TextField and TextArea is it can accept multiple lines as
input. Generally TextArea is used while accepting address or feedback where
user need to enter multiple lines.

Ejgemdqz
It is again an input control used to accept value as true or false by checking
or non checking the option. It stores value of type Boolean. When we want to
accept an input from user which has only two possible values ‘true’ or ‘false’
then we can use checkbox. For example marital status, gender etc. Following
syntax shows how a checkbox object can be declared –
Checkbox <object name> = new Checkbox (<label> [, <default value>]);
For example –
Checkbox chkUnmarried= new Checkbox (“Unmarried”,true);
Checkbox chkMarried= new Checkbox (“Married”);
By default checkbox value is unchecked i.e. false. If while defining you
need to define as checked then we can set its value to true, but it is optional. In
the above example we have defined two checkboxes ‘chkUnmarried’ and
‘chkMarried’. We have assigned default value for ‘chkUnmarried’ as true while
for other as false.
With checkbox we can add ‘ItemListener’ for which we need to override
method ‘itemStateChanged’ which is executed when user clicks on checkbox and
changes its status. Java
Applets and GUI 169

“Only for Private Circulation”

 Java Programming Ueqnndct
It is an adjustment control which can be used with other controls to change
scope of view. Syntax for declaring object is given as –
Scrollbar <object name> = new Scrollbar( );
For example –
Scrollbar s = new Scrollbar( );
With a scrollbar we can add ‘AdjustmentListener’ using which process for
adjustment in scrollbar can be executed.

Ogpw
Menu in java consists of three components –
• Menu bar
• Menu
• Menu item
Menu bar is a component which consists of different menus while a menu
consists of menu item. ‘MenuBar’ is the class which allows user to define object
for menu bar. For defining menu class ‘Menu’ is used, while for defining menu
items class ‘MenuItem’ is used. These different objects can be linked with each
other by adding object of MenuItem to Menu and adding Menu objects to
MenuBar and adding MenuBar to form.
Following syntaxes shows how objects on these classes can be defined –
MenuBar<object Name>=new MenuBar( );
Menu <object Name>=new Menu(<Label for Menu>);
MenuItem<object Name>=new MenuItem(<Label for Menu>);
MenuBarmainMenu=new MenuBar( ); Menu menu1=new
Menu(“Menu1”); Menu menu2=new Menu(“Menu2”);
MenuItem menuItem11=new MenuItem(“Menu Item1 in Menu1”);
MenuItem menuItem21=new MenuItem(“Menu Item1 in Menu2”);
Following example explains how objects can be declared on these
components –
Here in the above code we have defined a menu bar with name ‘mainMenu’.
In ‘mainMenu’ we have defined ‘menu1’ and ‘menu2’. Under each menu we
have defined one menu item, ‘menuItem11’ in ‘menu1’ and ‘menuItem21’ in
‘menu2’. Here we need to link these items with each other as follows –
Frame f=new Frame(); [Link](mainMenu);
[Link](menu1);
[Link](menu2);
Java
[Link](menuItem11); [Link](menuItem21);
170 Applets and GUI
“Only for Private Circulation”
Ucorng"Rtqitco"wukpi"flcyv‚" Java Programming
Output for the above program is given as -
/*Finding Largest out of 3 using awt*/ import [Link].*;
[Link].*;
public class Max3num extends Frame implements
ActionListener,TextListener
{
Label l1,l2,l3,l4; TextField t1,t2,t3,t4; Button submit,reset;
int num1,num2,num3,max; String num1str,num2str,num3str;
/*Constructor for class Max3num*/ public Max3num()
{
super("Maximum Of Three Numbers"); setLayout(new FlowLayout());
l1 = new Label("Enter FirstNumber"); add(l1);
t1 = newTextField(10); add(t1);
l2 = new Label("Enter SecondNumber"); add(l2);
t2 = newTextField(10); add(t2);
l3 = new Label("Enter ThirdNumber"); add(l3);
t3 = newTextField(10); add(t3);
submit = new Button("SUBMIT"); add(submit);
reset = new Button("RESET"); add(reset);
l4 = new Label("Maximum of 3 numbers are"); add(l4);
t4 = new TextField(10); add(t4);
[Link](this); [Link](this); [Link](this);
[Link](this); [Link](this);
}
public void textValueChanged(TextEventte)
{
if ([Link]() == t1)
{
num1str = [Link]();
num1 = [Link](num1str); [Link]("Maximum of "+num1);
}
else if ([Link]() == t2) Java
Applets and GUI 171

“Only for Private Circulation”

 Java Programming {
num2str = [Link]();
num2 = [Link](num2str); [Link]("Maximum of
"+num1+","+num2);
}
else if ([Link]() == t3)
{
num3str = [Link]();
num3 = [Link](num3str);
[Link]("Maximum of "+num1+","+num2+" & "+num3);
}
}
public void actionPerformed(ActionEventae)
{
if ([Link]() == submit)
{
max = num1;
if (num2 > max)
max = num2; if (num3 > max)
max = num3; [Link](""+max);
}
else if ([Link]() == reset)
{
[Link](null); [Link](null); [Link](null); [Link](null); num1=0;
num2=0; num3=0; max=0; num1str = null; num2str = null; num3str =null;
}
}
public static void main(String args[])
{
Max3num ob = new Max3num(); [Link](300,300); [Link](true);
}
}
Java
172 Applets and GUI
“Only for Private Circulation”
Output for the above program is given as - Java Programming

*****

Java
Applets and GUI 173

“Only for Private Circulation”

 Java Programming Cddtgxcvkqpu"⁄

Tghgtgpegu"⁄
Dqqmu"⁄
1. ‘The Complete Reference – Java 2’, Fifth Edition, Herbert Schildt
2. ‘Core Java Volume 1- Fundamentals’, Eighth Edition, Cay S.
Horstmann, Gray Cornell Websites –
1. [Link]
2. [Link]
3. [Link]
4. [Link]
5. [Link]
6. ss[Link]
7. [Link]
8. [Link]

*****

Java
174 Applets and GUI
“Only for Private Circulation”