CS8392 Object Oriented Programming Notes 1

www.studymaterialz.
in
CS8392 OBJECT ORIENTED PROGRAMMING
UNIT I INTRODUCTION TO OOP AND JAVA FUNDAMENTALS

Object Oriented Programming - Abstraction – objects and classes - Encapsulation- Inheritance -
Polymorphism- OOP in Java – Characteristics of Java – The Java Environment - Java Source File
-Structure – Compilation. Fundamental Programming Structures in Java – Defining classes in
Java – constructors, methods -access specifiers - static members -Comments, Data Types,
Variables, Operators, Control Flow, Arrays , Packages - JavaDoc comments.
UNIT II INHERITANCE AND INTERFACES

Inheritance – Super classes- sub classes –Protected members – constructors in sub classes- the
Object class – abstract classes and methods- final methods and classes – Interfaces – defining an
interface, implementing interface, differences between classes and interfaces and extending
interfaces - Object cloning -inner classes, Array Lists – Strings.
UNIT III EXCEPTION HANDLING AND I/O

Exceptions - exception hierarchy - throwing and catching exceptions – built-in exceptions,
creating own exceptions, Stack Trace Elements. Input / Output Basics – Streams – Byte streams
and Character streams – Reading and Writing Console – Reading and Writing Files.
UNIT IV MULTITHREADING AND GENERIC PROGRAMMING

Differences between multi-threading and multitasking, thread life cycle, creating threads,
synchronizing threads, Inter-thread communication, daemon threads, thread groups. Generic
Programming – Generic classes – generic methods – Bounded Types – Restrictions and
Limitations.
UNIT V EVENT DRIVEN PROGRAMMING

Graphics programming - Frame – Components - working with 2D shapes - Using color, fonts,
and images - Basics of event handling - event handlers - adapter classes - actions - mouse events
- AWT event hierarchy - Introduction to Swing – layout management - Swing Components –
Text Fields , Text Areas – Buttons- Check Boxes – Radio Buttons – Lists- choices- Scrollbars –
Windows –Menus – Dialog Boxes.
TEXT BOOKS:
1. Herbert Schildt, ―Java The complete reference‖, 8th Edition, McGraw Hill Education, 2011.
2. Cay S. Horstmann, Gary cornell, ―Core Java Volume –I Fundamentals‖, 9th Edition, Prentice
Hall, 2013.
REFERENCES:
1. Paul Deitel, Harvey Deitel, ―Java SE 8 for programmers‖, 3rd Edition, Pearson, 2015.
2. Steven Holzner, ―Java 2 Black book‖, Dreamtech press, 2011.
3. Timothy Budd, ―Understanding Object-oriented programming with Java‖, Updated Edition,
Pearson Education, 2000.
www.studymaterialz.in
CS8392- OOPS www.LearnEngineering.in
Introduction to Oop and Java Fundamentals  1.1
INTRODUCTION TO OOP AND JAVA FUNDAMENTALS
n
1.1 Object-Oriented PrOgramming
g.i
Object-oriented programming (OOP) is a programming paradigm based on the concept of
“objects”, which may contain data, in the form of fields, often known as attributes; and code,
rin
in the form of procedures, often known as methods.
List of object-oriented programming languages
ee
Ada 95 Fortran 2003 PHP since v4, greatly enhanced in v5
gin
BETA Graphtalk Python
C++ IDLscript Ruby

En
C# J# Scala
COBOL Java Simula

arn
Cobra LISP Smalltalk

Le
ColdFusion Objective-C Tcl
Common Lisp Perl since v5

w.
abstraction
ww
Abstraction is one of the key concepts of object-oriented programming (OOP) languages.

Its main goal is to handle complexity by hiding unnecessary details from the user. This en-
ables the user to implement more complex logic on top of the provided abstraction without
understanding about all the hidden complexity.
For example, people do not think of a car as a set of tens of thousands of individual parts.
They think of it as a well-defined object with its own unique behavior. This abstraction allows
people to use a car to drive to the desired location without worrying about the complexity of
the parts that form the car. They can ignore the details of how the engine, transmission, and
braking systems work. Instead, they are free to utilize the object as a whole.
www.LearnEngineering.in
A powerful way to manage abstraction is through the use of hierarchical classifications.

This allows us to layer the semantics of complex systems, breaking them into more manage-
able pieces.
• Hierarchical abstractions of complex systems can also be applied to computer
programs.
• The data from a traditional process-oriented program can be transformed by abstraction
into its component objects.
• A sequence of process steps can become a collection of messages between these
n
objects.
g.i
• Thus, each of these objects describes its own unique behavior.
• We can treat these objects as concrete entities that respond to messages telling them
rin
to do something.
Objects and classes
ee
Object
Objects have states and behaviors. Example: A dog has states - color, name, breed as well
gin
as behaviors – wagging the tail, barking, eating. An object is an instance of a class.

class
En
A class can be defined as a template/blueprint that describes the behavior/state that the
object of its type support.
Objects in java
arn
If we consider the real-world, we can find many objects around us, cars, dogs, humans,
etc. All these objects have a state and a behavior.
Le
If we consider a dog, then its state is - name, breed, color, and the behavior is - barking,
wagging the tail, running.
If we compare the software object with a real-world object, they have very similar char-
w.
acteristics.
Software objects also have a state and a behavior. A software object’s state is stored in
ww
fields and behavior is shown via methods.

So in software development, methods operate on the internal state of an object and the
object-to-object communication is done via methods.
classes in java
A class is a blueprint from which individual objects are created.
Following is an example of a class.

public class Dog {
String breed;
int age;
String color;
void barking()
n
{
g.i
}
}
rin
A class can contain any of the following variable types.
• Local variables − Variables defined inside methods, constructors or blocks are called
local variables. The variable will be declared and initialized within the method and
ee
the variable will be destroyed when the method has completed.
• Instance variables − Instance variables are variables within a class but outside
gin
any method. These variables are initialized when the class is instantiated. Instance
variables can be accessed from inside any method, constructor or blocks of that
particular class.
En
• Class variables − Class variables are variables declared within a class, outside any
method, with the static keyword.
arn
A class can have any number of methods to access the value of various kinds of methods.
In the above example, barking(), hungry() and sleeping() are methods.
encapsulation
Le
Encapsulation is the mechanism that binds together code and the data it manipulates, and
keeps both safe from outside interference and misuse.
w.
• In Java, the basis of encapsulation is the class. There are mechanisms for hiding the
complexity of the implementation inside the class.
ww
• Each method or variable in a class may be marked private or public.

• The public interface of a class represents everything that external users of the class
need to know, or may know.
• The private methods and data can only be accessed by code that is a member of the
class.
• Therefore, any other code that is not a member of the class cannot access a private
method or variable.
• Since the private members of a class may only be accessed by other parts of program
through the class’ public methods, we can ensure that no improper actions take
place.
inheritance
Inheritance is the process by which one object acquires the properties of another object.
n
g.i
rin
ee
gin
For example, a Dog is part of the classification Mammal, which in turn is part of the Ani-
mal class. Without the use of hierarchies, each object would need to define all of its charac-
En
teristics explicitly. However, by use of inheritance, an object need only define those qualities
that make it unique within its class. It can inherit its general attributes from its parent. Thus,
inheritance makes it possible for one object to be a specific instance of a more general case.
arn
Polymorphism
Polymorphism (from Greek, meaning “many forms”) is a feature that allows one interface
to be used for a general class of actions. The specific action is determined by the exact nature
Le
of the situation.
For eg, a dog’s sense of smell is polymorphic. If the dog smells a cat, it will bark and run
w.
after it. If the dog smells its food, it will salivate and run to its bowl. The same sense of smell
is at work in both situations. The difference is what is being smelled, that is, the type of data
being operated upon by the dog’s nose.
ww
Consider a stack (which is a last-in, first-out LIFO list). We might have a program that re-
quires three types of stacks. One stack is used for integer values, one for floating-point values,
and one for characters. The algorithm that implements each stack is the same, even though
the data being stored differs.
1.2 OOP cOncePts in java
OOP concepts in Java are the main ideas behind Java’s Object Oriented Programming.
They are:
Introduction to Oop and Java Fundamentals  1.5
Object
Any entity that has state and behavior is known as an object. It can be either physical or
logical.
For example: chair, pen, table, keyboard, bike etc.
class & instance
Collection of objects of the same kind is called class. It is a logical entity.
A Class is a 3-Compartment box encapsulating data and operations as shown in figure.
n
g.i
Class Name
rin
Static Attributes
ee
Dynamic Behaviors
gin
Figure: Class Structure
The followings figure shows two classes ‘Student’ and ‘Circle’.
Name (Identifier) student circle
En
Variables (Static Attributes) name, gender, dept, marks radius, color

Methods getDetails() getRadius()
arn
(Dynamic Behaviors) calculateGrade() printArea()

Figure: Examples of classes
A class can be visualized as a three-compartment box, as illustrated:
Le
Name (or identity): identifies the class.

Variables (or attribute, state, field): contain the static attributes of the class.
w.
Methods (or behaviors, function, operation): contain the dynamic behaviors of the
class.
ww
An instance is an instantiation of a class. All the instances of a class have similar proper-
ties, as described in the class definition. The term “object” usually refers to instance.
For example, we can define a class called “Student” and create three instances of the class
“Student” for “John”, “Priya” and “Anil”.
The following figure shows three instances of the class Student, identified as “John”,
“Priya” and “Anil”.
1.6  Object Oriented Programming
John : Student Priya : Student Anil : Student

name = “John” name = “Priya” name = “Anil”
gender = “male” gender = “female” gender = “male”
dept = “CSE” gender = “female” gender = “male”
mark = 88 dept = “IT” dept = “IT”
getDetails() getDetails() getDetails()
calculateGrade() calculateGrade() calculateGrade()
n
Figure: Instances of a class ‘Student’
g.i
abstraction
Abstraction refers to the quality of dealing with ideas rather than events. It basically deals
rin
with hiding the details and showing the essential things to the user.
We all know how to turn the TV on, but we don’t need to know how it works in order to
ee
enjoy it.
Abstraction means simple things like objects, classes, and variables represent more com-
gin
plex underlying code and data. It avoids repeating the same work multiple times. In java, we
use abstract class and interface to achieve abstraction.
abstract class:
En
Abstract class in Java contains the ‘abstract’ keyword. If a class is declared abstract, it
cannot be instantiated. So we cannot create an object of an abstract class. Also, an abstract
class can contain abstract as well as concrete methods.
arn
To use an abstract class, we have to inherit it from another class where we have to provide
implementations for the abstract methods there itself, else it will also become an abstract
Le
class.
interface:
w.
Interface in Java is a collection of abstract methods and static constants. In an interface,

each method is public and abstract but it does not contain any constructor. Along with ab-
straction, interface also helps to achieve multiple inheritance in Java.
ww
So an interface is a group of related methods with empty bodies.

encapsulation
Binding (or wrapping) code and data together into a single unit is known as encapsulation.
It means to hide our data in order to make it safe from any modification.
The best way to understand encapsulation is to look at the example of a medical capsule,
where the drug is always safe inside the capsule. Similarly, through encapsulation the meth-
ods and variables of a class are well hidden and safe.
A java class is the example of encapsulation.

Encapsulation can be achieved in Java by:
• Declaring the variables of a class as private.
• Providing public setter and getter methods to modify and view the variables values.
inheritance
This is a special feature of Object Oriented Programming in Java. It lets programmers
create new classes that share some of the attributes of existing classes.
n
For eg, a child inherits the properties from his father.
g.i
Similarly, in Java, there are two classes:
1. Parent class (Super or Base class)
rin
2. Child class (Subclass or Derived class)
A class which inherits the properties is known as ‘Child class’ whereas a class whose
ee
properties are inherited is known as ‘Parent class’.
Inheritance is classified into 4 types:
gin
En
arn
Le
single inheritance
It enables a derived class to inherit the properties and behavior from a single parent
w.
class.
ww
Here, Class A is a parent class and Class B is a child class which inherits the properties
and behavior of the parent class.
multilevel inheritance
When a class is derived from a class which is also derived from another class, i.e. a class
having more than one parent class but at different levels, such type of inheritance is called
Multilevel Inheritance.
n
g.i
rin
Here, class B inherits the properties and behavior of class A and class C inherits the prop-
ee
erties of class B. Class A is the parent class for B and class B is the parent class for C. So, class
C implicitly inherits the properties and methods of class A along with Class B.
gin
Hierarchical inheritance
When a class has more than one child class (sub class), then such kind of inheritance is known
as hierarchical inheritance.
En
arn
Le

w.
ww
Here, class A is a parent class for classes B and C, whereas classes B and C are the parent
classes of D which is the only child class of B and C.
Polymorphism
Polymorphism means taking many forms, where ‘poly’ means many and ‘morph’ means
forms. It is the ability of a variable, function or object to take on multiple forms. In other
words, polymorphism allows us to define one interface or method and have multiple imple-
mentations.
n
g.i
rin
For eg, Bank is a base class that provides a method rate of interest. But, rate of interest
ee
may differ according to banks. For example, SBI, ICICI and AXIS are the child classes that
provide different rates of interest.
gin
Polymorphism in Java is of two types:

• Run time polymorphism
• Compile time polymorphism
En
run time polymorphism:

In Java, runtime polymorphism refers to a process in which a call to an overridden method
arn
is resolved at runtime rather than at compile-time. Method overriding is an example of run

time polymorphism.
compile time polymorphism:
Le
In Java, compile time polymorphism refers to a process in which a call to an overloaded

method is resolved at compile time rather than at run time. Method overloading is an example
w.
of compile time polymorphism.

1.3 cHaracteristics Of java
ww
simple :
• Java is Easy to write and more readable.
• Java has a concise, cohesive set of features that makes it easy to learn and use.
• Most of the concepts are drawn from C++, thus making Java learning simpler.
secure :
• Java program cannot harm other system thus making it secure.
• Java provides a secure means of creating Internet applications.
• Java provides secure way to access web applications.
Portable :
• Java programs can execute in any environment for which there is a Java run-time
system.
n
• Java programs can run on any platform (Linux, Window, Mac)
g.i
• Java programs can be transferred over world wide web (e.g applets)
Object-oriented :
rin
• Java programming is object-oriented programming language.
• Like C++, java provides most of the object oriented features.
ee
• Java is pure OOP Language. (while C++ is semi object oriented)
gin
robust :
• Java encourages error-free programming by being strictly typed and performing run-
time checks.
En
multithreaded :
• Java provides integrated support for multithreaded programming.
arn
architecture-neutral :
• Java is not tied to a specific machine or operating system architecture.
Le
• Java is machine independent.

interpreted :
w.
• Java supports cross-platform code through the use of Java bytecode.

• Bytecode can be interpreted on any platform by JVM (Java Virtual Machine).
ww
High performance :
• Bytecodes are highly optimized.
• JVM can execute bytecodes much faster .
distributed :
• Java is designed with the distributed environment.
• Java can be transmitted over internet.
dynamic :
• Java programs carry substantial amounts of run-time type information with them that
is used to verify and resolve accesses to objects at run time.
1.4 Java RuNtIme eNvIRoNmeNt (JRe)
The Java Runtime Environment (JRE) is a set of software tools for development of Java
applications. It combines the Java Virtual Machine (JVM), platform core classes and support-
ing libraries.
n
JRE is part of the Java Development Kit (JDK), but can be downloaded separately. JRE
was originally developed by Sun Microsystems Inc., a wholly-owned subsidiary of Oracle
g.i
Corporation.
JRE consists of the following components:
rin
name of the component elements of the component
Deployment technologies Deployment
ee
Java Web Start
Java Plug-in
gin
User interface toolkits Abstract Window Toolkit (AWT)

Swing
En
Java 2D
Accessibility
arn
Image I/O
Print Service
Sound
Le
Drag and Drop (DnD)

w.
Input methods.
Integration libraries Interface Definition Language (IDL)
ww
Java Database Connectivity (JDBC)

Java Naming and Directory Interface (JNDI)
Remote Method Invocation (RMI)
Remote Method Invocation Over Internet
Inter-Orb Protocol (RMI-IIOP)
Scripting.
base libraries International support

Input/Output (I/O)
Eextension mechanism
Beans
Java Management Extensions (JMX)
Java Native Interface (JNI)
n
Math
g.i
Networking
Override Mechanism
rin
Security
Serialization and Java for XML Processing
ee
(XML JAXP).
Lang and util base libraries lang and util
gin
Management
Versioning
En
Zip
Instrument
arn
Reflection
Collections
Le
Concurrency
Java Archive (JAR)
w.
Logging
Preferences API
ww
Ref Objects
Regular Expressions.
Java Virtual Machine (JVM) Java HotSpot Client
Server Virtual Machines
1.5 Java vIRtual machINe (Jvm)

The JVM is a program that provides the runtime environment necessary for Java pro-
grams to execute. Java programs cannot run without JVM for the appropriate hardware and
OS platform.
Java programs are started by a command line, such as:
java <arguments> <program name>
This brings up the JVM as an operating system process that provides the Java runtime
n
environment. Then the program is executed in the context of an empty virtual machine.
g.i
When the JVM takes in a Java program for execution, the program is not provided as
Java language source code. Instead, the Java language source must have been converted (or
compiled) into a form known as Java bytecode. Java bytecode must be supplied to the JVM
rin
in a format called class files. These class files always have a .class extension.
The JVM is an interpreter for the bytecode form of the program. It steps through one
ee
bytecode instruction at a time. It is an abstract computing machine that enables a computer
to run a Java program.
gin
1.6 setting uP an envirOnment fOr java

Local environment setup
Download Java and run the .exe to install Java on the machine.
En
setting up the Path for Windows

Assuming Java is installed in c:\Program Files\java\jdk directory −
arn
• Right-click on ‘My Computer’ and select ‘Properties’.

• Click the ‘Environment variables’ button under the ‘Advanced’ tab.
Le
• Now, alter the ‘Path’ variable so that it also contains the path to the Java executable.
Example, if the path is currently set to ‘C:\WINDOWS\SYSTEM32’, then change
your path to read ‘C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin’.
w.
1.7 POPuLar java editOrs

ww
To write Java programs, we need any of the following:

• notepad − Text editor
• netbeans − A Java IDE that is open-source and free
• eclipse − A Java IDE developed by the eclipse open-source community
1.8 java sOurce fiLe structure

When we write a Java source program, it needs to follow a certain structure or template
as shown in the following figure:
n
g.i
rin
ee
gin
En
arn
Figure: Java Source File Structure

Packages are used in Java in order to prevent naming conflicts, to control access, to make
Le
searching/locating and usage of classes, interfaces, enumerations and annotations easier, etc.
A Java source file can have the following elements that must be specified in the following
order:
w.
An optional package declaration to specify a package name.

Zero or more import declarations.
ww
Any number of top-level type declarations. Class, enum, and interface declarations
are collectively known as type declarations.
Part 1: Optional Package Declaration
A package is a pack (group) of classes, interfaces and other packages. Packages are used
in Java in order to prevent naming conflicts, to control access, to make searching / locating
and usage of classes, interfaces, enumerations and annotations easier, etc.
Rules:
• The package statement should be the first line in the source file.
• There can be only one package statement in each source file.
• If a package statement is not used, the class, interfaces, enumerations, and annotation
types will be placed in the current default package.
• It is a good practice to use names of packages with lower case letters to avoid any
conflicts with the names of classes and interfaces.
n
Following package example contains interface named animals:
g.i
/* File name : Animal.java */
package animals;
rin
interface Animal
{
ee
public void eat();
gin
public void travel();

}
En
Part 2: Zero or More import Declarations

The import statement makes the declarations of external classes available to the current
Java source program at the time of compilation. The import statement specifies the path for
arn
the compiler to find the specified class.

syntax of the import statement:
Le
import packagename;
or
w.
import packagename.* ;
ww
We may import a single class or all the classes belonging to a package.

• To import a single class, we specify the name of the class
• To import all classes, we specify *.
Examples of the import statement:

statement in java Purpose
import mypackage.MyClass; imports the definition of the MyClass
class that is defined in the mypackage
package.
import mypackage.reports.accounts.salary. imports the definition of EmpClass
EmpClass; belonging to the mypackage.reports.
n
accounts.salary package.
g.i
import java.awt.*; imports all the classes belonging to the
java.awt package.
rin
Part 3: Zero or More top-level Declarations
The Java source file should have one and only one public class. The class name which is
defined as public should be the name of Java source file along with .java extension.
ee
Source File Declaration Rules
gin
• There can be only one public class per source file.
• A source file can have multiple non-public classes.
• The public class name should be the name of the source file which should have
En
.java extension at the end.

• For eg, if the class name is public class Employee{}, then the source file should be
arn
as Employee.java.
• If the class is defined inside a package, then the package statement should be the first
statement in the source file.
Le
• If import statements are present, then they must be written between the package
statement and the class declaration. If there are no package statements, then the
import statement should be the first line in the source file.
w.
• Import and package statements will imply to all the classes present in the source file.
It is not possible to declare different import and/or package statements to different
ww
classes in the source file.

1.9 cOmPiLatiOn
In Java, programs are not compiled into executable files. Java source code is compiled
into bytecode using javac compiler. The bytecodes are platform-independent instructions for
the Java VM. They are saved on the disk with the file extension .class. When the program
is to be run, the bytecode is converted into the machine code using the just-in-time (JIT) com-
piler. It is then fed to the memory and executed.
Java code needs to be compiled twice in order to be executed:

1. Java programs need to be compiled to bytecode.
2. When the bytecode is run, it needs to be converted to machine code.
The Java classes / bytecode are compiled to machine code and loaded into memory by the
JVM when needed for the first time.
compiling the Program
The Java compiler is invoked at the command line with the following syntax:
n
g.i
javac ExampleProgram.java
interpreting and running the Program
rin
Once the java program successfully compiles into Java bytecodes, we can interpret and
run applications on any Java VM, or interpret and run applets in any Web browser with a Java
VM built in such as Netscape or Internet Explorer. Interpreting and running a Java program
ee
means invoking the Java VM byte code interpreter, which converts the Java byte codes to
platform-dependent machine codes so your computer can understand and run the program.
gin
The Java interpreter is invoked at the command line with the following syntax:
java ExampleProgram
En
Quick compilation procedure

To execute the first Java program, follow the steps:
arn
Open text editor. For example, Notepad or Notepad++ on Windows; Gedit, Kate or
SciTE on Linux; or, XCode on Mac OS, etc.
Type the java program in a new text document.
Le
Save the file as HelloWorld.java.

Next, open any command-line application. For example, Command Prompt on
w.
Windows; and, Terminal on Linux and Mac OS.

Compile the Java source file using the command: javac HelloWorld.java
ww
Once the compiler returns to the prompt, run the application using the following
command:
java HelloWorld
1.10 fundamentaL PrOgramming structures in java

java comments
The java comments are statements that are not executed by the compiler and interpreter.
The comments can be used to provide information or explanation about the variable, method,
class or any statement. It can also be used to hide program code for specific time.
Types of Java Comments
There are 3 types of comments in java.
n
Single Line Comment
g.i
Multi Line Comment
Documentation Comment
rin
1) Java Single line comment
The single line comment is used to comment only one line. A single-line comment begins
ee
with a // and ends at the end of the line.
syntax example
gin
//Comment //This is single line comment

2) Java multi line comment
En
This type of comment must begin with /* and end with */. Anything between these two
comment symbols is ignored by the compiler. A multiline comment may be several lines
long.
arn
syntax example
/*Comment starts /* This is a
Le
continues multi line
continues comment */
w.
.
ww
Commnent ends*/
3) Java Documentation comment
This type of comment is used to produce an HTML file that documents our program. The
documentation comment begins with a /** and ends with a */.
syntax example
/**Comment start
*tags are used in order to specify a parameter
*or method or heading
n
*HTML tags can also be used
g.i
*such as <h1>
rin
*
*comment ends*/
ee

gin
En
arn
Le
w.
ww
Figure: Data types in java
the Primitive types

Java defines eight primitive types of data: byte, short, int, long, char, float, double, and
boolean. The primitive types are also commonly referred to as simple types and they are
grouped into the following four groups:
i) Integers - This group includes byte, short, int, and long. All of these are signed,
positive and negative values. The width and ranges of these integer types vary widely,
as shown in the following table:
name Width in bits range
n
long 64 –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
g.i
int 32 –2,147,483,648 to 2,147,483,647
short 16 –32,768 to 32,767
rin
byte 8 –128 to 127
table: integer data types
ee
Floating-point numbers – They are also known as real numbers. This group includes
float and double, which represent single- and double-precision numbers, respectively.
gin
The width and ranges of them are shown in the following table:
Table: Floating-point Data Types
name Width in bits range

En
double 64 4.9e–324 to 1.8e+308

float 32 1.4e–045 to 3.4e+038
arn
iii) Characters - This group includes char, which represents symbols in a character set,
like letters and numbers. char is a 16-bit type. The range of a char is 0 to 65,536.
There are no negative chars.
Le
iv) Boolean - This group includes boolean. It can have only one of two possible values,
true or false.
w.
1.12 variabLes
A variable is the holder that can hold the value while the java program is executed. A
ww
variable is assigned with a datatype. It is name of reserved area allocated in memory. In

other words, it is a name of memory location. There are three types of variables in java: local,
instance and static.
A variable provides us with named storage that our programs can manipulate. Each vari-
able in Java has a specific type, which determines the size and layout of the variable’s mem-
ory; the range of values that can be stored within that memory; and the set of operations that
can be applied to the variable.
Before using any variable, it must be declared. The following statement expresses the
basic form of a variable declaration –
datatype variable [ = value][, variable [ = value] ...] ;
Here data type is one of Java’s data types and variable is the name of the variable. To de-
clare more than one variable of the specified type, use a comma-separated list.
Example
int a, b, c; // Declaration of variables a, b, and c.
n
int a = 20, b = 30; // initialization
g.i
byte B = 22; // Declaratrion initializes a byte type variable B.
Types of Variable
rin
There are three types of variables in java:
• local variable
ee
• instance variable
• static variable
gin
En
arn
Le
Fig. Types of variables

w.
Local variable
• Local variables are declared inside the methods, constructors, or blocks.
ww
• Local variables are created when the method, constructor or block is entered
• Local variable will be destroyed once it exits the method, constructor, or block.
• Local variables are visible only within the declared method, constructor, or block.
• Local variables are implemented at stack level internally.
• There is no default value for local variables, so local variables should be declared and
an initial value should be assigned before the first use.
• Access specifiers cannot be used for local variables.
instance variable
• A variable declared inside the class but outside the method, is called instance variable.
Instance variables are declared in a class, but outside a method, constructor or any
block.
• A slot for each instance variable value is created when a space is allocated for an
object in the heap.
• Instance variables are created when an object is created with the use of the keyword
n
‘new’ and destroyed when the object is destroyed.
g.i
• Instance variables hold values that must be referenced by more than one method,
constructor or block, or essential parts of an object’s state that must be present
rin
throughout the class.
• Instance variables can be declared in class level before or after use.
ee
• Access modifiers can be given for instance variables.
• The instance variables are visible for all methods, constructors and block in the
gin
class. It is recommended to make these variables as private. However, visibility for
subclasses can be given for these variables with the use of access modifiers.
• Instance variables have default values.
En
○ numbers, the default value is 0,

○ Booleans it is false,
arn
○ Object references it is null.

• Values can be assigned during the declaration or within the constructor.
Le
• Instance variables cannot be declared as static.

• Instance variables can be accessed directly by calling the variable name inside the class.
However, within static methods (when instance variables are given accessibility), they
w.
should be called using the fully qualified name. ObjectReference.VariableName.

static variable
ww
• Class variables also known as static variables are declared with the static keyword in
a class, but outside a method, constructor or a block.
• Only one copy of each class variable per class is created, regardless of how many
objects are created from it.
• Static variables are rarely used other than being declared as constants. Constants are
variables that are declared as public/private, final, and static. Constant variables never
change from their initial value.
• Static variables are stored in the static memory. It is rare to use static variables other
than declared final and used as either public or private constants.
• Static variables are created when the program starts and destroyed when the program
stops.
• Visibility is same as instance variables. However, most static variables are declared
public since they must be available for users of the class.
• Default values are same as instance variables.
n
○ numbers, the default value is 0;
g.i
○ Booleans, it is false;
○ Object references, it is null.
rin
• Values can be assigned during the declaration or within the constructor. Additionally,
values can be assigned in special static initializer blocks.
• Static variables cannot be local.
ee
• Static variables can be accessed by calling with the class name ClassName.
gin
VariableName.
• When declaring class variables as public static final, then variable names (constants)
are all in upper case. If the static variables are not public and final, the naming syntax
En
is the same as instance and local variables.

1.13 OPeratOrs
arn
Operator in java is a symbol that is used to perform operations. Java provides a rich set
of operators to manipulate variables.For example: +, -, *, / etc.
All the Java operators can be divided into the following groups −
Le
• Arithmetic Operators :
Multiplicative : * / %
w.
Additive : + -
• Relational Operators
ww
Comparison : < > <= >= instanceof

Equality : == !=
• Bitwise Operators
bitwise AND : &
bitwise exclusive OR : ^
bitwise inclusive OR : |
Shift operator: << >> >>>
• Logical Operators
logical AND : &&
logical OR : ||
logical NOT : ~ !
• Assignment Operators: =
• Ternary operator: ? :
n
• Unary operator
g.i
Postfix : expr++ expr—
Prefix : ++expr --expr +expr -expr
rin
the arithmetic Operators
Arithmetic operators are used to perform arithmetic operations in the same way as they
are used in algebra. The following table lists the arithmetic operators −
ee
Example:
gin
int A=10,B=20;
Operator description example Output

En
+ (Addition) Adds values A & B. A+B 30

- (Subtraction) Subtracts B from A A-B -10
arn
* (Multiplication) Multiplies values A & B A*B 200

/ (Division) Divides B by A B/A 2
Divides left-hand operand by right-
Le
% (Modulus) B%A 0
hand operand and returns remainder.
// Java program to illustrate arithmetic operators

w.
public class Aoperators

ww
{
public static void main(String[] args)
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
String x = “Thank”, y = “You”;
System.out.println(“a + b = “+(a + b));
System.out.println(“a - b = “+(a - b));
System.out.println(“x + y = “+x + y);

System.out.println(“a * b = “+(a * b));
System.out.println(“a / b = “+(a / b));
System.out.println(“a % b = “+(a % b));
}
}
n
the relational Operators
g.i
The following relational operators are supported by Java language.
Example:
rin
int A=10,B=20;

ee
Checks if the values of two operands
== (equal to) are equal or not, if yes then condition (A == B) true
gin
becomes true.
Checks if the values of two operands
!= (not equal to) are equal or not, if values are not equal (A != B) true
En
then condition becomes true.

Checks if the value of left operand is
> (greater than) greater than the value of right operand, (A > B) true
arn
if yes then condition becomes true.

< (less than) less than the value of right operand, if (A < B) true
Le
yes then condition becomes true.

w.
>= (greater than or greater than or equal to the value of

(A >= B) true
equal to) right operand, if yes then condition be-
comes true.
ww

<= (less than or less than or equal to the value of right
(A <= B) true
equal to) operand, if yes then condition becomes
true.
checks whether the object is of a partic- boolean re-
ular type (class type or interface type) sult = name
instance of Operator True
(Object reference variable ) instanceof instanceof
(class/interface type) String;
// Java program to illustrate relational operators

public class operators
{
{
int a = 20, b = 10;
n
boolean condition = true;
g.i
//various conditional operators
System.out.println(“a == b :” + (a == b));
rin
System.out.println(“a < b :” + (a < b));
System.out.println(“a <= b :” + (a <= b));
ee
System.out.println(“a > b :” + (a > b));
System.out.println(“a >= b :” + (a >= b));
gin
System.out.println(“a != b :” + (a != b));
System.out.println(“condition==true :” + (condition == true));
En
}
}
arn
bitwise Operators
Java supports several bitwise operators, that can be applied to the integer types, long, int,
short, char, and byte. Bitwise operator works on bits and performs bit-by-bit operation.
Le
Example:
int a = 60,b = 13;
w.
binary format of a & b will be as follows −

a = 0011 1100
ww
b = 0000 1101
Bitwise operators follow the truth table:
a b a&b a|b a^b ~a

0 0 0 0 1 1
0 1 0 1 0 1
1 0 0 1 0 0
1 1 1 1 1 0
a&b = 0000 1100
n
a|b = 0011 1101
g.i
a^b = 0011 0001
~a = 1100 0011
rin
The following table lists the bitwise operators −
int A=60,B=13;
ee
& (bit- Binary AND Operator copies a (A & B) will give 12 12
gin
wise and) bit to the result if it exists in both which is (in binary
operands. form:0000
1100)
En
| (bitwise Binary OR Operator copies a bit (A | B) 61

or) if it exists in either operand. (in binary form:
arn
0011 1101)
^ (bitwise Binary XOR Operator copies the (A ^ B) will give 49 49
XOR) bit if it is set in one operand but which is 0011 0001 (in binary form:
Le
not both. 0011 0001)

~ (bitwise Binary Ones Complement Opera- (~A) will give -61 -61
w.
compli- tor is unary and has the effect of which is 1100 0011 (in binary form:
ment) ‘flipping’ bits. in 2’s complement 1100 0011)
form due to a signed
ww
binary number.
<< (left The left operands value is moved A << 2 will give 240 240
shift) left by the number of bits speci- which is 1111 0000 (in binary form:
fied by the right operand. 1111 0000)
>> (right The left operands value is moved A >> 2 will give 15 15
shift) right by the number of bits speci- which is 1111 (in binary form:
fied by the right operand. 1111)
>>> (zero The left operands value is moved A >>>2 will give 15 15
fill right right by the number of bits speci- which is 0000 1111 (in binary form:
shift) fied by the right operand and 0000 1111)
shifted values are filled up with
zeros.
n
// Java program to illustrate bitwise operators
g.i
{
rin
{
ee
int a = 10;
gin
int b = 20;
System.out.println(“a&b = “ + (a & b));
System.out.println(“a|b = “ + (a | b));
En
System.out.println(“a^b = “ + (a ^ b));
System.out.println(“~a = “ + ~a);
arn
}
}
Le
Logical Operators
The following are the logical operators supported by java.
w.
Example:
A=true;
ww
B=false;
Operator description example Ouptput

&& (logical If both the operands are non-zero,
(A && B) false
and) then the condition becomes true.
|| (logical or) If any of the two operands are non-
zero, then the condition becomes (A || B) true
true.
! (logical not) Use to reverses the logical state of its
n
operand. If a condition is true then
!(A && B) true
Logical NOT operator will make
g.i
false.
assignment Operators
rin
The following are the assignment operators supported by Java.
ee
Operator description example
=
C = A + B will as-
gin
(Simple Assigns values from right side oper- sign value of

assignment ands to left side operand.
A + B into C
operator)
En
+=
(Add AND It adds right operand to the left operand C += A is equiva-
and assigns the result to left operand. lent to C = C + A
arn
assignment
operator)
-=
Le
(Subtract It subtracts right operand from the left

C -= A is equiva-
AND operand and assigns the result to left
lent to C = C – A
assignment operand.
w.
operator)
*=
ww
(Multiply It multiplies right operand with the left

C *= A is equiva-
lent to C = C * A
assignment operand.
operator)
/=
(Divide It divides left operand with the right
C /= A is equiva-
lent to C = C / A
assignment operand.
operator)
%=
(Modulus It takes modulus using two operands C %= A is equiva-
n
AND assign- and assigns the result to left operand. lent to C = C % A
ment opera-
g.i
tor)
C <<= 2 is same as
rin
<<= Left shift AND assignment operator.
C = C << 2
C >>= 2 is same as
>>= Right shift AND assignment operator.
ee C = C >> 2
gin
C &= 2 is same as
&= Bitwise AND assignment operator.
C=C&2
En
bitwise exclusive OR and assignment C ^= 2 is same as

^=
operator. C=C^2
arn
bitwise inclusive OR and assignment C |= 2 is same as C

|=
operator. =C|2
Le
// Java program to illustrate assignment operators

w.

{
ww

{
int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
c = b;
System.out.println(“Value of c = “ + c);
a += 1;
b -= 1;
e *= 2;
f /= 2;
System.out.println(“a, b, e, f = “ +
a + “,” + b + “,” + e + “,” + f);
}
n
}
g.i
ternary Operator
Conditional Operator ( ? : )
rin
Since the conditional operator has three operands, it is referred as the ternary operator.
This operator consists of three operands and is used to evaluate Boolean expressions. The
goal of the operator is to decide, which value should be assigned to the variable. The operator
ee
is written as –
variable x = (expression) ? value if true : value if false
gin
Following is an example −
Example:
En
public class example

{
arn
public static void main(String args[])

{
int a, b;
Le
a = 10;
b = (a == 0) ? 20: 30;
w.
System.out.println( “b : “ + b );
ww
}
}
unary Operators
Unary operators use only one operand. They are used to increment, decrement or negate
a value.
Operator description
- Unary minus negating the values
+ Unary plus converting a negative value to positive
++ :Increment operator incrementing the value by 1
— : Decrement operator decrementing the value by 1
! : Logical not operator inverting a boolean value
// Java program to illustrate unary operators
n
g.i
{
rin
{ ee
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
boolean condition = true;
gin
c = ++a;
System.out.println(“Value of c (++a) = “ + c);
En
c = b++;
System.out.println(“Value of c (b++) = “ + c);
arn
c = --d;
System.out.println(“Value of c (--d) = “ + c);
c = --e;
Le
System.out.println(“Value of c (--e) = “ + c);

System.out.println(“Value of !condition =” + !condition);
w.
}
}
ww
Precedence of java Operators

Operator precedence determines the grouping of operands in an expression. This affects
how an expression is evaluated. Certain operators have higher precedence than others; for
example, the multiplication operator has higher precedence than the addition operator −
For example, the following expression,

x = 10 + 5 * 2;
is evaluated. So, the output is 20, not 30. Because operator * has higher precedence
than +.
The following table shows the operators with the highest precedence at the top of the table
and those with the lowest at the bottom. Within an expression, higher precedence operators
will be evaluated first.
n
category Operator associativity
g.i
Postfix >() [] . (dot operator) Left to right
Unary >++ - - ! ~ Right to left
rin
Multiplicative >* / Left to right
Additive >+ - Left to right
ee
Shift >>> >>> << Left to right
Relational >> >= < <= Left to right
gin
Equality >== != Left to right

Bitwise AND >& Left to right
En
Bitwise XOR >^ Left to right

Bitwise OR >| Left to right
arn
Logical AND >&& Left to right

Logical OR >|| Left to right
Le
Conditional ?: Right to left

Assignment >= += -= *= /= %= >>= Right to left
<<= &= ^= |=
w.
1.14 cOntrOL fLOW

ww
Java Control statements control the flow of execution in a java program, based on data val-
ues and conditional logic used. There are three main categories of control flow statements;
Selection statements: if, if-else and switch.
Loop statements: while, do-while and for.
Transfer statements: break, continue, return, try-catch-finally and assert.
selection statements
The selection statements checks the condition only once for the program execution.
if statement:
The if statement executes a block of code only if the specified expression is true. If the
value is false, then the if block is skipped and execution continues with the rest of the pro-
gram.
The simple if statement has the following syntax:
if (<conditional expression>)
<statement action>
n
The following program explains the if statement.
g.i
public class programIF{
rin
{
int a = 10, b = 20;
ee
if (a > b)
System.out.println(“a > b”);
gin
if (a < b)
System.out.println(“b < a”);
En
}
}
arn
the if-else statement

The if/else statement is an extension of the if statement. If the condition in the if statement
fails, the statements in the else block are executed. The if-else statement has the following
Le
syntax:
if (<conditional expression>)
w.
<statement action>
else
ww
<statement action>
The following program explains the if-else statement.
public class ProgramIfElse
{
{
int a = 10, b = 20;

if (a > b)
{
System.out.println(“a > b”);
}
else
n
{
g.i
System.out.println(“b < a”);
}
rin
}
} ee
switch case statement
The switch case statement is also called as multi-way branching statement with several
gin
choices. A switch statement is easier to implement than a series of if/else statements. The
switch statement begins with a keyword, followed by an expression that equates to a no long
integral value.
En
After the controlling expression, there is a code block that contains zero or more labeled
cases. Each label must equate to an integer constant and each must be unique. When the
switch statement executes, it compares the value of the controlling expression to the values
arn
of each case label.

The program will select the value of the case label that equals the value of the control-
ling expression and branch down that path to the end of the code block. If none of the case
Le
label values match, then none of the codes within the switch statement code block will be
executed.
w.
Java includes a default label to use in cases where there are no matches. A nested switch
within a case block of an outer switch is also allowed. When executing a switch statement,
the flow of the program falls through to the next case. So, after every case, you must insert a
ww
break statement.
The syntax of switch case is given as follows:

switch (<non-long integral expression>) {
case label1: <statement1>
case label2: <statement2>
…
case labeln: <statementn>
n
default: <statement>
g.i
} // end switch
The following program explains the switch statement.
rin
public class ProgramSwitch
{ ee
{
gin
int a = 10, b = 20, c = 30;

int status = -1;
En
if (a > b && a > c)

{
arn
status = 1;
}
else if (b > c)
Le
{
status = 2;
w.
}
else
ww
{
status = 3;
}
switch (status)
{
case 1:System.out.println(“a is the greatest”);
break;
case 2:System.out.println(“b is the greatest”);
break;
case 3:System.out.println(“c is the greatest”);
break;
default:System.out.println(“Cannot be determined”);
}
n
}
g.i
}
iteration statements
rin
Iteration statements execute a block of code for several numbers of times until the condi-
tion is true.
ee
While statement
The while statement is one of the looping constructs control statement that executes a
gin
block of code while a condition is true. The loop will stop the execution if the testing expres-
sion evaluates to false. The loop condition must be a boolean expression. The syntax of the
while loop is
En
while (<loop condition>)

<statements>
arn
The following program explains the while statement.

public class ProgramWhile
Le
{
w.
{
int count = 1;
ww
System.out.println(“Printing Numbers from 1 to 10”);

while (count <= 10)
{
System.out.println(count++);}
}
}
}
do-while Loop statement

The do-while loop is similar to the while loop, except that the test condition is performed
at the end of the loop instead of at the beginning. The do—while loop executes atleast once
without checking the condition.
It begins with the keyword do, followed by the statements that making up the body of the
loop. Finally, the keyword while and the test expression completes the do-while loop. When
the loop condition becomes false, the loop is terminated and execution continues with the
statement immediately following the loop.
n
The syntax of the do-while loop is
g.i
do
<loop body>
rin
while (<loop condition>);
The following program explains the do--while statement.
ee
public class DoWhileLoopDemo {
public static void main(String[] args) {
gin
int count = 1;
En
do {
System.out.println(count++);
arn
} while (count <= 10);

}
Le
}
for Loop
w.
The for loop is a looping construct which can execute a set of instructions for a specified
number of times. It’s a counter controlled loop.
ww
The syntax of the loop is as follows:

for (<initialization>; <loop condition>; <increment expression>)
<loop body>
• initialization statement executes once before the loop begins. The <initialization>
section can also be a comma-separated list of expression statements.
• test expression. As long as the expression is true, the loop will continue. If this
expression is evaluated as false the first time, the loop will never be executed.
• Increment(Update) expression that automatically executes after each repetition of the

loop body.
• All the sections in the for-header are optional. Any one of them can be left empty, but
the two semicolons are mandatory.
The following program explains the for statement.
public class ProgramFor {
n
g.i
for (int count = 1; count <= 10; count++) {
System.out.println(count);
rin
}
}
ee
}
transfer statements
gin
Transfer statements are used to transfer the flow of execution from one statement to an-
other.
En
continue statement
A continue statement stops the current iteration of a loop (while, do or for) and causes
execution to resume at the top of the nearest enclosing loop. The continue statement can be
arn
used when you do not want to execute the remaining statements in the loop, but you do not
want to exit the loop itself.
The syntax of the continue statement is
Le
continue; // the unlabeled form

continue <label>; // the labeled form
w.
It is possible to use a loop with a label and then use the label in the continue statement.
The label name is optional, and is usually only used when you wish to return to the outermost
ww
loop in a series of nested loops.

The following program explains the continue statement.
public class ProgramContinue
{
System.out.println(“Odd Numbers”);
for (int i = 1; i <= 10; ++i) {

if (i % 2 == 0)
continue;
System.out.println(i + “\t”);
}
}
n
}
g.i
break statement
The break statement terminates the enclosing loop (for, while, do or switch statement).
Break statement can be used when we want to jump immediately to the statement following
rin
the enclosing control structure. As continue statement, can also provide a loop with a label,
and then use the label in break statement. The label name is optional, and is usually only used
when you wish to terminate the outermost loop in a series of nested loops.
ee
The Syntax for break statement is as shown below;
gin
break; // the unlabeled form

break <label>; // the labeled form
The following program explains the break statement.
En
public class ProgramBreak {

arn
System.out.println(“Numbers 1 - 10”);
for (int i = 1;; ++i) {
Le
if (i == 11)
break;
w.
// Rest of loop body skipped when i is even

System.out.println(i + “\t”);
ww
}
}
}
The transferred statements such as try-catch-finally, throw will be explained in the later
chapters.
1.15 defining cLasses in java

A class is an entity that determines how an object will behave and what the object will
contain. A class is the basic building block of an object-oriented language such as Java. It
is acting as a template that describes the data and behavior associated with instances of that
class.
When you instantiate a class means creating an object. The class contains set of variables
and methods.
The data associated with a class or object is stored in variables; the behavior associated
n
with a class or object is implemented with methods. A class is a blueprint from which indi-
g.i
vidual objects are created.
class MyClass {
rin
// field,
//constructor, and
ee
// method declarations
}
gin
Example:
class Myclass{
En

{
arn
System.out.println(“Hello World!”); //Display the string.

}
}
Le
The keyword class begins the class definition for a class named name. The variables and
methods of the class are embraced by the curly brackets that begin and end the class definition
w.
block. The “Hello World” application has no variables and has a single method named main.
In Java, the simplest form of a class definition is
ww
class name {
...
}
in general, class declarations can include these components, in order:
1. Modifiers : A class can be public or has default access.
2. Class name: The name should begin with a initial letter.
Superclass(if any): The name of the class’s parent (superclass), if any, preceded by
the keyword extends. A class can only extend (subclass) one parent.
Interfaces(if any): A comma-separated list of interfaces implemented by the class,
if any, preceded by the keyword implements. A class can implement more than one
interface.
5. Body: The class body surrounded by braces, { }.
1.16 cOnstructOrs
n
Every class has a constructor. If the constructor is not defined in the class, the Java com-
piler builds a default constructor for that class. While a new object is created, at least one
g.i
constructor will be invoked. The main rule of constructors is that they should have the same
name as the class. A class can have more than one constructor.
rin
Constructors are used for initializing new objects. Fields are variables that provide the
state of the class and its objects, and methods are used to implement the behavior of the class
and its objects.
ee
Rules for writing Constructor
gin
• Constructor(s) of a class must have same name as the class name in which it resides.
• A constructor in Java cannot be abstract, final, static and synchronized.
• Access modifiers can be used in constructor declaration to control its access i.e which
En
other class can call the constructor.

Following is an example of a constructor −
arn
Example
public class myclass {
Le
public myclass() { // Constructor

}
w.
public myclass(String name) {

// This constructor has one parameter, name.
ww
}
}
types of constructors
There are two type of constructor in Java:
1. no-argument constructor:
A constructor that has no parameter is known as default constructor.
If the constructor is not defined in a class, then compiler creates default con-
structor (with no arguments) for the class. If we write a constructor with ar-
guments or no-argument then compiler does not create default constructor.
Default constructor provides the default values to the object like 0, null etc. depending on the
type.
// Java Program to illustrate calling a no-argument constructor
import java.io.*;
class myclass
n
{
g.i
int num;
String name;
rin
// this would be invoked while object of that class created.
myclass()
ee
{
gin
System.out.println(“Constructor called”);
}
}
En
class myclassmain
{
arn
public static void main (String[] args)

{
Le
// this would invoke default constructor.

myclass m1 = new myclass();
w.
// Default constructor provides the default values to the object like 0, null
System.out.println(m1.num);
ww
System.out.println(m1.name);
}
}
2. Parameterized constructor
A constructor that has parameters is known as parameterized constructor. If we want to
initialize fields of the class with your own values, then use parameterized constructor.
// Java Program to illustrate calling of parameterized constructor.

import java.io.*;
class myclass
{
// data members of the class.
String name;
n
int num;
g.i
// contructor with arguments.
myclass(String name, int n)
rin
{
this.name = name; ee
this.num = n;
}
gin
}
class myclassmain{
En

{
arn
// this would invoke parameterized constructor.

myclass m1 = new myclass(“Java”, 2017);
System.out.println(“Name :” + m1.name + “ num :” + m1.num);
Le
}
}
w.
There are no “return value” statements in constructor, but constructor returns current class
instance. We can write ‘return’ inside a constructor.
ww
1.17 cOnstructOr OverLOading

Like methods, we can overload constructors for creating objects in different ways.
Compiler differentiates constructors on the basis of numbers of parameters, types of the
parameters and order of the parameters.
// Java Program to illustrate constructor overloading

import java.io.*;
class myclass
{
// constructor with one argument
myclass (String name)
n
{
g.i
System.out.println(“Constructor with one “ + “argument - String : “ + name);
}
rin
// constructor with two arguments
myclass (String name, int id) ee
{
System.out.print(“Constructor with two arguments : “ +” String and Integer : “ + name
gin
+ “ “+ id);
}
// Constructor with one argument but with different type than previous.
En
myclass (long num)

{
arn
System.out.println(“Constructor with one argument : “ +”Long : “ + num);

}
Le
}
class myclassmain
w.
{
ww
{
myclass m1 = new myclass (“JAVA”);
myclass m2 = new myclass (“Python”, 2017);
myclass m3 = new myclass(3261567);
}
}
Constructors are different from methods in Java

• Constructor(s) must have the same name as the class within which it defined while it

• void if
does not return any value.
• Constructor is called only once at the time of Object creation while method(s) can be
called any numbers of time.
n
creating an Object
g.i
The class provides the blueprints for objects. The objects are the instances of the class. In
Java, the new keyword is used to create new objects.
rin
There are three steps when creating an object from a class −
• Declaration − A variable declaration with a variable name with an object type.
ee
• Instantiation − The ‘new’ keyword is used to create the object.
• Initialization − The ‘new’ keyword is followed by a call to a constructor. This call
gin
initializes the new object.

1.18 metHOds in java
A method is a collection of statement that performs specific task. In Java, each method is
En
a part of a class and they define the behavior of that class. In Java, method is a jargon used
for method.
arn
advantages of methods
• Program development and debugging are easier
• Increases code sharing and code reusability
Le
• Increases program readability

• It makes program modular and easy to understanding
w.
• It shortens the program length by reducing code redundancy

ww
types of methods
There are two types of methods in Java programming:
• Standard library methods (built-in methods or predefined methods)
• User defined methods
standard library methods
The standard library methods are built-in methods in Java programming to handle tasks
such as mathematical computations, I/O processing, graphics, string handling etc. These
methods are already defined and come along with Java class libraries, organized in packages.
In order to use built-in methods, we must import the corresponding packages. Some of library
methods are listed below.
Packages Library methods descriptions
java.lang.Math acos() Computes arc cosine of the argument
All maths related methods exp() Computes the e raised to given power
are defined in this class
abs() Computes absolute value of argument
n
log() Computes natural logarithm
g.i
sqrt() Computes square root of the argument
pow() Computes the number raised to given
rin
power
java.lang.String charAt() ee
All string related methods concat()
are defined in this class
compareTo()
gin
indexOf()
En
toUpperCase()
java.awt add() inserts a component

arn
contains classes for setSize() set the size of the component

graphics
setLayout() defines the layout manager
Le
setVisible() changes the visibility of the component
Example:
w.
Program to compute square root of a given number using built-in method.

ww
public class MathEx {

System.out.print(“Square root of 14 is: “ + Math.sqrt(14));
}
}
Sample Output:
Square root of 14 is: 3.7416573867739413
user-defined methods
The methods created by user are called user defined methods.
Every method has the following.
• Method declaration (also called as method signature or method prototype)
• Method definition (body of the method)
• Method call (invoke/activate the method)
n
method declaration
g.i
The syntax of method declaration is:
Syntax:
rin
return_type method_name(parameter_list);
Here, the return_type specifies the data type of the value returned by method. It will be
void if the method returns nothing. method_name indicates the unique name assigned to the
ee
method. parameter_list specifies the list of values accepted by the method.
method Definition
gin
Method definition provides the actual body of the method. The instructions to complete a
specific task are written in method definition. The syntax of method is as follows:
En
Syntax:
modifier return_type method_name(parameter_list){
arn
// body of the method

}
Here,
Le
Modifier – Defines the access type of the method i.e accessibility re-
gion of method in the application
w.
return_type – Data type of the value returned by the method or void if

method returns nothing
ww
method_name – Unique name to identify the method. The name must follow
the rules of identifier
parameter_list – List of input parameters separated by comma. It must be
like
datatype parameter1,datatype parameter2,……
List will be empty () in case of no input parameters.
method body – block of code enclosed within { and } braces to perform
specific task
The first line of the method definition must match exactly with the method prototype. A
method cannot be defined inside another method.
method call
A method gets executed only when it is called. The syntax for method call is.
syntax:
method_name(parameters);
When a method is called, the program control transfers to the method definition where
n
the actual code gets executed and returns back to the calling point. The number and type of
g.i
parameters passed in method call should match exactly with the parameter list mentioned in
method prototype.
rin
Example:
method name
class Addition{
modifier
ee
public int add(int a,int b){
return type body of the method
return(a+b);
gin
}
Parameter list
}
class Main{
En
method call
method return
public static void main(String args[]){
int sum=0,a=1,b=12;
arn
Addition obj=new Addition();

sum=obj.add(a,b);
System.out.println(“Sum:”+sum);
Le
}
}
w.
Sample Output:
Sum:13
ww
memory allocation for methods calls

Method calls are implemented using stack. When a method is called, the parameters
passed in the call, local variables defined inside method, and return value of the method
are stored in stack frame. The allocated stack frame gets deleted automatically at the end of
method execution.
types of user-defined methods

The methods in C are classified based on data flow between calling method and called
method. They are:
• Method with no arguments and no return value
• Method with no arguments and a return value
• Method with arguments and no return value
• Method with arguments and a return value.
n
method with no arguments and no return value
g.i
In this type of method, no value is passed in between calling method and called method.
Here, when the method is called program control transfers to the called method, executes the
rin
method, and return back to the calling method.
Example: ee
Program to compute addition of two numbers (no argument and no return value)
public class Main{
gin
public void add(){ // method definition with no arguments and no return value
int a=10,b=20;
En
System.out.println(“Sum:”+(a+b));
}
arn

Main obj=new Main();
obj.add(); // method call with no arguments
Le
}
}
w.
Sample Output:
ww
Sum:30
method with no arguments and a return value
In this type of method, no value is passed from calling method to called method but a
value is returned from called method to calling method.
Example:
Program to compute addition of two numbers (no argument and with return value)
public class Main {

public int add(){ // method definition with no arguments and with return value
int a=10,b=20;
return(a+b);
}
int sum=0;
n
g.i
/* method call with no arguments. The value returned
sum=obj.add(); from the method is assigned to variable sum */
rin
}
ee
}
Sample Output:
gin
Sum:30
method with arguments and no return value
En
In this type of method, parameters are passed from calling method to called method but
no value is returned from called method to calling method.
Example:
arn
Program to compute addition of two numbers (with argument and without return value)
public class Main {
Le
public void add(int x,int y){ // method definition with arguments and no return value
System.out.println(“Sum:”+(x+y));
w.
}
ww
int a=10,b=20;
obj.add(a,b); // method call with arguments
}
}
Sample Output:
Sum:30
method with arguments and a return value.

In this type of method, there is data transfer in between calling method and called method.
Here, when the method is called program control transfers to the called method with argu-
ments, executes the method, and return the value back to the calling method.
Example:
Program to compute addition of two numbers (with argument and return value)
public class Main {
n
public int add(int x,int y){ // function definition with arguments and return value
g.i
return(x+y); //return value
}
rin
int a=10,b=20;
ee
/* method call with arguments. The value returned from
the method is displayed within main() */
gin
System.out.println(“Sum:”+obj.add(a,b));
}
En
}
Sample Output:
arn
Sum:30
1.19 Parameter Passing in java
The commonly available parameter passing methods are:
Le
• Pass by value
• Pass by reference
w.
Pass by value
ww
In pass by value, the value passed to the method is copied into the local parameter
and any change made inside the method only affects the local copy has no effect on the
original copy. In Java, parameters are always passed by value. All the scalar variables (of
type int, long, short, float, double, byte, char, Boolean) are always passed to the methods by
value. Only the non-scalar variables like Object, Array, String are passed by reference.
Note:
Scalar variables are singular data with one value; Non scalar variables are data with mul-
tiple values.
Example:
Pass by value
class Swapper{
int a;
int b;
Swapper(int x, int y) // constructor to initialize variables
n
{
g.i
a = x;
b = y;
rin
}
void swap(int x, int y) // method to interchange values
ee
{
int temp;
/* only the local copy x, y gets swapped. The original object
gin
temp = x; value a, b remains unchanged*/

x=y;
En
y=temp;
}
arn
}
class Main{
public static void main(String[] args){
Le
Swapper obj = new Swapper(10, 20); // create object

System.out.println(“Before swapping: a=”+obj.a+” b=”+obj.b);
w.
obj.swap(obj.a,obj.b); // call the method by passing class object as parameter

ww

}
}
Sample Output:
Before swapping: a=10 b=20
After swapping: a=10 b=20
Here, to call method swap() first create an object for class Swapper. Then the method is
called by passing object values a and b as input parameters. As these values are scalar, the
parameters are passed using pass by value technique. So the changes carried out inside the
method are not reflected in original value of a and b.
Pass by reference
In pass-by-reference, reference (address) of the actual parameters is passed to the local
parameters in the method definition. So, the changes performed on local parameters are re-
flected on the actual parameters.
n
Example:
g.i
class Swapper{
int a;
rin
int b;
Swapper(int x, int y) // constructor to initialize variables
ee
{
gin
a = x;
b = y;
}
En
void swap(Swapper ref) // method to interchange values

{
arn
int temp; /* Object is passed by reference. So the original object value

temp = ref.a; a, b gets changed*/
Le
ref.a = ref.b;
ref.b = temp;
w.
}
}
ww
class PassByRef{
Swapper obj = new Swapper(10, 20); // create object
obj.swap(obj); // call the method by passing class object as parameter

System.out.println(“After swapping: a=”+obj.a+” b=”+obj.b);
}
}
Sample Output:
Before swapping: a=10 b=20
After swapping: a=20 b=10
n
g.i
In this example, the class object is passed as parameter using pass by reference technique.
So the method refers the original value of a and b.
method using object as parameter and returning objects
rin
A method can have object as input parameter (see pass by reference) and can return a class
type object.
ee
Example:
class Addition{
gin
int no;
Addition(){}
En
Addition(int x){
no=x;
arn
}
public Addition display(Addition oa){
Le
Addition tmp=new Addition();

/*method with same class object as input parameter &
tmp.no=no+oa.no; return value*/
w.
return(tmp);
}
ww
}
class Main{
Addition a1=new Addition(10);
Addition a2=new Addition(10);
Addition a3;
a3=a1.display(a2); // method is invoked using the object a1 with input parameter a2
System.out.println(“a1.no=”+a1.no+” a2.no=”+a2.no+” a3.no=”+a3.no);

}
}
Sample Output:
a1.no=10 a2.no=10 a3.no=20
Here, display() accepts class Addition object a2 as input parameter. It also return same
class object as output. This method adds the value of invoking object a1 and input parameter
n
a2. The summation result is stored in temporary object tmp inside the method. The value re-
g.i
turned by the method is received using object a3 inside main().
1.20 metHOd OverLOading
rin
Method overloading is the process of having multiple methods with same name that dif-
fers in parameter list. The number and the data type of parameters must differ in overloaded
methods. It is one of the ways to implement polymorphism in Java. When a method is called,
ee
the overloaded method whose parameters match with the arguments in the call gets invoked.
Note: Overloaded methods are differentiable only based on parameter list and not on their
gin
return type.
Example:
En
Program for addition using Method Overloading

class MethodOverload{
arn
void add(){
System.out.println(“No parameters”);
}
Le
void add(int a,int b){ // overloaded add() for two integer parameter
w.
}
void add(int a,int b,int c){ // overloaded add() for three integer parameter
ww
System.out.println(“Sum:”+(a+b+c));
}
void add(double a,double b){ // overloaded add() for two double parameter
}
}
public class Main {
MethodOverload obj=new MethodOverload();
obj.add(); // call all versions of add()
n
obj.add(1,2);
g.i
obj.add(1,2,3);
obj.add(12.3,23.4);
rin
}
} ee
Sample Output:
No parameters
gin
Sum:3
Sum:6
En
Sum:35.7
Here, add() is overloaded four times. The first version takes no parameters, second takes
two integers, third takes three integers and fourth accepts two double parameter.
arn
1.21 access sPecifiers

Access specifiers or access modifiers in java specifies accessibility (scope) of a data mem-
Le
ber, method, constructor or class. It determines whether a data or method in a class can be
used or invoked by other class or subclass.
types of access Specifiers
w.
There are 4 types of java access specifiers:

ww
Private
Default (no speciifer)
Protected
Public
The details about accessibility level for access specifiers are shown in following table.
access modifiers default Private Protected Public
Accessible inside the class Yes Yes Yes Yes
Accessible within the subclass
Yes No Yes Yes
inside the same package
Accessible outside the package No No No Yes
Accessible within the subclass
No No Yes Yes
outside the package
n
Private access modifier
g.i
Private data fields and methods are accessible only inside the class where it is declared i.e
accessible only by same class members. It provides low level of accessibility. Encapsulation
rin
and data hiding can be achieved using private specifier.
Example: ee
Role of private specifier
class PrivateEx{
gin
private int x; // private data

public int y; // public data
En
private PrivateEx(){} // private constructor

public PrivateEx(int a,int b){ // public constructor
arn
x=a;
y=b;
}
Le
}
public class Main {
w.

ww
PrivateEx obj1=new PrivateEx(); // Error: private constructor cannot be applied

PrivateEx obj2=new PrivateEx(10,20); // public constructor can be applied to obj2
System.out.println(obj2.y); // public data y is accessible by a non-member
System.out.println(obj2.x); //Error: x has private access in PrivateEx
}
}
In this example, we have created two classes PrivateEx and Main. A class contains private
data member, private constructor and public method. We are accessing these private members
from outside the class, so there is compile time error.
Default access modifier

If the specifier is mentioned, then it is treated as default. There is no default specifier
keyword. Using default specifier we can access class, method, or field which belongs to same
n
package, but not from outside this package.
g.i
Example:
Role of default specifier
rin
class DefaultEx{ ee
int y=10; // default data
}
gin
public class Main {

En
DefaultEx obj=new DefaultEx();

arn
System.out.println(obj.y); // default data y is accessible outside the class
}
Le
Sample Output:
w.
10
ww
In the above example, the scope of class DefaultEx and its data y is default. So it can be
accessible within the same package and cannot be accessed from outside the package.
Protected access modifier

Protected methods and fields are accessible within same class, subclass inside same pack-
age and subclass in other package (through inheritance). It cannot be applicable to class and
interfaces.
Example:
Role of protected specifier
class Base{
protected void show(){
System.out.println(“In Base”);
}
n
}
g.i
public class Main extends Base{
rin
Main obj=new Main(); ee
obj.show();
}
gin
}
Sample Output:
En
In Base
In this example, show() of class Base is declared as protected, so it can be accessed from
arn
outside the class only through inheritance. Chapter 2 explains the concept of inheritance in
detail.
Le
Public access modifier

The public access specifier has highest level of accessibility. Methods, class, and fields
w.
declared as public are accessible by any class in the same package or in other package.
Example:
ww
Role of public specifier

class PublicEx{
public int no=10;
}
public class Main{

PublicEx obj=new PublicEx();
System.out.println(obj.no);
}
}
n
Sample Output:
g.i
10
In this example, public data no is accessible both by member and non-member of the
rin
class.
1.22 static KeyWOrd
ee
The static keyword indicates that the member belongs to the class instead of a specific
instance. It is used to create class variable and mainly used for memory management. The
gin
static keyword can be used with:
• Variable (static variable or class variable)
• Method (static method or class method)
En
• Block (static block)

• Nested class (static class)
arn
• import (static import)

static variable
Le
Variable declared with keyword static is a static variable. It is a class level variable com-
monly shared by all objects of the class.
w.
• Memory allocation for such variables only happens once when the class is loaded in
the memory.
ww
• scope of the static variable is class scope ( accessible only inside the class)
• lifetime is global ( memory is assigned till the class is removed by JVM).
• Automatically initialized to 0.
• It is accessible using ClassName.variablename
• Static variables can be accessed directly in static and non-static methods.
Example :
Without static With static
class staticex{ class staticex{
int no=10; static int no=10;
Staticex(){ Staticex(){
n
System.out.println(no); System.out.println(no);
g.i
no++; no++;
} }
}
rin}
ee
public class main{ public class main{
public static void main(String[] args) public static void main(String[] args)
gin
{ {
Staticex obj1=new Staticex(); Staticex obj1=new Staticex();

En

arn
} }
Le
} }
Sample Output: Sample Output:

w.
10 10
ww
10 11
10 12
n
g.i
rin
ee
static method
The method declared with static keyword is known as static method. main() is most com-
gin
mon static method.

• It belongs to the class and not to object of a class.
• A static method can directly access only static variables of class and directly invoke
En
only static methods of the class.

• Static methods cannot access non-static members(instance variables or instance
arn
methods) of the class

• Static method cant access this and super references
• It can be called through the name of class without creating any instance of that class.
Le
For example, ClassName.methodName()

Example:
w.
class StaticEx{
static int x;
ww
int y=10;
static void display(){
System.out.println(“Static Method “+x); // static method accessing static variable
}
public void show(){
System.out.println(“Non static method “+y);
System.out.println(“Non static method “+x); // non-static method can access static variable
}
}
public class Main
{
StaticEx obj=new StaticEx();
n
StaticEx.display(); // static method invoked without using object
g.i
obj.show();
}
rin
}
Sample Output: ee
Static Method 0
Non static method 10
gin
Non static method 0

In this example, class StaticEx consists of a static variable x and static method display().
The static method cannot access a non-static variable. If you try to access y inside static
En
method display(), it will result in compilation error.

/*non-static variable y cannot be referred from a
arn
static void display(){

static context*/
System.out.println(“Static Method “+x+y);
Le
}
static block
w.
A static block is a block of code enclosed in braces, preceded by the keyword static.
• The statements within the static block are first executed automatically before main
ww
when the class is loaded into JVM.

• A class can have any number of static blocks.
• JVM combines all the static blocks in a class as single block and executes them.
• Static methods can be invoked from the static block and they will be executed as and
when the static block gets executed.
Syntax:
static{
…………….
}
Example:
class StaticBlockEx{
StaticBlockEx (){
System.out.println(“Constructor”);
}
n
static {
g.i
System.out.println(“First static block”);
}
rin
static void show(){
System.out.println(“Inside method”);
ee
}
gin
static{
System.out.println(“Second static block”);
show();
En
}
arn

StaticBlockEx obj=new StaticBlockEx ();
Le
}
static{
w.
System.out.println(“Static in main”);
}
ww
}
Sample Output:
First static block
Second static block
Inside method
Static in main
Constructor
Nested class (static class)
Nested class is a class declared inside another class. The inner class must be a static class
declared using keyword static. The static nested class can refer directly to static members of
the enclosing classes, even if those members are private.
Syntax:
n
class OuterClass{
g.i
……..
static class InnerClass{
rin
……….
}
ee
}
We can create object for static nested class directly without creating object for outer class.
gin
For example:
OuterClassName.InnerClassName=new OuterClassName.InnerClassName();
En
Example:
class Outer{
arn
static int x=10;

static class Inner{
int y=20;
Le
public void show(){

System.out.println(x+y); // nested class accessing its own data & outer
w.
class static data

}
ww
}
}
class Main{
Outer.Inner obj=new Outer.Inner(); // Creating object for static nested class
obj.show();
}
}
Sample Output:
30
static import
The static import allows the programmer to access any static members of imported class
directly. There is no need to qualify it by its name.
Syntax:
Import static package_name;
n
Advantage:
g.i
• Less coding is required if you have access any static member of a class oftenly.
Disadvantage:
rin
• Overuse of static import makes program unreadable and unmaintable.
Example:
ee
import static java.lang.System.*;
class StaticImportEx{
gin

out.println(“Static Import Example”); //Now no need of System.out
En
}
}
arn
Sample Output:
Static Import Example
Le
1.23 arrays
Array is a collection of elements of similar data type stored in contiguous memory loca-
tion. The array size is fixed i.e we can’t increase/decrease its size at runtime. It is index based
w.
and the first element is stored at 0th index.

ww
Advantages of Array
• Code Optimization: Multiple values can be stored under common name. Date retrieval
or sorting is an easy process.
• Random access: Data at any location can be retrieved randomly using the index.
Disadvantages of Array
• Inefficient memory usage: Array is static. It is not resizable at runtime based on number
of user’s input. To overcome this limitation, Java introduce collection concept.
n
types of array
g.i
There are two types of array.
• One Dimensional Array
rin

Multidimensional Array
ee
gin
En
arn
Le
w.
ww
Example:
int[] a=new int[5]; //defining an integer array for 5 elements
Alternatively, we can create and initialize array using following syntax.
Syntax:
dataType[] arrayName=new datatype[]{list of values separated by comma};
Or
n
dataType[] arrayName={ list of values separated by comma};
g.i
Example:
int[] a={12,13,14};
rin
int[] a=new int[]{12,13,14};
The built-in length property is used to determine length of the array i.e. number of ele-
ments present in an array.
ee
accessing array elements
gin
The array elements can be accessed by using indices. The index starts from 0 and ends at
(array size-1). Each element in an array can be accessed using for loop.
Example:
En
Program to access array elements.

class Main{
arn

int a[]=new int[]{10,20,30,40};//declaration and initialization
Le
//printing array
for(int i=0;i<a.length;i++)//length is the property of array
w.
System.out.println(a[i]);
}
ww
}
Sample Output:
10
20
30
40
the for-each loop

The for-each loop is used to traverse the complete array sequentially without using an
index variable. It’s commonly used to iterate over an array or a Collections class (eg, Array-
List).
Syntax:
for(type var:arrayName){
Statements using var;
n
}
g.i
Example:
Program to calculate sum of array elements.
rin
class Main{
ee
int a[]=new int[]{10,20,30,40};//declaration and initialization
int sum=0;
gin
for(int i:a) // calculate sum of array elements

sum+=i;
En
}
arn
}
Sample Output:
Le
Sum:100
multidimensional arrays
w.
Multidimensional arrays are arrays of arrays with each element of the array holding the
reference of other array. These are also known as Jagged Arrays.
Syntax:
ww
dataType[][] arrayName=new datatype[rowsize][columnnsize]; // 2 dimensional array

dataType[][][] arrayName=new datatype[][][]; // 3 dimensional array
Example:
int[][] a=new int[3][4];
n
g.i
rin
Example:
Program to access 2D array elements ee
class TwoDimEx
{
gin

{
En
// declaring and initializing 2D array

int arr[][] = { {1,1,12},{2,16,1},{12,42,2} };
arn
// printing 2D array
for (int i=0; i< arr.length; i++)
{
Le
for (int j=0; j < arr[i].length ; j++)

System.out.print(arr[i][j] + “ “);
w.
System.out.println();
}
ww
}
}
Sample Output:
1 1 12
2 16 1
12 42 2
jagged array
Jagged array is an array of arrays with different row size i.e. with different dimensions.
Example:
class Main {
int[][] a = {
n
{11, 3, 43},
g.i
{3, 5, 8, 1},
{9},
rin
};
ee
System.out.println(“Length of row 1: “ + a[0].length);
gin

}
En
}
Sample Output:
arn
Length of row 1: 3
Length of row 2: 4
Le
Length of row 3: 1
Passing an array to a method
w.
An array can be passed as parameter to method.

Example:
ww
Program to find minimum element in an array

class Main{
static void min(int a[]){
int min=a[0];
for(int i=1;i<a.length;i++)
if(min>a[i])
min=a[i];
System.out.println(“Minimum:”+min);
}
int a[]={12,13,14,5};
min(a);//passing array to method
}
n
}
g.i
Sample Output:
Minimum:5
rin
returning an array from a method
A method may also return an array. ee
Example:
Program to sort array elements in ascending order.
gin
class Main{
static int[] sortArray(int a[]){
En
int tmp;
for(int i=0;i<a.length-1;i++) { //code for sorting
arn
for(int j=i+1;j<=a.length-1;j++) {
if(a[i]>a[j]){
tmp=a[i];
Le
a[i]=a[j];
a[j]=tmp;
w.
}
}
ww
}
return(a); // returning array
}
int a[]={33,43,24,5};
a=sortArray(a);//passing array to method
Inheritance and Interfaces  2.1
UNIT -2
INHERITANCE AND INTERFACES
n
2.1 InherItance
g.i
Inheritance is the mechanism in java by which one class is allow to inherit the features
(fields and methods) of another class. It is process of deriving a new class from an existing
rin
class. A class that is inherited is called a superclass and the class that does the inheriting is
called a subclass. Inheritance represents the IS-A relationship, also known as parent-child re-
lationship. The keyword used for inheritance is extends.
ee
Syntax:
class Subclass-name extends Superclass-name
gin
{
//methods and fields
En
}
Here, the extends keyword indicates that we are creating a new class that derives from an
arn
existing class.
Note: The constructors of the superclass are never inherited by the subclass
advantages of Inheritance:
Le
• Code reusability - public methods of base class can be reused in derived classes
• Data hiding – private data of base class cannot be altered by derived class
w.
• Overriding--With inheritance, we will be able to override the methods of the base

class in the derived class
ww
Example:
// Create a superclass.
class BaseClass{
int a=10,b=20;
public void add(){
}
}
// Create a subclass by extending class BaseClass.
public class Main extends BaseClass
{
public void sub(){
n
System.out.println(“Difference:”+(a-b));
g.i
}
rin
/*The subclass has access to all public members of its superclass*/
ee
obj.add();
obj.sub();
gin
}
}
En
Sample Output:
Sum:30
arn
Difference:-10
In this example, Main is the subclass and BaseClass is the superclass. Main object can
access the field of own class as well as of BaseClass class i.e. code reusability.
Le
types of inheritance
Single Inheritance :
w.
In single inheritance, a subclass inherit the features of one superclass.

example:
ww
class Shape{
int a=10,b=20;
}
class Rectangle extends Shape{
public void rectArea(){
System.out.println(“Rectangle Area:”+(a*b));
}
}
public class Main
{
Rectangle obj=new Rectangle();
n
obj.rectArea();
g.i
}
}
rin
ee
gin
En
arn
Le
w.
ww
Multilevel Inheritance:
In Multilevel Inheritance, a derived class will be inheriting a base class and as well as the
derived class also act as the base class to other class i.e. a derived class in turn acts as a base
class for another class.
Example:
class Numbers{
int a=10,b=20;
}
class Add2 extends Numbers{
int c=30;
n
public void sum2(){
g.i
System.out.println(“Sum of 2 nos.:”+(a+b));
}
rin
}
class Add3 extends Add2{ ee
public void sum3(){
System.out.println(“Sum of 3 nos.:”+(a+b+c));
gin
}
}
En
public class Main

{
arn

Add3 obj=new Add3();
obj.sum2();
Le
obj.sum3();
}
w.
}
ww
Sample Output:
Sum of 2 nos.:30
Sum of 3 nos.:60
hierarchical Inheritance:
In Hierarchical Inheritance, one class serves as a superclass (base class) for more than
one sub class.
Example:
class Shape{
int a=10,b=20;
}
class Rectangle extends Shape{
public void rectArea(){
n
System.out.println(“Rectangle Area:”+(a*b));
g.i
}
}
rin
class Triangle extends Shape{
public void triArea(){ ee
System.out.println(“Triangle Area:”+(0.5*a*b));
}
gin
}
public class Main
En
{
arn
Rectangle obj=new Rectangle();

obj.rectArea();
Triangle obj1=new Triangle();
Le
obj1.triArea();
}
w.
}
ww
Sample Output:
Rectangle Area:200
Triangle Area:100.0
Multiple inheritance
Java does not allow multiple inheritance:
• To reduce the complexity and simplify the language
• To avoid the ambiguity caused by multiple inheritance
For example, Consider a class C derived from two base classes A and B. Class C inherits
A and B features. If A and B have a method with same signature, there will be ambiguity to
call method of A or B class. It will result in compile time error.
class A{
void msg(){System.out.println(“Class A”);}
}
class B{
n
void msg(){System.out.println(“Class B “);}
g.i
}
class C extends A,B{//suppose if it were
rin
Public Static void main(String args[]){
C obj=new C();
ee
obj.msg();//Now which msg() method would be invoked?
}
gin
}
Sample Output:
En
Compile time error

Direct implementation of multiple inheritance is not allowed in Java. But it is achievable
arn
using Interfaces. The concept about interface is discussed in chapter.2.7.

access control in Inheritance
The following rules for inherited methods are enforced −
Le
• Variables declared public or protected in a superclass are inheritable in subclasses.

• Variables or Methods declared private in a superclass are not inherited at all.
w.
• Methods declared public in a superclass also must be public in all subclasses.

ww
• Methods declared protected in a superclass must either be protected or public in

subclasses; they cannot be private.
Example:
// Create a superclass
class A{
int x; // default specifier
private int y; // private to A
public void set_xy(int a,int b){

x=a;
y=b;
}
}
// A’s y is not accessible here.
n
class B extends A{
g.i
public void add(){
System.out.println(“Sum:”+(x+y)); //Error: y has private access in A – not inheritable
rin
}
} ee
class Main{
gin
B obj=new B();
obj.set_xy(10,20);
En
obj.add();
}
arn
}
In this example since y is declared as private, it is only accessible by its own class mem-
bers. Subclasses have no access to it.
Le
2.2 UsIng sUper

The super keyword refers to immediate parent class object. Whenever you create the in-
w.
stance of subclass, an instance of parent class is created implicitly which is referred by super
reference variable.
ww
• It an be used to refer immediate parent class instance variable when both parent and
child class have member with same name
• It can be used to invoke immediate parent class method when child class has overridden
that method.
• super() can be used to invoke immediate parent class constructor.
Use of super with variables:
When both parent and child class have member with same name, we can use super key-
word to access mamber of parent class.
Example:
class SuperCls
{
int x = 20;
}
/* sub class SubCls extending SuperCls */
n
class SubCls extends SuperCls
g.i
{
int x = 80;
rin
void display()
{ ee
System.out.println(“Super Class x: “ + super.x); //print x of super class
System.out.println(“Sub Class x: “ + x); //print x of subclass
gin
}
}
En
/* Driver program to test */

class Main
arn
{
{
Le
SubCls obj = new SubCls();

obj.display();
w.
}
ww
}
sample Output:
Super Class x: 20
Sub Class x: 80
In the above example, both base class and subclass have a member x. We could access x
of base class in sublcass using super keyword.
Use of super with methods:

The super keyword can also be used to invoke parent class method. It should be used if
subclass contains the same method as parent class (Method Overriding).
class SuperCls
{
int x = 20;
void display(){ //display() in super class
n
System.out.println(“Super Class x: “ + x);
g.i
}
}
rin
class SubCls extends SuperCls ee
{
int x = 80;
gin
void display() //display() redefined in sub class – method overriding

{
System.out.println(“Sub Class x: “ + x);
En
super.display(); // invoke super class display()

}
arn
}
Le
class Main
{
w.

{
ww

obj.display();
}
}
Sample Output:
Sub Class x: 80
Super Class x: 20
In the above example, if we only call method display() then, the display() of sub class gets
invoked. But with the use of super keyword, display() of superclass could also be invoked.
Use of super with constructors:
The super keyword can also be used to invoke the parent class constructor.
Syntax:
super();
n
• super() if present, must always be the first statement executed inside a subclass
constructor.
g.i
• When we invoke a super() statement from within a subclass constructor, we are
invoking the immediate super class constructor
rin
Example:
class SuperCls
ee
{
SuperCls(){
gin
System.out.println(“In Super Constructor”);

}
En
}
arn
class SubCls extends SuperCls

{
Le
SubCls(){
super();
w.
System.out.println(“In Sub Constructor”);

}
ww
}
class Main
{
{

}
}
Sample Output:
In Super Constructor
In Sub Constructor
n
2.3 Order Of cOnstrUctOr InvOcatIOn
g.i
• Constructors are invoked in the order of their derivation
• If a subclass constructor does not explicitly invoke a superclass constructor using

rin
ee
Example:
class A
gin
{
A(){
En
System.out.println(“A’s Constructor”);
}
arn
}
/* sub class B extending A */
class B extends A
Le
{
B(){
w.
super();
ww
System.out.println(“B’s Constructor”);
}
}
/* sub class C extending B */
class C extends B{
C(){
super();
System.out.println(“C’s Constructor”);
}
}
class Main
{
n
g.i
{
C obj = new C();
rin
}
} ee
Sample Output:
A’s Constructor
gin
B’s Constructor
C’s Constructor
En
Invoking superclass parameterized constructor

To call parameterized constructor of superclass, we must use the super keyword as shown
below.
arn
Syntax:
super(value);
Le
Example:
class SuperCls{
w.
int x;
SuperCls(int x){
ww
this.x=x; // this refers to current invoking object

}
}
class SubCls extends SuperCls{
int y;
SubCls(int x,int y){
super(x); // invoking parameterized constructor of superclass

this.y=y;
}
public void display(){
System.out.println(“x: “+x+” y: “+y);
}
n
}
g.i
public class Main
{
rin
SubCls obj=new SubCls(10,20); ee
obj.display();
}
gin
}
Sample Output:
En
x: 10 y: 20
The program contains a superclass and a subclass, where the superclass contains a param-
eterized constructor which accepts a integer value, and we used the super keyword to invoke
arn
the parameterized constructor of the superclass.

2.4 the Object class
Le
The Object class is the parent class of all the classes in java by default (directly or indi-
rectly). The java.lang.Object class is the root of the class hierarchy. Some of the Object class
are Boolean, Math, Number, String etc.
w.
Object
ww
Boolean Character Number Math String StringBuffer
Byte Short Integer Long Float Double
Some of the important methods defined in Object class are listed below.
Object class Methods description
boolean equals(Object) Returns true if two references point to the same object.
String toString() Converts object to String
void notify()
void notifyAll() Used in synchronizing threads
void wait()
n
void finalize() Called just before an object is garbage collected
g.i
Returns a new object that are exactly the same as the current
Object clone()
object
int hashCode() Returns a hash code value for the object.
rin
Example:
public class Test
ee
{
gin
{
/*hashcode is the unique number generated by JVM*/
En
Test t = new Test();

System.out.println(t);
arn
System.out.println(t.toString()); // provides String representation of an Object

System.out.println(t.hashCode());
Le
t = null; /*calling garbage collector explicitly to dispose system resources, perform

System.gc(); clean-up activities and minimize memory leaks*/
w.
System.out.println(“end”);
}
ww
protected void finalize() // finalize() is called just once on an object

{
System.out.println(“finalize method called”);
}
}
Sample Output:
Test@2a139a55
Test@2a139a55
705927765
end
finalize method called
In the above program, the default toString() method for class Object returns a string con-
n
sisting of the name of the class Test of which the object is an instance, the at-sign character
g.i
`@’, and the unsigned hexadecimal representation of the hash code of the object.
2.5 abstract classes and MethOds
rin
abstract class
A class that is declared as abstract is known as abstract class. It can have abstract and
non-abstract methods (method with body). It needs to be extended and its method imple-
ee
mented. It cannot be instantiated.
Syntax:
gin
abstract class classname

{
En
}
abstract method
arn
A method that is declared as abstract and does not have implementation is known as ab-
stract method. The method body will be defined by its subclass.
Abstract method can never be final and static. Any class that extends an abstract class
Le
must implement all the abstract methods declared by the super class.
Note:
w.
A normal class (non-abstract class) cannot have abstract methods.

Syntax:
ww
abstract returntype functionname (); //No definition

syntax for abstract class and method:
modifier abstract class className
{
//declare fields
//declare methods
abstract dataType methodName();

}
modifier class childClass extends className
{
dataType methodName()
{
n
}
g.i
}
Why do we need an abstract class?
rin
Consider a class Animal that has a method sound() and the subclasses of it like Dog Lion,
Horse Cat etc. Since the animal sound differs from one animal to another, there is no point to
implement this method in parent class. This is because every child class must override this
ee
method to give its own implementation details, like Lion class will say “Roar” in this method
and Horse class will say “Neigh”.
gin
So when we know that all the animal child classes will and should override this method,
then there is no point to implement this method in parent class. Thus, making this method
abstract would be the good choice. This makes this method abstract and all the subclasses
En
to implement this method. We need not give any implementation to this method in parent
class.
Since the Animal class has an abstract method, it must be declared as abstract.
arn
Now each animal must have a sound, by making this method abstract we made it compul-
sory to the child class to give implementation details to this method. This way we ensure that
every animal has a sound.
Le
rules
1. Abstract classes are not Interfaces.
w.
2. An abstract class may have concrete (complete) methods.

ww
An abstract class may or may not have an abstract method. But if any class has one or
more abstract methods, it must be compulsorily labeled abstract.
Abstract classes can have Constructors, Member variables and Normal methods.
Abstract classes are never instantiated.
For design purpose, a class can be declared abstract even if it does not contain any
abstract methods.
Reference of an abstract class can point to objects of its sub-classes thereby achieving
run-time polymorphism Ex: Shape obj = new Rectangle();
A class derived from the abstract class must implement all those methods that are
declared as abstract in the parent class.
If a child does not implement all the abstract methods of abstract parent class, then the
child class must need to be declared abstract as well.
example 1
//abstract parent class
abstract class Animal
n
{
g.i
//abstract method
public abstract void sound();
rin
}
//Lion class extends Animal class
ee
public class Lion extends Animal
{
gin
public void sound()

{
En
System.out.println(“Roars”);
}
arn

{
Le
Animal obj = new Lion();

obj.sound();
w.
}
}
ww
Output:
Roars
In the above code, Animal is an abstract class and Lion is a concrete class.
example 2
abstract class Bank
{
abstract int getRateOfInterest();
}
class SBI extends Bank
n
{
g.i
int getRateOfInterest()
{
rin
return 7;
} ee
}
class PNB extends Bank
gin
{
int getRateOfInterest()
En
{
return 8;
arn
}
}
public class TestBank
Le
{
w.
{
ww
Bank b=new SBI();//if object is PNB, method of PNB will be invoked

int interest=b.getRateOfInterest();
System.out.println(“Rate of Interest is: “+interest+” %”);
b=new PNB();
System.out.println(“Rate of Interest is: “+b.getRateOfInterest()+” %”);
}
}
Output:
Rate of Interest is: 7 %
Rate of Interest is: 8 %
abstract class with concrete (normal) method
Abstract classes can also have normal methods with definitions, along with abstract
methods.
Sample Code:
n
abstract class A
g.i
{
abstract void callme();
rin
public void normal()
{
ee
System.out.println(“this is a normal (concrete) method.”);
}
gin
}
public class B extends A
En
{
void callme()
arn
{
System.out.println(“this is an callme (abstract) method.”);
}
Le

{
w.
B b = new B();
b.callme();
ww
b.normal();
}
}
Output:
this is an callme (abstract) method.
this is a normal (concrete) method.
Observations about abstract classes in java

1. an instance of an abstract class cannot be created; but, we can have references
of abstract class type though.
Sample Code:
abstract class Base
{
abstract void fun();
n
}
g.i
class Derived extends Base
{
rin
void fun()
{
ee
System.out.println(“Derived fun() called”);
gin
}
}
public class Main
En
{
arn
{
// Base b = new Base(); Will lead to error
Le
// We can have references of Base type.

Base b = new Derived();
w.
b.fun();
}
ww
}
Output:
Derived fun() called
an abstract class can contain constructors in java. and a constructor of ab-

stract class is called when an instance of a inherited class is created.
Sample Code:
abstract class Base
{
Base()
{
n
System.out.println(“Within Base Constructor”);
g.i
}
abstract void fun();
rin
}
ee
{
Derived()
gin
{
System.out.println(“Within Derived Constructor”);
En
}
void fun()
arn
{
System.out.println(“ Within Derived fun()”);
}
Le
}
public class Main
w.
{
ww
{
Derived d = new Derived();
}
}
Output:
Within Base Constructor
Within Derived Constructor
3. We can have an abstract class without any abstract method. this allows us to create
classes that cannot be instantiated, but can only be inherited.
Sample Code:
abstract class Base
{
void fun()
{
n
System.out.println(“Within Base fun()”);
g.i
}
}
rin
{
ee
}
gin
public class Main
{
En
{
Derived d = new Derived();
arn
d.fun();
}
Le
}
Output:
w.
Within Base fun()

4. Abstract classes can also have final methods (methods that cannot be
ww
overridden).
Sample Code:
abstract class Base
{
final void fun()
{
System.out.println(“Within Derived fun()”);

}
}
{
}
n
public class Main
g.i
{
rin
{
Base b = new Derived(); ee
b.fun();
}
gin
}
Output:
En
Within Derived fun()

2.6 fInal MethOds and classes
arn
The final keyword in java is used to restrict the user. The java final keyword can be ap-
plied to:
• variable
Le
• method
• class
w.
Java final variable - To prevent constant variables

Java final method - To prevent method overriding
ww
Java final class - To prevent inheritance

Figure: Uses of final in java
Java final variable

The final keyword can be applied with the variables, a final variable that have no value
it is called blank final variable or uninitialized final variable. It can be initialized in the con-
structor only. The blank final variable can be static also which will be initialized in the static
block only.
sample code:
A final variable speedlimit is defined within a class Vehicle. When we try to change the
value of this variable, we get an error. This is due to the fact that the value of final variable
cannot be changed, once a value is assigned to it.
public class Vehicle
{
final int speedlimit=60;//final variable
n
void run()
g.i
{
speedlimit=400;
rin
}
ee
{
Vehicle obj=new Vehicle();
gin
obj.run();
}
En
}
Output:
arn
/Vehicle.java:6: error: cannot assign a value to final variable speedlimit

speedlimit=400;
Le
^
1 error
w.
Blank final variable

A final variable that is not initialized at the time of declaration is known as blank final
ww
variable. We must initialize the blank final variable in constructor of the class otherwise it will
throw a compilation error.
Sample Code:
public class Vehicle
{
final int speedlimit; //blank final variable
void run()
{
}
{
Vehicle obj=new Vehicle();
obj.run();
n
}
g.i
}
Output:
rin
/Vehicle.java:3: error: variable speedlimit not initialized in the default constructor
final int speedlimit; //blank final variable
ee
^
1 error
gin
java final Method

A Java method with the final keyword is called a final method and it cannot be overridden
in the subclass.
En
In general, final methods are faster than non-final methods because they are not required
to be resolved during run-time and they are bonded at compile time.
arn
Sample Code:
class XYZ
Le
{
final void demo()
w.
{
System.out.println(“XYZ Class Method”);
ww
}
}
public class ABC extends XYZ
{
void demo()
{
System.out.println(“ABC Class Method”);

}
{
ABC obj= new ABC();
obj.demo();
n
}
g.i
}
Output:
rin
/ABC.java:11: error: demo() in ABC cannot override demo() in XYZ
void demo() ee
^
overridden method is final
gin
1 error
The following code will run fine as the final method demo() is not overridden. This shows
that final methods are inherited but they cannot be overridden.
En
Sample Code:
class XYZ
arn
{
final void demo()
Le
{
System.out.println(“XYZ Class Method”);
w.
}
}
ww
public class ABC extends XYZ

{
{
ABC obj= new ABC();

obj.demo();
}
}
Output:
XYZ Class Method
n
Points to be remembered while using final methods:
g.i
• Private methods of the superclass are automatically considered to be final.
• Since the compiler knows that final methods cannot be overridden by a subclass, so
these methods can sometimes provide performance enhancement by removing calls
rin
to final methods and replacing them with the expanded code of their declarations at
each method call location. ee
• Methods made inline should be small and contain only few lines of code. If it grows
in size, the execution time benefits become a very costly affair.
gin
• A final’s method declaration can never change, so all subclasses use the same method
implementation and call to one can be resolved at compile time. This is known
as static binding.
En
java final class

• Final class is a class that cannot be extended i.e. it cannot be inherited.
arn
• A final class can be a subclass but not a superclass.

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

• Several classes in Java are final e.g. String, Integer, and other wrapper classes.
w.
• The final keyword can be placed either before or after the access specifier.
Syntax:
ww
final public class A public final class A
{ {
OR
//code //code
} }
n
g.i
rin
ee
gin
En
arn
Le
w.
• class
ww
in Java.
• Final member variable must be initialized at the time of declaration or inside the
constructor, failure to do so will result in compilation error.
• We cannot reassign value to a final variable in Java.
• The local final variable must be initialized during declaration.
• overridden in Java.
• A final class cannot be inheritable in Java.
• Exception handling in
Java.
• Final should not be confused with finalize() method which is declared in Object class
and called before an object is a garbage collected by JVM.
• All variable declared inside Java interface are implicitly final.
• abstract in
Java.
n
• Final methods are bonded during compile time also called static binding.
g.i
• Final variables which are not initialized during declaration are called blank final
variable and must be initialized in all constructor either explicitly or by calling
this(). Failure to do so compiler will complain as “final variable (name) might not be
rin
initialized”.
• Making a class, method or variable final in Java helps to improve performance because
ee
JVM gets an opportunity to make assumption and optimization.
2.7 Interfaces
gin
An interface is a reference type in Java. It is similar to class. It is a collection of abstract

methods. Along with abstract methods, an interface may also contain constants, default meth-
ods, static methods, and nested types. Method bodies exist only for default methods and static
En
methods.
An interface is similar to a class in the following ways:
arn
• An interface can contain any number of methods.

• An interface is written in a file with a .java extension, with the name of the interface
matching the name of the file.
Le
• The byte code of an interface appears in a .class file.

• Interfaces appear in packages, and their corresponding bytecode file must be in a
w.
directory structure that matches the package name.

Uses of interface:
ww
• Since java does not support multiple inheritance in case of class, it can be achieved
by using interface.
• It is also used to achieve loose coupling.
• Interfaces are used to implement abstraction.
Defining an Interface
An interface is defined much like a class.
Syntax:
accessspecifier interface interfacename
{
return-type method-name1(parameter-list);
return-type method-name2(parameter-list);
type final-varname1 = value;
n
type final-varname2 = value;
g.i
// ...
return-type method-nameN(parameter-list);
rin
type final-varnameN = value;
} ee
When no access specifier is included, then default access results, and the interface is only
available to other members of the package in which it is declared. When it is declared as pub-
lic, the interface can be used by any other code.
gin
• The java file must have the same name as the interface.
• The methods that are declared have no bodies. They end with a semicolon after the
En
parameter list. They are abstract methods; there can be no default implementation of
any method specified within an interface.
• Each class that includes an interface must implement all of the methods.
arn
• Variables can be declared inside of interface declarations. They are implicitly final
and static, meaning they cannot be changed by the implementing class. They must
also be initialized.
Le
• All methods and variables are implicitly public.

w.
Sample Code:
The following code declares a simple interface Animal that contains two methods called
eat() and travel() that take no parameter.
ww
/* File name : Animal.java */

interface Animal {
public void eat();
public void travel();
}
Implementing an Interface
Once an interface has been defined, one or more classes can implement that interface. To
implement an interface, the ‘implements’ clause is included in a class definition and then the
methods defined by the interface are created.
Syntax:
class classname [extends superclass] [implements interface [,interface...]]
{
n
// class-body
g.i
}
properties of java interface
rin
• If a class implements more than one interface, the interfaces are separated with a
comma. ee
• If a class implements two interfaces that declare the same method, then the same
method will be used by clients of either interface.
gin
• The methods that implement an interface must be declared public.

• The type signature of the implementing method must match exactly the type signature
specified in the interface definition.
En
rules
• A class can implement more than one interface at a time.
arn
• A class can extend only one class, but can implement many interfaces.
• An interface can extend another interface, in a similar way as a class can extend
another class.
Le
Sample Code 1:
The following code implements an interface Animal shown earlier.
w.
/* File name : MammalInt.java */

ww
public class Mammal implements Animal

{
public void eat()
{
System.out.println(“Mammal eats”);
}
public void travel()
{
System.out.println(“Mammal travels”);
}
public int noOfLegs()
{
return 0;
n
}
g.i
{
rin
Mammal m = new Mammal();
m.eat(); ee
m.travel();
}
gin
}
Output:
En
Mammal eats
Mammal travels
arn
It is both permissible and common for classes that implement interfaces to define ad-
ditional members of their own. In the above code, Mammal class defines additional method
called noOfLegs().
Le
Sample Code 2:
The following code initially defines an interface ‘Sample’ with two members. This inter-
face is implemented by a class named ‘testClass’.
w.
import java.io.*;
ww
// A simple interface
interface Sample
{
final String name = “Shree”;
void display();
}
// A class that implements interface.

public class testClass implements Sample
{
public void display()
{
System.out.println(“Welcome”);
n
}
g.i
{
rin
testClass t = new testClass();
t.display(); ee
System.out.println(name);
}
gin
}
Output:
En
Welcome
Shree
arn
Sample Code 3:
In this example, Drawable interface has only one method. Its implementation is provided
by Rectangle and Circle classes.
Le
interface Drawable
{
w.
void draw();
}
ww
class Rectangle implements Drawable

{
public void draw()
{
System.out.println(“Drawing rectangle”);
}
}
class Circle implements Drawable
{
public void draw()
{
System.out.println(“Drawing circle”);
n
}
g.i
}
public class TestInterface
rin
{
ee
{
Drawable d=new Circle();
gin
d.draw();
}
En
}
Output:
arn
Drawing circle
nested Interface
An interface can be declared as a member of a class or another interface. Such an inter-
Le
face is called a member interface or a nested interface. A nested interface can be declared as
public, private, or protected.
w.
Sample Code:
interface MyInterfaceA
ww
{
void display();
interface MyInterfaceB
{
void myMethod();
}
}
public class NestedInterfaceDemo1 implements MyInterfaceA.MyInterfaceB
{
public void myMethod()
{
System.out.println(“Nested interface method”);
n
}
g.i
{
rin
MyInterfaceA.MyInterfaceB obj= new NestedInterfaceDemo1();
obj.myMethod(); ee
}
}
gin
Output:
Nested interface method
En
Differences between classes and interfaces

Both classes and Interfaces are used to create new reference types. A class is a collection
of fields and methods that operate on fields. A class creates reference types and these refer-
arn
ence types are used to create objects. A class has a signature and a body. The syntax of class
declaration is shown below:
class class_Name extends superclass implements interface_1,….interface_n
Le
// class signature
{
w.
//body of class.
ww
}
Signature of a class has class’s name and information that tells whether the class has in-
herited another class. The body of a class has fields and methods that operate on those fields.
A Class is created using a keyword class.
When a class is instantiated, each object created contains a copy of fields and methods
with them. The fields and members declared inside a class can be static or nonstatic. Static
members value is constant for each object whereas, the non-static members are initialized by
each object differently according to its requirement.
Members of a class have access specifiers that decide the visibility and accessibility of
the members to the user or to the subclasses. The access specifiers are public, private and pro-
tected. A class can be inherited by another class using the access specifier which will decide
the visibility of members of a superclass (inherited class) in a subclass (inheriting class).
An interface has fully abstract methods (methods with nobody). An interface is syntacti-
cally similar to the class but there is a major difference between class and interface that is a
class can be instantiated, but an interface can never be instantiated.
An interface is used to create the reference types. The importance of an interface in Java
n
is that, a class can inherit only a single class. To circumvent this restriction, the designers of
g.i
Java introduced a concept of interface. An interface declaration is syntactically similar to a
class, but there is no field declaration in interface and the methods inside an interface do not
have any implementation. An interface is declared using a keyword interface.
rin
aspect for
class Interface
comparison
ee An interface can never be instanti-
A class is instantiated to create
basic ated as the methods are unable to
objects.
perform any action on invoking.
gin
Keyword class Interface

access The members of a class can be The members of an interface are
specifier private, public or protected. always public.
En
The methods of a class are defined The methods in an interface are

Methods
to perform a specific action. purely abstract.
arn
A class can implement any num- An interface can extend multiple

inheritance ber of interfaces and can extend interfaces but cannot implement
only one class. any interface.
Inheritance
Le
extends implements
keyword
An interface can never have a
A class can have constructors to
w.
constructor constructor as there is hardly any

initialize the variables.
variable to initialize.
class class_Name Interface interface_Name
ww
{ {
//fields Type var_name=value;
declaration
//Methods Type method1(parameter-list);
syntax
} Type method2(parameter-list);
..
}
The following example shows that a class that implements one interface:
public interface interface_example
{
public void method1();
public string method2();
}
n
public class class_name implements interface_example
g.i
{
public void method1()
rin
{
.. ee
}
public string method2()
gin
{
…
En
}
}
arn
Inheritance between concrete (non-abstract) and abstract classes use extends keyword.
It is possible to extend only one class to another. Java does not support multiple inheri-
tance. However, multilevel inheritance i.e., any number of classes in a ladder is possible. For
Le
example, in the following code class C extends the class B, where the class B extends class
A.
class A {}
w.
class B extends A { }
ww
class C extends B { }
Inheritance between classes (including abstract classes) and interfaces, use implements
keyword.
To support multiple inheritance, it uses interfaces. So after implements keyword, there
can be any number of interfaces. For example, in the following code, class B extends only
one class A and two interfaces I1 and I2.
interface I1 {}
interface I2 {}
class A
class B extends A implements I1, I2
{
}
n
Inheritance between two interfaces, is possible with the use of extends keyword only.
g.i
For example, in the following code, interface I2 extends the interface I1.
interface I1 { }
rin
interface I2 extends I1{ }
2.8 Object clOnIng ee
Object cloning refers to creation of exact copy of an object. It creates a new instance of
the class of current object and initializes all its fields with exactly the contents of the corre-
sponding fields of this object. In Java, there is no operator to create copy of an object. Unlike
gin
C++, in Java, if we use assignment operator then it will create a copy of reference variable
and not the object. This can be explained by taking an example. Following program demon-
strates the same.
En
// Java program to demonstrate that assignment operator creates a new reference to same
object.
arn
import java.io.*;
class sample
Le
{
int a;
w.
float b;
sample()
ww
{
a = 10;
b = 20;
}
}
class Mainclass
{

{
sample ob1 = new sample();
System.out.println(ob1.a + “ “ + ob1.b);
sample ob2 = ob1;
ob2.a = 100;
n
System.out.println(ob1.a+” “+ob1.b);
g.i
System.out.println(ob2.a+” “+ob2.b);
}
rin
}
Output: ee
10 20.0
100 20.0
gin
100 20.0
creating a copy using clone() method
En
The class whose object’s copy is to be made must have a public clone method in it or in
one of its parent class.
• Every class that implements clone() should call super.clone() to obtain the cloned
arn
object reference.
• The class must also implement java.lang.Cloneable interface whose object clone
we want to create otherwise it will throw CloneNotSupportedException when clone
Le
method is called on that class’s object.

• Syntax:
w.
• protected Object clone() throws CloneNotSupportedException

import java.util.ArrayList;
ww
class sample1
{
int a, b;
}
class sample2 implements Cloneable
{
n
g.i
rin
ee
gin
En
arn
Le
w.
ww
shallow copy
Shallow copy is method of copying an object. It is the default in cloning. In this method
the fields of an old object ob1 are copied to the new object ob2. While copying the object type
field the reference is copied to ob2 i.e. object ob2 will point to same location as pointed out
by ob1. If the field value is a primitive type it copies the value of the primitive type. So, any
changes made in referenced objects will be reflected in other object.
Note:
Shallow copies are cheap and simple to make.
n
deep copy
g.i
To create a deep copy of object ob1 and place it in a new object ob2 then new copy of any
referenced objects fields are created and these references are placed in object ob2. This means any
rin
changes made in referenced object fields in object ob1 or ob2 will be reflected only in that object
and not in the other. A deep copy copies all fields, and makes copies of dynamically allocated
ee
memory pointed to by the fields. A deep copy occurs when an object is copied along with the
objects to which it refers.
gin
//Java program for deep copy using clone()

import java.util.ArrayList;
En
class Test
{
arn
int a, b;
}
Le
class Test2 implements Cloneable

{
w.
int c, d;
Test ob1 = new Test();
ww
public Object clone() throws CloneNotSupportedException

{
// Assign the shallow copy to new refernce variable t
Test2 t1 = (Test2)super.clone();
t1.ob1 = new Test();
// Create a new object for the field c
// and assign it to shallow copy obtained,
// to make it a deep copy

return t1;
}
}
public class Main
{
n
public static void main(String args[]) throws CloneNotSupportedException
g.i
{
Test2 t2 = new Test2();
rin
t2.c = 10;
t2.d = 20; ee
t2.ob1.a = 30;
t2.ob1.b = 40;
gin
Test2 t3 = (Test2)t2.clone();
t3.c = 100;
En
t3.ob1.a = 300;
System.out.println (t2.c + “ “ + t2.d + “ “ + t2.ob1.a + “ “ + t2.ob1.b);
arn
System.out.println (t3.c + “ “ + t3.d + “ “ + t3.ob1.a + “ “ + t3.ob1.b);

}
}
Le
Output
10 20 30 40
w.
100 20 300 0
ww
Advantages of clone method:

• If we use assignment operator to assign an object reference to another reference
variable then it will point to same address location of the old object and no new copy
of the object will be created. Due to this any changes in reference variable will be
reflected in original object.
• If we use copy constructor, then we have to copy all of the data over explicitly i.e.
we have to reassign all the fields of the class in constructor explicitly. But in clone
method this work of creating a new copy is done by the method itself. So to avoid
extra processing we use object cloning.
2.9 nested classes

In Java, a class can have another class as its member. The class written within another
class is called the nested class, and the class that holds the inner class is called the outer
class.
Java inner class is defined inside the body of another class. Java inner class can be de-
clared private, public, protected, or with default access whereas an outer class can have only
public or default access. The syntax of nested class is shown below:
class Outer_Demo {
n
class Nested_Demo {
g.i
}
rin
}
types of nested classes
There are two types of nested classes in java. They are non-static and static nested classes.
ee
The non-static nested classes are also known as inner classes.
gin
• Non-static nested class (inner class)
○ Member inner class
○ Method Local inner class
En
○ Anonymous inner class

• Static nested class
arn
type description
Member Inner Class A class created within class and outside method.
Anonymous Inner Class A class created for implementing interface or extending class.
Le
Its name is decided by the java compiler.

Method Local Inner Class A class created within method.
w.
Static Nested Class A static class created within class.

Nested Interface An interface created within class or interface.
ww
2.10 Inner classes (nOn-statIc nested classes)

Inner classes can be used as the security mechanism in Java. Normally, a class cannot be
related with the access specifier private. However if a class is defined as a member of other
class, then the inner class can be made private. This class can have access to the private mem-
bers of a class.
The three types of inner classes are

• Member Inner Class
• Method-local Inner Class
• Anonymous Inner Class
Member Inner class
The Member inner class is a class written within another class. Unlike a class, an inner
class can be private and once you declare an inner class private, it cannot be accessed from
n
an object outside the class.
g.i
The following program is an example for member inner class.
class Outer_class {
rin
int n=20;
private class Inner_class {
ee
public void display() {
System.out.println(“This is an inner class”);
gin
System.out.println(“n:”+n);
}
En
}
void print_inner() {
arn
Inner_class inn = new Inner_class();

inn.display();
Le
}
}
w.
public class Myclass {

public static void main(String args[]) {
ww
Outer_class out= new Outer_class();

out.print_inner();
}
}
Output:
This is an inner class
Method-local Inner class

In Java, a class can be written within a method. Like local variables of the method, the
scope of the inner class is restricted within the method. A method-local inner class can be
instantiated only within the method where the inner class is defined. The following program
shows how to use a method-local inner class. The following program is an example for Meth-
od-local Inner Class
public class Outer_class {
void Method1() {
n
int n = 100;
g.i
class MethodInner_class {
public void display() {
rin
System.out.println(“This is method inner class “);
System.out.println(“n:”+n);
ee
}
gin
}
MethodInner_class inn= new MethodInner_class();
inn.display();
En
}
arn
Outer_class out = new Outer_class();

out.Method1();
Le
}
}
w.
Output:
This is method inner class
ww
n: 100
anonymous Inner class
An inner class declared without a class name is known as an anonymous inner class. The
anonymous inner classes can be created and instantiated at the same time. Generally, they are
used whenever you need to override the method of a class or an interface. The syntax of an
anonymous inner class is as follows –
abstract class Anonymous_Inner {

public abstract void Method1();
}
The following program is an example for anonymous inner class.
n
Anonymous_Inner inn = new Anonymous_Inner() {
g.i
public void Method1() {
System.out.println(“This is the anonymous inner class”);
rin
}
};
ee
inn.Method1();
gin
}
}
Output:
En
This is the anonymous inner class

static nested class
arn
A static inner class is a nested class which is a static member of the outer class. It can
be accessed without instantiating the outer class, using other static members. Just like static
Le
members, a static nested class does not have access to the instance variables and methods of
the outer class. Instantiating a static nested class is different from instantiating an inner class.
The following program shows how to use a static nested class.
w.

static class inner_class{
ww
public void Method1() {

System.out.println(“This is the nested class”);
}
}
Outer_class.inner_class obj = new Outer_class.inner_class();

obj.Method1();
}
}
Output:
This is the nested class
n
advantage of java inner classes:
g.i
There are basically three advantages of inner classes in java. They are as follows:
• Nested classes represent a special type of relationship that is it can access all the
rin
members of outer class including private.
• Nested classes are used to develop more readable and maintainable code because it
logically group classes and interfaces in one place only.
ee
• It provides code optimization. That is it requires less code to write.
gin
2.11 arraylIst
ArrayList is a part of collection framework. It is present in java.util package. It provides
us dynamic arrays in Java. Though, it may be slower than standard arrays but can be helpful
En
in programs where lots of manipulation in the array is needed.

• ArrayList inherits AbstractList class and implements List interface.
arn
• ArrayList is initialized by a size; however the size can increase if collection grows or
shrink if objects are removed from the collection.
• Java ArrayList allows us to randomly access the list.
Le
• ArrayList cannot be used for primitive types, like int, char, etc.
• ArrayList in Java is much similar to vector in C++.
w.
java arraylist class

Java ArrayList class extends AbstractList class which implements List interface. The List
ww
interface extends Collection and Iterable interfaces in hierarchical order.
n
g.i
rin
ee
Java ArrayList class uses a dynamic array for storing the elements. It inherits AbstractList
gin
class and implements List interface.

The important points about Java ArrayList class are:
En
• Java ArrayList class can contain duplicate elements.

• Java ArrayList class maintains insertion order.
arn
• Java ArrayList class is non synchronized.

• Java ArrayList allows random access because array works at the index basis.
• In Java ArrayList class, manipulation is slow because a lot of shifting needs to be
Le
occurred if any element is removed from the array list.

arraylist class declaration
w.
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAc-

cess, Cloneable, Serializable
ww
constructors of java arraylist

constructor description
ArrayList() It is used to build an empty array list.
ArrayList(Collection c) It is used to build an array list that is initialized with the
elements of the collection c.
ArrayList(int capacity) It is used to build an array list that has the specified initial
capacity.
Methods of java arraylist

Method description
void add(int index, Object It is used to insert the specified element at the specified
element) position index in a list.
boolean addAll It is used to append all of the elements in the specified
(Collection c) collection to the end of this list, in the order that they are
returned by the specified collection’s iterator.
n
void clear() It is used to remove all of the elements from this list.
g.i
int lastIndexOf(Object o) It is used to return the index in this list of the last occurrence
of the specified element, or -1 if the list does not contain this
element.
rin
Object[] toArray() It is used to return an array containing all of the elements in
this list in the correct order.
ee
Object[] toArray It is used to return an array containing all of the elements in
(Object[] a) this list in the correct order.
gin
boolean add(Object o) It is used to append the specified element to the end of a list.
boolean addAll(int index, It is used to insert all of the elements in the specified
Collection c) collection into this list, starting at the specified position.
En
Object clone() It is used to return a shallow copy of an ArrayList.

int indexOf(Object o) It is used to return the index in this list of the first occurrence
of the specified element, or -1 if the List does not contain this
arn
element.
void trimToSize() It is used to trim the capacity of this ArrayList instance to be
the list’s current size.
Le
import java.util.*;
class Arraylist_example{
w.

ww
ArrayList<String> a1=new ArrayList<String>();

a1.add(“Bala”);
a1.add(“Mala”);
a1.add(“Vijay”);
ArrayList<String> a2=new ArrayList<String>();
a2.add(“kala”);
a2.add(“Banu”);
a1.addAll(a2);
Iterator itr=a1.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
}
n
}
g.i
2.12 java strIng
In general string is a sequence of characters. String is an object that represents a sequence
of characters. The java.lang.String class is used to create string object. In java, string is basi-
rin
cally an object that represents sequence of char values. An array of characters works same as
java string. For example:
ee
java string class provides a lot of methods to perform operations on string such as com-
pare(), concat(), equals(), split(), length(), replace(), compareTo(), intern(), substring() etc.
gin
The java.lang.String class implements Serializable, Comparable and CharSequence in-

terfaces. The CharSequence interface is used to represent sequence of characters. It is imple-
mented by String, StringBuffer and StringBuilder classes. It means can create string in java
En
by using these 3 classes.

The string objects can be created using two ways.
arn
By String literal
2. By new Keyword
string literal
Le
Java String literal is created by using double quotes. For Example:

1. String s=”welcome”;
w.
Each time you create a string literal, the JVM checks the string constant pool first. If the
string already exists in the pool, a reference to the pooled instance is returned. If string doesn’t
ww
exist in the pool, a new string instance is created and placed in the pool. For example:
String s1=”Welcome”;
String s2=”Welcome”;
In the above example only one object will be created. Firstly JVM will not find any string
object with the value “Welcome” in string constant pool, so it will create a new object. After
that it will find the string with the value “Welcome” in the pool, it will not create new object
but will return the reference to the same instance. To make Java more memory efficient (be-
cause no new objects are created if it exists already in string constant pool).
2. by new keyword
String s=new String(“Welcome”);
In such case, JVM will create a new string object in normal (non pool) heap memory and
the literal “Welcome” will be placed in the string constant pool. The variable s will refer to
the object in heap (non pool).
The java String is immutable i.e. it cannot be changed. Whenever we change any string,
a new instance is created. For mutable string, you can use StringBuffer and StringBuilder
classes.
n
The following program explains the creation of strings
g.i
public class String_Example{
rin
String s1=”java”;
char c[]={‘s’,’t’,’r’,’i’,’n’,’g’};
ee
String s2=new String(c);
gin
String s3=new String(“example”);

System.out.println(s1);
En
}}
arn
java string class methods

The java.lang.String class provides many useful methods to perform operations on se-
Le
quence of char values.

Method description
w.
char charAt(int index) returns char value for the particular index
int length() returns string length
ww
static String format(String format, returns formatted string

Object... args)
static String format(Locale l, String returns formatted string with given locale
format, Object... args)
String substring(int beginIndex) returns substring for given begin index
String substring(int beginIndex, int returns substring for given begin index and
endIndex) end index
boolean contains(CharSequence s) returns true or false after matching the se-
quence of char value
static String join(CharSequence delim- returns a joined string

iter, CharSequence... elements)
boolean equals(Object another) checks the equality of string with object
boolean isEmpty() checks if string is empty
String concat(String str) concatinates specified string
String replace(char old, char new) replaces all occurrences of specified char
value
String replace(CharSequence old, Char- replaces all occurrences of specified CharSe-
n
Sequence new) quence
g.i
static String equalsIgnoreCase(String compares another string. It doesn’t check
another) case.
String[] split(String regex) returns splitted string matching regex
rin
String[] split(String regex, int limit) returns splitted string matching regex and
limit
ee
String intern() returns interned string
int indexOf(int ch) returns specified char value index
gin
int indexOf(int ch, int fromIndex) returns specified char value index starting
with given index
int indexOf(String substring) returns specified substring index
En
int indexOf(String substring, int fro- returns specified substring index starting
mIndex) with given index
String toLowerCase() returns string in lowercase.
arn
String toLowerCase(Locale l) returns string in lowercase using specified

locale.
String toUpperCase() returns string in uppercase.
Le
String toUpperCase(Locale l) returns string in uppercase using specified

locale.
String trim() removes beginning and ending spaces of this
w.
string.
static String valueOf(int value) converts given type into string. It is over-
ww
loaded
The following program is an example for String concat function:
class string_method{
String s=”Java”;
s=s.concat(“ Programming”);
System.out.println(s);
}
}
Output:
Java Programming
n
g.i
rin
ee
gin
En
arn
Le
w.
ww
Exception Handling and I/O  3.1
UNIT - 3
EXCEPTION HANDLING AND I/O
n
3.1 ExcEptions
g.i
An exception is an unexpected event, which may occur during the execution of a program
(at run time), to disrupt the normal flow of the program’s instructions. This leads to the abnor-
rin
mal termination of the program, which is not always recommended.
Therefore, these exceptions are needed to be handled. The exception handling in java is
one of the powerful mechanisms to handle the runtime errors so that normal flow of the ap-
ee
plication can be maintained.
An exception may occur due to the following reasons. They are.
gin
• Invalid data as input.

• Network connection may be disturbed in the middle of communications
En
• JVM may run out of memory.

• File cannot be found/opened.
arn
These exceptions are caused by user error, programmer error, and physical resources.
Based on these, the exceptions can be classified into three categories.
Le
• Checked exceptions − A checked exception is an exception that occurs at the compile

time, also called as compile time (static time) exceptions. These exceptions cannot
be ignored at the time of compilation. So, the programmer should handle these
w.
exceptions.
• Unchecked exceptions − An unchecked exception is an exception that occurs at run
ww
time, also called as Runtime Exceptions. These include programming bugs, such as
logic errors or improper use of an API. Runtime exceptions are ignored at the time of
compilation.
• Errors − Errors are not exceptions, but problems may arise beyond the control of the
user or the programmer. Errors are typically ignored in your code because you can
rarely do anything about an error. For example, if a stack overflow occurs, an error
will arise. They are also ignored at the time of compilation.
• Error: An Error indicates serious problem that a reasonable application should not
try to catch.
• Exception: Exception indicates conditions that a reasonable application might try to
catch.
3.2 ExcEption HiERaRcHy
The java.lang.Exception class is the base class for all exception classes. All exception and
errors types are sub classes of class Throwable, which is base class of hierarchy. One branch
is headed by Exception. This class is used for exceptional conditions that user programs
n
should catch. NullPointerException is an example of such an exception. Another branch, Er-
g.i
ror are used by the Java run-time system(JVM) to indicate errors having to do with the run-
time environment itself(JRE). StackOverflowError is an example of such an error.
rin
Errors are abnormal conditions that happen in case of severe failures, these are not han-
dled by the Java programs. Errors are generated to indicate errors generated by the runtime
environment. Example: JVM is out of memory. Normally, programs cannot recover from
ee
errors.
The Exception class has two main subclasses: IOException class and RuntimeException
gin
Class.
En
arn
Le
w.
ww
Exceptions Methods
Method Description
public String getMessage() Returns a detailed message about the exception that has
occurred. This message is initialized in the Throwable
constructor.
public Throwable getCause() Returns the cause of the exception as represented by a
Throwable object.
public String toString() Returns the name of the class concatenated with the re-
n
sult of getMessage().
g.i
public void printStackTrace() Prints the result of toString() along with the stack trace to
System.err, the error output stream.
public StackTraceElement [] Returns an array containing each element on the stack
rin
trace. The element at index 0 represents the top of the
getStackTrace()
call stack, and the last element in the array represents the
method at the bottom of the call stack.
ee
public Throwable Fills the stack trace of this Throwable object with the
current stack trace, adding to any previous information
gin
fillInStackTrace()
in the stack trace.
Exception handling in java uses the following Keywords
En
1. try
2. catch
arn
3. finally
4. throw
5. throws
Le
The try/catch block is used as follows:

try {
w.
// block of code to monitor for errors

// the code you think can raise an exception
ww
}
catch (ExceptionType1 exOb) {
// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb) {
// exception handler for ExceptionType

}
// optional
finally {
// block of code to be executed after try block ends
}
n
throwing and catching exceptions
g.i
Catching Exceptions
A method catches an exception using a combination of the try and catch keywords. The
program code that may generate an exception should be placed inside the try/catch block. The
rin
syntax for try/catch is depicted as below−
Syntax
ee
try {
// Protected code
gin
} catch (ExceptionName e1) {

// Catch block
En
}
The code which is prone to exceptions is placed in the try block. When an exception oc-
arn
curs, that exception is handled by catch block associated with it. Every try block should be
immediately followed either by a catch block or finally block.
A catch statement involves declaring the type of exception that might be tried to catch. If
Le
an exception occurs, then the catch block (or blocks) which follow the try block is checked.
If the type of exception that occurred is listed in a catch block, the exception is passed to the
catch block similar to an argument that is passed into a method parameter.
w.
To illustrate the try-catch blocks the following program is developed.

class Exception_example {
ww

{
int a,b;
try { // monitor a block of code.
a = 0;
b = 10 / a; //raises the arithmetic exception
System.out.println(“Try block.”);
}
catch (ArithmeticException e)
{ // catch divide-by-zero error
System.out.println(“Division by zero.”);
}
n
System.out.println(“After try/catch block.”);
g.i
}
}
rin
Output:
Division by zero. ee
After try/catch block.
Multiple catch clauses
gin
In some cases, more than one exception could be raised by a single piece of code. To
handle this multiple exceptions, two or more catch clauses can be specified. Here, each catch
block catches different type of exception. When an exception is thrown, each catch statement
En
is inspected in order, and the first one whose type matches that of the exception is executed.
After one catch statement executes, the others are bypassed, and execution continues after the
try/catch block. The following example traps two different exception types:
arn
class MultiCatch_Example {
Le
try {
int a,b;
w.
a = args.length;
System.out.println(“a = “ + a);
ww
b = 10 / a; //may cause division-by-zero error

int arr[] = { 10,20 };
c[5] =100;
}
catch(ArithmeticException e)
{
System.out.println(“Divide by 0: “ + e);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(“Array index oob: “ + e);
}
n
System.out.println(“After try/catch blocks.”);
g.i
}
}
rin
Here is the output generated by the execution of the program in both ways:
C:\>java MultiCatch_Example ee
a=0
Divide by 0: java.lang.ArithmeticException: / by zero
gin
After try/catch blocks.

C:\>java MultiCatch_Example arg1
En
a=1
Array index oob: java.lang.ArrayIndexOutOfBoundsException:5
arn
After try/catch blocks.

While the multiple catch statements is used, it is important to remember that exception
subclasses must come before their superclasses. A catch statement which uses a superclass
Le
will catch exceptions of that type plus any of its subclasses. Thus, a subclass would never
be reached if it came after its superclass. And also, in Java, unreachable code is an error. For
example, consider the following program:
w.
class MultiCatch_Example {
ww
try {
int a,b;
a = args.length;
System.out.println(“a = “ + a);
b = 10 / a; //may cause division-by-zero error
int arr[] = { 10,20 };

n
g.i
rin
ee
gin
En
arn
Le
w.
ww
catch(Exception e)
{
}
} catch(Exception
e) {
}
n
....
g.i
The following program is an example for Nested try statements.
class Nestedtry_Example{
rin
try{ ee
try{
System.out.println(“division”);
gin
int a,b;
a=0;
En
b =10/a;
}
arn
catch(ArithmeticException e)
{
System.out.println(e);
Le
}
try
w.
{
ww
int a[]=new int[5];

a[6]=3;
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(e);
}
System.out.println(“other statement);
}
catch(Exception e)
{
n
System.out.println(“handeled”);}
g.i
System.out.println(“normal flow..”);
}
rin
}
throw keyword ee
The Java throw keyword is used to explicitly throw an exception. The general form of
throw is shown below:
gin
throw ThrowableInstance;
Here, ThrowableInstance must be an object of type Throwable or a subclass of Throw-
able. Primitive types, such as int or char, as well as non-Throwable classes, such as String and
En
Object, cannot be used as exceptions.

There are two ways to obtain a Throwable object:
arn
using a parameter in a catch clause

2. creating one with the new operator.
The following program explains the use of throw keyword.
Le
public class TestThrow1{

static void validate(int age){
w.
try{
ww
if(age<18)
throw new ArithmeticException(“not valid”);
else
System.out.println(“welcome to vote”);
}
Catch(ArithmeticException e)
{
System.out.println(“Caught inside ArithmeticExceptions.”);

throw e; // rethrow the exception
}
}
try{
n
validate(13);
g.i
}
Catch(ArithmeticException e)
rin
{
System.out.println(“ReCaught ArithmeticExceptions.”);
ee
}
}
gin
}
The flow of execution stops immediately after the throw statement and any subsequent
statements that are not executed. The nearest enclosing try block is inspected to see if it has
En
a catch statement that matches the type of exception. If it does find a match, control is trans-
ferred to that statement. If not, then the next enclosing try statement is inspected, and so on.
If no matching catch is found, then the default exception handler halts the program and prints
arn
the stack trace.

the throws/throw Keywords
Le
If a method does not handle a checked exception, the method must be declared using
the throws keyword. The throws keyword appears at the end of a method’s signature.
w.
The difference between throws and throw keywords is that, throws is used to postpone the
handling of a checked exception and throw is used to invoke an exception explicitly.
The following method declares that it throws a Remote Exception −
ww
Example
import java.io.*;
public class throw_Example1 {
public void function(int a) throws RemoteException {
// Method implementation
throw new RemoteException();
} // Remainder of class definition

}
A method can declare that it throws more than one exception, in which case the excep-
tions are declared in a list separated by commas. For example, the following method declares
that it throws a RemoteException and an ArithmeticException −
import java.io.*;
public class throw_Example2 {
n
public void function(int a) throws RemoteException,ArithmeticException {
g.i
// Method implementation
}
rin
// Remainder of class definition
}
ee
the Finally Block
The finally block follows a try block or a catch block. A finally block of code always ex-
gin
ecutes, irrespective of the occurrence of an Exception. A finally block appears at the end of
the catch blocks that follows the below syntax.
Syntax
En
try {
// Protected code
arn
} catch (ExceptionType1 e1) {

// Catch block
Le
} catch (ExceptionType2 e2) {

// Catch block
w.
}
finally {
ww
// The finally block always executes.

}
Example
public class Finally_Example {
try {
int a,b;
a=0;
b=10/a;
} catch (ArithmeticException e) {
System.out.println(“Exception thrown :” + e);
}finally {
n
System.out.println(“The finally block is executed”);
g.i
}
}
rin
}
points to remember: ee
• A catch clause cannot exist without a try statement.
• It is not compulsory to have finally clauses whenever a try/catch block is present.
gin
• The try block cannot be present without either catch clause or finally clause.
• Any code cannot be present in between the try, catch, finally blocks.
En
3.3 Built-in ExcEptions

Built-in exceptions are the exceptions which are available in Java libraries. These excep-
tions are suitable to explain certain error situations. Below is the list of important built-in
arn
exceptions in Java.
Exceptions Description
Le
Arithmetic Exception It is thrown when an exceptional condition has oc-

curred in an arithmetic operation.
w.
Array Index Out Of Bound It is thrown to indicate that an array has been accessed
Exception with an illegal index. The index is either negative or
greater than or equal to the size of the array.
ww
ClassNotFoundException This Exception is raised when we try to access a class

whose definition is not found.
FileNotFoundException This Exception is raised when a file is not accessible
or does not open.
IOException It is thrown when an input-output operation failed or
interrupted.
InterruptedException It is thrown when a thread is waiting, sleeping, or do-
ing some processing, and it is interrupted.
NoSuchFieldException It is thrown when a class does not contain the field (or
variable) specified.
NoSuchMethodException It is thrown when accessing a method which is not
found.
NullPointerException This exception is raised when referring to the members
of a null object. Null represents nothing.
NumberFormatException This exception is raised when a method could not con-
vert a string into a numeric format.
n
RuntimeException This represents any exception which occurs during
g.i
runtime.
StringIndexOutOfBoundsEx- It is thrown by String class methods to indicate that an
ception index is either negative than the size of the string
rin
The following Java program explains NumberFormatException
class NumberFormat_Example
ee
{
gin
{
try {
En
int num = Integer.parseInt (“hello”) ;

System.out.println(num);
arn
}
catch(NumberFormatException e) {
Le
System.out.println(“Number format exception”);

}
w.
}
}
ww
The following Java program explains StackOverflowError exception.

class Example {
{
fun1();
}
public static void fun1()

{
fun2();
}
public static void fun2()
{
n
fun1();
g.i
}
}
rin
Output:
Exception in thread “main” java.lang.StackOverflowError
ee
at Example.fun2(File.java:14)
at Example.fun1(File.java:10)
gin
3.4 usER DEFinED ExcEption in Java

Java allows the user to create their own exception class which is derived from built-
in class Exception. The Exception class inherits all the methods from the class Throwable.
En
The Throwable class is the superclass of all errors and exceptions in the Java language. It
contains a snapshot of the execution stack of its thread at the time it was created. It can also
contain a message string that gives more information about the error.
arn
• The Exception class is defined in java.lang package.

• User defined exception class must inherit Exception class.
Le
The user defined exception can be thrown using throw keyword.

w.
class User_defined_name extends Exception{

………..
ww
}
Some of the methods defined by Throwable are shown in below table.
Methods Description
Throwable fillInStackTrace( ) Fills in the execution stack trace and returns a
Throwable object.
String getLocalizedMessage() Returns a localized description of the exception.
String getMessage() Returns a description of the exception.
void printStackTrace( ) Displays the stack trace.

String toString( ) Returns a String object containing a description
of the Exception.
StackTraceElement[ ]get Returns an array that contains the stack trace, one
StackTrace( ) element at a time, as an array of StackTraceEle-
ment.
two commonly used constructors of Exception class are:
n
• Exception() - Constructs a new exception with null as its detail message.
g.i
• Exception(String message) - Constructs a new exception with the specified detail
message.
Example:
rin
//creating a user-defined exception class derived from Exception class
public class MyException extends Exception
ee
{
gin
public String toString(){ // overriding toString() method
return “User-Defined Exception”;
}
En

MyException obj= new MyException();
arn
try
{
Le
throw new MyException(); // customized exception is raised

}
w.
/*Printing object e makes a call to toString() method which

catch(MyException e)
returns String error message*/
{
ww
System.out.println(“Exception handled - “+ e);

}
}
}
Sample Output:
Exception handled - User-Defined Exception
In the above example, a custom defined exception class MyException is created by inher-
iting it from Exception class. The toString() method is overridden to display the customized
method on catch. The MyException is raised using the throw keyword.
Example:
Program to create user defined exception that test for odd numbers.
import java.util.Scanner;
class OddNumberException extends Exception
n
{
g.i
OddNumberException() //default constructor
{
rin
super(“Odd number exception”);
}
ee
OddNumberException(String msg) //parameterized constructor
{
gin
super(msg);
}
En
}
public class UserdefinedExceptionDemo{
arn

{
Le
int num;
Scanner Sc = new Scanner(System.in); // create Scanner object to read input
w.
System.out.println(“Enter a number : “);

num = Integer.parseInt(Sc.nextLine());
ww
try
{
if(num%2 != 0) // test for odd number
throw(new OddNumberException()); // raise the exception if number is odd
else
System.out.println(num + “ is an even number”);
}
catch(OddNumberException Ex)
{
System.out.print(“\n\tError : “ + Ex.getMessage());
}
}
}
n
Sample Output1:
g.i
Enter a number : 11
Error : Odd number exception
rin
Sample Output2:
10 is an even number ee
Odd Number Exception class is derived from the Exception class. To implement user
defined exception we need to throw an exception object explicitly. In the above example, If
the value of num variable is odd, then the throw keyword will raise the user defined exception
gin
and the catch block will get execute.

3.5 cHainED ExcEptions
En
Chained Exceptions allows to relate one exception with another exception, i.e one ex-
ception describes cause of another exception. For example, consider a situation in which a
method throws an ArithmeticException because of an attempt to divide by zero but the actual
arn
cause of exception was an I/O error which caused the divisor to be zero. The method will
throw only ArithmeticException to the caller. So the caller would not come to know about the
actual cause of exception. Chained Exception is used in such type of situations.
Le
throwable constructors that supports chained exceptions are:

1. Throwable(Throwable cause) :- Where cause is the exception that causes the current
w.
exception.
Throwable(String msg, Throwable cause) :- Where msg is the exception message and
cause is the exception that causes the current exception.
ww
throwable methods that supports chained exceptions are:

1. getCause() method :- This method returns actual cause of an exception.
2. initCause(Throwable cause) method :- This method sets the cause for the calling ex-
ception.
Example:
import java.io.IOException;
public class ChainedException
{
public static void divide(int a, int b)
{
if(b==0)
n
{
g.i
ArithmeticException ae = new ArithmeticException(“top layer”);
ae.initCause( new IOException(“cause”) );
rin
throw ae;
}
ee
else
gin
{
System.out.println(a/b);
}
En
}
arn
{
try {
Le
divide(5, 0);
}
w.
catch(ArithmeticException ae) {
System.out.println( “caught : “ +ae);
ww
System.out.println(“actual cause: “+ae.getCause());

}
}
}
Sample Output:
caught : java.lang.ArithmeticException: top layer
actual cause: java.io.IOException: cause
In this example, the top-level exception is ArithmeticException. To it is added a cause

exception, IOException. When the exception is thrown out of divide( ), it is caught by main(
). There, the top-level exception is displayed, followed by the underlying exception, which is
obtained by calling getCause( ).
3.6 stacK tRacE ElEMEnt
The StackTraceElement class element represents a single stack frame which is a stack
trace when an exception occurs. Extracting stack trace from an exception could provide use-
ful information such as class name, method name, file name, and the source-code line num-
n
ber. The getStackTrace( ) method of the Throwable class returns an array of StackTraceEle-
g.i
ments.
stacktraceElement class constructor
rin
StackTraceElement(String declaringClass, String methodName, String fileName, int
lineNumber)
This creates a stack trace element representing the specified execution point.
ee
Stack Trace Element class methods
gin
Method Description
boolean equals(Object obj) Returns true if the invoking StackTraceElement is the
same as the one passed in obj. Otherwise, it returns false.
En
String getClassName() Returns the class name of the execution point

String getFileName( ) Returns the filename of the execution point
int getLineNumber( ) Returns the source-code line number of the execution
arn
point
String getMethodName( ) Returns the method name of the execution point
Le
String toString( ) Returns the String equivalent of the invoking sequence

Example:
w.
public class StackTraceEx{

ww
try{
throw new RuntimeException(“go”); //raising an runtime exception
}
catch(Exception e){
System.out.println(“Printing stack trace:”);
//create array of stack trace elements
final StackTraceElement[] stackTrace = e.getStackTrace();
for (StackTraceElement s : stackTrace) {

System.out.println(“\tat “ + s.getClassName() + “.” + s.getMethodName()
+ “(“ + s.getFileName() + “:” + s.getLineNumber() + “)”);
}
}
}
n
}
g.i
Sample Output:
Printing stack trace:
rin
at StackTraceEx.main(StackTraceEx.java:5)
3.7 input/output Basics ee
Java I/O (Input and Output) is used to process the input and produce the output. Java uses
the concept of stream to make I/O operation fast. All the classes required for input and output
operations are declared in java.io package.
gin
A stream can be defined as a sequence of data. The Input Stream is used to read data from
a source and the OutputStream is used for writing data to a destination.
En
arn
Le
w.
Java defines two types of streams. They are,

ww
1. Byte Stream : It is used for handling input and output of 8 bit bytes. The frequently
used classes are FileInputStream and FileOutputStream.
2. Character Stream : It is used for handling input and output of characters. Charac-
ter stream uses 16 bit Unicode. The frequently used classes are FileReader and File
Writer.
Byte stream classes
The byte stream classes are topped by two abstract classes InputStream and Output-
Stream.
n
inputstream class
g.i
InputStream class is an abstract class. It is the super class of all classes representing an
input stream of bytes.
rin
• The Input Strearn class is the superclass for all byte-oriented input stream classes.
• All the methods of this class throw an IOException.
• Being an abstract class, the InputStrearn class cannot be instantiated hence, its
ee
subclasses are used
gin
Some of the Input Stream classes are listed below
class Description
Contains methods to read bytes from the buffer (memory
En
Buffered Input Stream

area)
Byte Array Input Contains methods to read bytes from a byte array
arn
Stream
Data Input Stream Contains methods to read Java primitive data types
Contains methods to read bytes from a file
Le
File Input Stream

Filter Input Stream Contains methods to read bytes from other input streams
which it uses as its basic source of data
w.
Object Input Stream Contains methods to read objects

ww
Piped Input Stream Contains methods to read from a piped output stream. A
piped input stream must be connected to a piped output
stream
Sequence Input Stream Contains methods to concatenate multiple input streams and
then read from the combined stream
Some of the useful methods of InputStream are listed below.

Method Description
public abstract int read() Reads the next byte of data from the input stream. It returns -1
throws IOException at the end of file.
public int available() Returns an estimate of the number of bytes that can be read
throws IOException from the current input stream.
public void close() Close the current input stream
throws IOException
n
g.i
rin
ee
gin
En
Fig. InputStream class Hierarchy

outputstream class
arn
OutputStream class is an abstract class. It is the super class of all classes representing an
output stream of bytes. An output stream accepts output bytes and sends them to some sink.
Le
class Description
Buffered Output Stream Contains methods to write bytes into the buffer
w.
Byte Array Output Stream Contains methods to write bytes into a byte array
Data Output Stream Contains methods to write Java primitive data types
ww
File Output Stream Contains methods to write bytes to a file

Filter Output Stream Contains methods to write to other output streams
Object Output Stream Contains methods to write objects
Piped Output Stream Contains methods to write to a piped output stream
Print Stream Contains methods to print Java primitive data types
Some of the useful methods of OutputStream class are listed below.

Method Description
public void write(int)throws Write a byte to the current output stream.
IO Exception
public void write(byte[]) Write an array of byte to the current output
throws IO Exception stream.
public void flush()throws Flushes the current output stream.
n
IO Exception
g.i
public void close()throws close the current output stream.
IO Exception
rin
ee
gin
En
arn
Fig. OutputStream class Hierarchy

character stream classes
The character stream classes are also topped by two abstract classes Reader and Writer.
Le
w.
ww
Some important Character stream reader classes are listed below.

Reader classes are used to read 16-bit unicode characters from the input stream.
• The Reader class is the superclass for all character-oriented input stream classes.
• All the methods of this class throw an IO Exception.
• Being an abstract class, the Reader class cannot be instantiated hence its subclasses

Reader class Description

BufferedReader Contains methods to read characters from the buffer
FileReader Contains methods to read from a file
InputStreamReader Contains methods to convert bytes to characters
Reader Abstract class that describes character stream input
The Reader class defines various methods to perform reading operations on data of an
input stream. Some of these methods are listed below.
n
Method Description
g.i
int read() returns the integral representation of the next available char-
acter of input. It returns -1 when end of file is encountered
int read (char buffer []) attempts to read buffer. length characters into the buffer and
rin
returns the total number of characters successfully read. It re-
turns -I when end of file is encountered
int read (char buffer [], attempts to read ‘nChars’ characters into the buffer starting
ee
int loc, int nChars) at buffer [loc] and returns the total number of characters suc-
cessfully read. It returns -1 when end of file is encountered
gin
long skip (long nChars) skips ‘nChars’ characters of the input stream and returns the
number of actually skipped characters
void close () closes the input source. If an attempt is made to read even
En
after closing the stream then it generates IOException

Some important Character stream writer classes are listed below.
arn
Writer classes are used to write 16-bit Unicode characters onto an outputstream.
• The Writer class is the superclass for all character-oriented output stream classes .
• All the methods of this class throw an IOException.
Le
• Being an abstract class, the Writer class cannot be instantiated hence, its subclasses

w.
Writer class Description

BufferedWriter Contains methods to write characters to a buffer
ww
FileWriter Contains methods to write to a file

OutputStreamReader Contains methods to convert from bytes to character
PrintWriter Output stream that contains print( ) and println( )
Writer Abstract class that describes character stream output
The Writer class defines various methods to perform writing operations on output stream.
Some of these methods are listed below.
Method Description
void write () writes data to the output stream
void write (int i) Writes a single character to the output stream
void write (char buffer [] ) writes an array of characters to the output stream
void write(char buffer [],int writes ‘n’ characters from the buffer starting at
loc, int nChars) buffer [loc] to the output stream
void close () closes the output stream. If an attempt is made to
perform writing operation even after closing the stream
n
then it generates IOException
g.i
void flush () flushes the output stream and writes the waiting
buffered output characters
rin
Predefined Streams
Java provides the following three standard streams −
• Standard Input − refers to the standard InputStream which is the keyboard by default.
ee
This is used to feed the data to user’s program and represented as system.in.
gin
• Standard Output − refers to the standard OutputStream by default,this is console and
represented as system.out.
• Standard Error − This is used to output the error data produced by the user’s program
En
and usually a computer screen is used for standard error stream and represented
as system.err.
The System class is defined in java.lang package. It contains three predefined stream vari-
arn
ables: in, out, err. These are declared as public and static within the system.
3.8 REaDing consolE input
Le
Reading characters
The read() method is used with BufferedReader object to read characters. As this function
returns integer type value has we need to use typecasting to convert it into char type.
w.
Syntax:
ww
int read() throws IOException

Example:
Read character from keyboard
import java.io.*;
class Main
{
public static void main( String args[]) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
char c;
System.out.println(“Enter characters, @ to quit”);
do{
c = (char)br.read(); //Reading character
n
System.out.println(c);
g.i
}while(c!=’@’);
}
rin
}
Sample Output: ee
Enter characters, @ to quit
abcd23@
gin
a
b
En
c
d
arn
2
3
@
Le
Example:
Read string from keyboard
w.
The readLine() function with BufferedReader class’s object is used to read string from
keyboard.
ww
Syntax:
String readLine() throws IOException
Example :
import java.io.*;
public class Main{
public static void main(String args[])throws Exception{
InputStreamReader r=new InputStreamReader(System.in);

BufferedReader br=new BufferedReader(r);
System.out.println(“Enter your name”);
String name=br.readLine();
System.out.println(“Welcome “+name);
}
n
}
g.i
Sample Output :
Enter your name
rin
Priya
Welcome Priya ee
3.9 WRiting consolE output
• Console output is most easily accomplished with print( ) and println( ). These methods
gin
are defined by the class PrintStream (which is the type of object referenced by System.
out).
• Since PrintStream is an output stream derived from OutputStream, it also implements
En
the low-level method write( ).

• So, write( ) can be used to write to the console.
arn
Syntax:
void write(int byteval)
This method writes to the stream the byte specified by byteval.
Le
The following java program uses write( ) to output the character “A” followed by a new-
line to the screen:
w.
// Demonstrate System.out.write().
class WriteDemo
ww
{
{
int b;
b = ‘A’;
System.out.write(b);
System.out.write(‘\n’);
}
}
3.10tHE pRintWRitER class
• Although using System.out to write to the console is acceptable, its use is recommended
mostly for debugging purposes or for sample programs.
n
• For real-world programs, the recommended method of writing to the console when
g.i
using Java is through a PrintWriter stream.
• PrintWriter is one of the character-based classes.
rin
• Using a character-based class for console output makes it easier to internationalize
our program.
ee
• PrintWriter defines several constructors.
Syntax:
gin
PrintWriter(OutputStream outputStream, boolean flushOnNewline)

Here,
En
• output Stream is an object of type OutputStream

• flushOnNewline controls whether Java flushes the output stream every time a println(
) method is called.
arn
• If flushOnNewline is true, flushing automatically takes place. If false, flushing is not

automatic.
Le
• PrintWriter supports the print( ) and println( ) methods for all types including
Object.
w.
• Thus, we can use these methods in the same way as they have been used with System.
out.
• If an argument is not a simple type, the PrintWriter methods call the object’s toString(
ww
) method and then print the result.

• To write to the console by using a PrintWriter, specify System.out for the output
stream and flush the stream after each newline.
For example, the following code creates a PrintWriter that is connected to console output:
PrintWriter pw = new PrintWriter(System.out, true);
The following application illustrates using a PrintWriter to handle console output:

// Demonstrate PrintWriter
import java.io.*;
public class PrintWriterDemo
{
n
{
g.i
PrintWriter pw = new PrintWriter(System.out, true);
pw.println(“This is a string”);
rin
int i = -7;
pw.println(i); ee
double d = 4.5e-7;
pw.println(d);
gin
}
}
En
Sample Output:
This is a string
arn
-7
4.5E-7
3.11 REaDing anD WRiting FilEs
Le
In Java, all files are byte-oriented, and Java provides methods to read and write bytes from
and to a file.
w.
Two of the most often-used stream classes are FileInputStream and FileOutputStream,
which create byte streams linked to files.
ww
File input stream

This stream is used for reading data from the files. Objects can be created using the key-
word new and there are several types of constructors available.
The two constructors which can be used to create a FileInputStream object:
Following constructor takes a file name as a string to create an input stream object to
read the file:
InputStream f = new FileInputStream(“filename “);
Following constructor takes a file object to create an input stream object to read the
file. First we create a file object using File() method as follows:
File f = new File(“C:/java/hello”);
InputStream f = new FileInputStream(f);
Methods to read to stream or to do other operations on the stream.
Method Description
public void close() throws • Closes the file output stream.
n
IOException{}
• Releases any system resources associated with the
g.i
file.
• Throws an IOException.
rin
protected void finalize()throws • Ceans up the connection to the file.
IOException {}
• Ensures that the close method of this file output
ee
stream is called when there are no more references
to this stream.
gin
public int read(int r)throws • Reads the specified byte of data from the
IOException{} InputStream.
En
• Returns an int.
• Returns the next byte of data and -1 will be returned
if it’s the end of the file.
arn
public int read(byte[] r) throws • Reads r.length bytes from the input stream into an
IOException{} array.
Le
• Returns the total number of bytes read. If it is the

end of the file, -1 will be returned.
public int available() throws • Gives the number of bytes that can be read from
w.
IOException{} this file input stream.

• Returns an int.
ww
File output stream

FileOutputStream is used to create a file and write data into it.
The stream would create a file, if it doesn’t already exist, before opening it for output.
The two constructors which can be used to create a FileOutputStream object:
Following constructor takes a file name as a string to create an input stream object to
write the file:
OutputStream f = new FileOutputStream(“filename”);
Following constructor takes a file object to create an output stream object to write the
file. First, we create a file object using File() method as follows:
File f = new File(“C:/java/hello”);
OutputStream f = new FileOutputStream(f);
Methods to write to stream or to do other operations on the stream
Method Description
public void close() throws IO- • Closes the file output stream.
n
Exception{}
• Releases any system resources associated with the
g.i
file.
rin
protected void finalize()throws • Cleans up the connection to the file.
IOException {}
• Ensures that the close method of this file output
ee
stream is called when there are no more references
to this stream.
gin
public void write(int w)throws • Writes the specified byte to the output stream.
IOException{}
public void write(byte[] w) • Writes w.length bytes from the mentioned byte
En
array to the OutputStream.

Following code demonstrates the use of InputStream and OutputStream.
arn
import java.io.*;
public class fileStreamTest
Le
{
w.
{
try
ww
{
byte bWrite [] = {11,21,3,40,5};
OutputStream os = new FileOutputStream(“test.txt”);
for(int x = 0; x < bWrite.length ; x++)
{
os.write( bWrite[x] ); // writes the bytes

}
os.close();
InputStream is = new FileInputStream(“test.txt”);
int size = is.available();
for(int i = 0; i < size; i++)
n
{
g.i
System.out.print((char)is.read() + “ “);
}
rin
is.close();
} ee
catch (IOException e)
{
gin
System.out.print(“Exception”);
}
En
}
}
arn
The above code creates a file named test.txt and writes given numbers in binary format.
The same will be displayed as output on the stdout screen.
Le
w.
ww
Multi Threading and Generic Programming  4.1
UNIT-4
MULTI THREADING AND GENERIC PROGRAMMING
n
4.1 Multithreading and Multi-tasking
g.i
In programming, there are two main ways to improve the throughput of a program:
i) by using multi-threading
rin
ii) by using multitasking
Both these methods take advantage of parallelism to efficiently utilize the power of CPU
ee
and improve the throughput of program.
difference between multithreading and multi-tasking
gin
1. The basic difference between multitasking and multithreading is that in multitasking,

the system allows executing multiple programs and tasks at the same time, whereas,
in multithreading, the system executes multiple threads of the same or different pro-
En
cesses at the same time.

Multi-threading is more granular than multi-tasking. In multi-tasking, CPU switches
arn
between multiple programs to complete their execution in real time, while in multi-
threading CPU switches between multiple threads of the same program. Switching
between multiple processes has more context switching cost than switching between
multiple threads of the same program.
Le
Processes are heavyweight as compared to threads. They require their own address
space, which means multi-tasking is heavy compared to multithreading.
w.
Multitasking allocates separate memory and resources for each process/program

whereas, in multithreading threads belonging to the same process shares the same
ww
memory and resources as that of the process.
Comparison between multithreading and multi-tasking

Parameter Multi tasking Multi threading
Basic Multitasking lets CPU to execute Multithreading lets CPU to execute
multiple tasks at the same time. multiple threads of a process simul-
taneously.
Switching In multitasking, CPU switches In multithreading, CPU switches
between programs frequently. between the threads frequently.
Memory and In multitasking, system has to In multithreading, system has to
n
Resource allocate separate memory and allocate memory to a process,
g.i
resources to each program that multiple threads of that process shares
CPU is executing. the same memory and resources
allocated to the process.
rin
Multitasking
Multitasking is when a single CPU performs several tasks (program, process, task,
ee
threads) at the same time. To perform multitasking, the CPU switches among these tasks
very frequently so that user can interact with each program simultaneously.
gin
In a multitasking operating system, several users can share the system simultaneously.
CPU rapidly switches among the tasks, so a little time is needed to switch from one user to the
next user. This puts an impression on a user that entire computer system is dedicated to him.
En
arn
Le
w.
ww
Figure: Multitasking
When several users are sharing a multitasking operating system, CPU scheduling and
multiprogramming makes it possible for each user to have at least a small portion of
Multitasking OS and let each user have at least one program in the memory for execution.
Multi threading
Multithreading is different from multitasking in a sense that multitasking allows mul-
tiple tasks at the same time, whereas, the Multithreading allows multiple threads of a single
task (program, process) to be processed by CPU at the same time.
A thread is a basic execution unit which has its own program counter, set of the register
and stack. But it shares the code, data, and file of the process to which it belongs. A process
can have multiple threads simultaneously, and the CPU switches among these threads so fre-
quently making an impression on the user that all threads are running simultaneously.
n
g.i
rin
ee
gin
En

arn
•
Le
• resource
sharing as threads belonging to the same process can
share code and data of the process and it allows a process to have multiple threads at
w.
the same time active in same address space.

• Creating a different process is costlier as the system has to allocate different memory
ww
and resources to each process, but creating threads is easy as it does not require
allocating separate memory and resources for threads of the same process.
4.2 thread lifeCyCle
A thread in Java at any point of time exists in any one of the following states. A thread lies
only in one of the shown states at any instant:
New
Runnable
Blocked
Waiting
Timed Waiting
Terminated
n
The following figure represents various states of a thread at any instant of time:
g.i
rin
ee
gin
En
arn
Le
Figure: Life Cycle of a thread

w.
1. New Thread:
• When a new thread is created, it is in the new state.
ww
• The thread has not yet started to run when thread is in this state.
• When a thread lies in the new state, it’s code is yet to be run and hasn’t started to
execute.
2. Runnable State:
• A thread that is ready to run is moved to runnable state.
• In this state, a thread might actually be running or it might be ready run at any instant
of time.
• It is the responsibility of the thread scheduler to give the thread, time to run.
• A multi-threaded program allocates a fixed amount of time to each individual thread.
Each and every thread runs for a short while and then pauses and relinquishes the CPU
to another thread, so that other threads can get a chance to run. When this happens,
all such threads that are ready to run, waiting for the CPU and the currently running
thread lies in runnable state.
3. Blocked/Waiting state:
• When a thread is temporarily inactive, then it’s in one of the following states:
n
○ Blocked
g.i
○ Waiting
rin
• For example, when a thread is waiting for I/O to complete, it lies in the blocked state.
It’s the responsibility of the thread scheduler to reactivate and schedule a blocked/
waiting thread.
ee
• A thread in this state cannot continue its execution any further until it is moved to
runnable state. Any thread in these states do not consume any CPU cycle.
gin
• A thread is in the blocked state when it tries to access a protected section of code that
is currently locked by some other thread. When the protected section is unlocked, the
schedule picks one of the threads which is blocked for that section and moves it to
En
the runnable state. A thread is in the waiting state when it waits for another thread on
a condition. When this condition is fulfilled, the scheduler is notified and the waiting
thread is moved to runnable state.
arn
• If a currently running thread is moved to blocked/waiting state, another thread in the

runnable state is scheduled by the thread scheduler to run. It is the responsibility of
thread scheduler to determine which thread to run.
Le
4. Timed Waiting:
• A thread lies in timed waiting state when it calls a method with a time out parameter.
w.
• A thread lies in this state until the timeout is completed or until a notification is
received.
ww
• For example, when a thread calls sleep or a conditional wait, it is moved to timed
waiting state.
5. Terminated State:
• A thread terminates because of either of the following reasons:
○ Because it exits normally. This happens when the code of thread has entirely
executed by the program.
○ Because there occurred some unusual erroneous event, like segmentation fault
or an unhandled exception.
• A thread that lies in terminated state does no longer consumes any cycles of CPU.
Creating threads
• Threading is a facility to allow multiple tasks to run concurrently within a single
process. Threads are independent, concurrent execution through a program, and each
thread has its own stack.
n
In Java, There are two ways to create a thread:
g.i
1) By extending Thread class.
2) By implementing Runnable interface.
rin
Java Thread Benefits
1. Java Threads are lightweight compared to processes as they take less time and re-
source to create a thread.
ee
Threads share their parent process data and code
gin
Context switching between threads is usually less expensive than between process-
es.
Thread intercommunication is relatively easy than process communication.
En
thread class:
Thread class provide constructors and methods to create and perform operations on a
arn
thread. Thread class extends Object class and implements Runnable interface.
Commonly used Constructors of thread class:
• Thread()
Le
• Thread(String name)
• Thread(Runnable r)
w.
• Thread(Runnable r, String name)

ww

is used to perform action for a thread.
starts the execution of the thread. JVM calls the run() method on
the thread.

waits for a thread to die.
waits for a thread to die for the specified mili-

changes the priority of the thread.

n
returns the reference of currently executing
g.i

rin

ee

gin

En

marks the thread as daemon or user thread.
arn

Le
tests if the current thread has been interrupted.

naming thread
w.
The Thread class provides methods to change and get the name of a thread. By default,
each thread has a name i.e. thread-0, thread-1 and so on. But we can change the name of the
ww
thread by using setName() method. The syntax of setName() and getName() methods are
given below:
public string getname(): is used to return the name of a thread.
public void setname(string name): is used to change the name of a thread.
extending thread
The first way to create a thread is to create a new class that extends Thread, and then to
create an instance of that class. The extending class must override the run( ) method, which
is the entry point for the new thread. It must also call start( ) to begin execution of the new
thread.
Sample java program that creates a new thread by extending Thread:
// Create a second thread by extending Thread
n
class NewThread extends Thread
g.i
{
NewThread()
rin
{ // Create a new, second thread
super(“Demo Thread”); ee
System.out.println(“Child thread: “ + this);
start(); // Start the thread
gin
}
// This is the entry point for the second thread.
En
public void run()

{
arn
try
{
for(int i = 5; i > 0; i--)
Le
{
System.out.println(“Child Thread: “ + i);
w.
Thread.sleep(500);
ww
}
}
catch (InterruptedException e)
{
System.out.println(“Child interrupted.”);
}
System.out.println(“Child thread is exiting”);
}
}
public class ExtendThread
{
{
n
new NewThread(); // create a new thread
g.i
try
{
rin
for(int i = 5; i > 0; i--)
{ ee
System.out.println(“Main Thread: “ + i);
Thread.sleep(1000);
gin
}
}
En
{
arn
System.out.println(“Main thread interrupted.”);

}
System.out.println(“Main thread is exiting.”);
Le
}
}
w.
Sample Output:
ww
(output may vary based on processor speed and task load)

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Child thread is exiting.
Main Thread: 2
Main Thread: 1
n
Main thread is exiting.
g.i
The child thread is created by instantiating an object of NewThread, which is derived
from Thread. The call to super( ) is inside NewThread. This invokes the following form of
the Thread constructor:
rin
public Thread(String threadName)
Here, threadName specifies the name of the thread.
ee
implementing runnable
• The easiest way to create a thread is to create a class that implements the Runnable
gin
interface.
• Runnable abstracts a unit of executable code. We can construct a thread on any object
that implements Runnable.
En
• To implement Runnable, a class need only implement a single method called run( ),
which is declared as:
arn
public void run( )

• Inside run( ), we will define the code that constitutes the new thread. The run( )
can call other methods, use other classes, and declare variables, just like the main
Le
thread can. The only difference is that run( ) establishes the entry point for another,
concurrent thread of execution within the program. This thread will end when run( )
w.
returns.
• After we create a class that implements Runnable, we will instantiate an object of
ww
type Thread from within that class.

• After the new thread is created, it will not start running until we call its start( ) method,
which is declared within Thread. In essence, start( ) executes a call to run( ).
• The start( ) method is shown as:
void start( )
Sample java program that creates a new thread by implementing Runnable:

// Create a second thread
class NewThread implements Runnable
{
Thread t;
NewThread()
n
{
g.i
// Create a new, second thread
t = new Thread(this, “Demo Thread”);
rin
System.out.println(“Child thread: “ + t);
t.start(); // Start the thread ee
}
// This is the entry point for the second thread.
gin
public void run()

{
En
try
{
arn
for(int i = 5; i > 0; i--)

{
System.out.println(“Child Thread: “ + i);
Le
Thread.sleep(500);
}
w.
}
ww
{
System.out.println(“Child interrupted.”);
}
System.out.println(“Child thread is exiting.”);
}
}
public class ThreadDemo

{
{
new NewThread(); // create a new thread
try
n
{
g.i
for(int i = 5; i > 0; i--)
{
rin
System.out.println(“Main Thread: “ + i);
Thread.sleep(1000); ee
}
}
gin
{
En
System.out.println(“Main thread interrupted.”);

}
arn

}
}
Le
Inside NewThread’s constructor, a new Thread object is created by the following

statement:
w.
t = new Thread(this, “Demo Thread”);

Passing this as the first argument indicates that we want the new thread to call the run( )
ww
method on this object. Next, start( ) is called, which starts the thread of execution beginning
at the run( ) method. This causes the child thread’s for loop to begin. After calling start( ),
NewThread’s constructor returns to main(). When the main thread resumes, it enters its for
loop. Both threads continue running, sharing the CPU, until their loops finish.
Sample Output:
Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
n
Main Thread: 4
g.i
Child Thread: 3
Child Thread: 2
rin
Main Thread: 3
Child Thread: 1 ee
Child thread is exiting.
Main Thread: 2
gin
Main Thread: 1
En
In a multithreaded program, often the main thread must be the last thread to finish run-
ning. In fact, for some older JVMs, if the main thread finishes before a child thread has
completed, then the Java run-time system may “hang.” The preceding program ensures that
arn
the main thread finishes last, because the main thread sleeps for 1,000 milliseconds between
iterations, but the child thread sleeps for only 500 milliseconds. This causes the child thread
to terminate earlier than the main thread.
Le
Choosing an approach
The Thread class defines several methods that can be overridden by a derived class. Of
w.
these methods, the only one that must be overridden is run(). This is, of course, the same
method required when we implement Runnable. Many Java programmers feel that classes
should be extended only when they are being enhanced or modified in some way. So, if we
ww
will not be overriding any of Thread’s other methods, it is probably best simply to implement
Runnable.
Creating Multiple threads

The following program creates three child threads:
// Create multiple threads.
{
String name; // name of thread
n
Thread t;
g.i
NewThread(String threadname)
{
rin
name = threadname;
t = new Thread(this, name); ee
System.out.println(“New thread: “ + t);
t.start(); // Start the thread
gin
}
// This is the entry point for thread.
En
public void run()

{
arn
try
{
for(int i = 5; i > 0; i--)
Le
{
System.out.println(name + “: “ + i);
w.
Thread.sleep(1000);
ww
}
}
{
System.out.println(name + “Interrupted”);
}
System.out.println(name + “ exiting.”);
}
}
public class MultiThreadDemo
{
{
n
new NewThread(“One”); // start threads
g.i
new NewThread(“Two”);
new NewThread(“Three”);
rin
try
{ ee
// wait for other threads to end
Thread.sleep(10000);
gin
}
En
{
System.out.println(“Main thread Interrupted”);
arn
}
System.out.println(“Main thread exiting.”);
}
Le
}
The output from this program is shown here:
w.
New thread: Thread[One,5,main]

ww
New thread: Thread[Two,5,main]

New thread: Thread[Three,5,main]
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Three: 3
Two: 3
One: 2
Three: 2
n
Two: 2
g.i
One: 1
Three: 1
rin
Two: 1
One exiting. ee
Two exiting.
Three exiting.
gin
Main thread exiting.

As we can see, once started, all three child threads share the CPU. The call to sleep(10000)
in main(). This causes the main thread to sleep for ten seconds and ensures that it will finish
En
last.
using isalive( ) and join( )
arn
We want the main thread to finish last. In the preceding examples, this is accomplished
by calling sleep( ) within main( ), with a long enough delay to ensure that all child threads
terminate prior to the main thread. However, this is hardly a satisfactory solution, and it also
Le
raises a larger question: How can one thread know when another thread has ended?
Two ways exist to determine whether a thread has finished or not.
w.
• First, we can call isAlive( ) on the thread. This method is defined by Thread.
Syntax:
ww
final boolean isAlive( )

The isAlive( ) method returns true, if the thread upon which it is called is still running. It
returns false, otherwise.
• Second, we can use join() to wait for a thread to finish.
Syntax:
final void join( ) throws InterruptedException
This method waits until the thread on which it is called terminates. Its name comes from
the concept of the calling thread waiting until the specified thread joins it.
Sample Java program using join() to wait for threads to finish.
{
String name; // name of thread
Thread t;
n
NewThread(String threadname)
g.i
{
name = threadname;
rin
t = new Thread(this, name);
System.out.println(“New thread: “ + t);
ee
t.start(); // Start the thread
gin
}
// This is the entry point for thread.
public void run()
En
{
try
arn
{
for(int i = 5; i > 0; i--)
Le
{
System.out.println(name + “: “ + i);
w.
Thread.sleep(1000);
}
ww
}
{
System.out.println(name + “ interrupted.”);
}
System.out.println(name + “ is exiting.”);
}
}
public class DemoJoin
{
{
n
NewThread ob1 = new NewThread(“One”);
g.i
NewThread ob2 = new NewThread(“Two”);
NewThread ob3 = new NewThread(“Three”);
rin
System.out.println(“Thread One is alive: “ + ob1.t.isAlive());
System.out.println(“Thread Two is alive: “ + ob2.t.isAlive());
ee
System.out.println(“Thread Three is alive: “ + ob3.t.isAlive());
// wait for threads to finish
gin
try
{
En
System.out.println(“Waiting for threads to finish.”);

ob1.t.join();
arn
ob2.t.join();
ob3.t.join();
}
Le
{
w.
System.out.println(“Main thread Interrupted”);

ww
}
System.out.println(“Thread One is alive: “ + ob1.t.isAlive());
System.out.println(“Thread Two is alive: “ + ob2.t.isAlive());
System.out.println(“Thread Three is alive: “ + ob3.t.isAlive());
}
}
sample output:
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
One: 5
New thread: Thread[Three,5,main]
Two: 5
n
Thread One is alive: true
g.i
Thread Two is alive: true
Thread Three is alive: true
rin
Waiting for threads to finish.
Three: 5
ee
One: 4
gin
Two: 4
Three: 4
One: 3
En
Two: 3
Three: 3
arn
One: 2
Two: 2
Le
Three: 2
One: 1
w.
Two: 1
Three: 1
ww
One is exiting.
Two is exiting.
Three is exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
• to control the access of multiple threads to

any shared resource.
• Java Synchronization is better option where we want to allow only one thread to
access the shared resource.
• When two or more threads need access to a shared resource, they need some way to
n
ensure that the resource will be used by only one thread at a time. The process by
which this is achieved is called synchronization. Java provides unique, language-
g.i
level support for it.
• Key to synchronization is the concept of the monitor (also called a semaphore).
rin
• A monitor is an object that is used as a mutually exclusive lock, or mutex. Only one
thread can own a monitor at a given time. When a thread acquires a lock, it is said
ee
to have entered the monitor. All other threads attempting to enter the locked monitor
will be suspended until the first thread exits the monitor.
gin
• These other threads are said to be waiting for the monitor. A thread that owns a monitor
can reenter the same monitor if it so desires.
• Approaches:
En
○ Using synchronized Method

○ Using synchronized Statement
arn
using synchronized Methods

Synchronization is easy in Java, because all objects have their own implicit monitor as-
sociated with them.
Le
To enter an object’s monitor, just call a method that has been modified with the synchro-
nized keyword.
w.
While a thread is inside a synchronized method, all other threads that try to call it (or any
other synchronized method) on the same instance have to wait.
ww
To exit the monitor and relinquish control of the object to the next waiting thread, the
owner of the monitor simply returns from the synchronized method.
• To understand the need for synchronization, we will consider a simple example that
does not use it—but should.
• The following program has three simple classes.
• The first one, Callme, has a single method named call( ). The call( ) method takes a
String parameter called msg. This method tries to print the msg string inside of square
brackets. After call( ) prints the opening bracket and the msg string, it calls Thread.
sleep(1000), which pauses the current thread for one second.

• The constructor of the next class, Caller, takes a reference to an instance of the Callme
class and a String, which are stored in target and msg, respectively. The constructor
also creates a new thread that will call this object’s run( ) method. The thread is
started immediately. The run( ) method of Caller calls the call( ) method on the target
instance of Callme, passing in the msg string.
• Finally, the Synch class starts by creating a single instance of Callme, and three
instances of Caller, each with a unique message string.
n
• The same instance of Callme is passed to each Caller.
g.i
// This program is not synchronized.
class Callme
rin
{
void call(String msg)
ee
{
gin
System.out.print(“[“ + msg);
try
{
En
Thread.sleep(1000);
}
arn
catch(InterruptedException e)
{
Le
System.out.println(“Interrupted”);
}
w.
System.out.println(“]”);
}
ww
class Caller implements Runnable

{
String msg;
Callme target;
Thread t;
public Caller(Callme targ, String s)
{
target = targ;
msg = s;
t = new Thread(this);
n
t.start();
g.i
}
public void run()
rin
{
target.call(msg); ee
}
}
gin
public class Synch

En
{
arn
{
Callme target = new Callme();
Caller ob1 = new Caller(target, “Hello”);
Le
Caller ob2 = new Caller(target, “Synchronized”);

Caller ob3 = new Caller(target, “World”);
w.
// wait for threads to end

ww
try
{
ob1.t.join();
ob2.t.join();
ob3.t.join();
}
{
}
}
}
Sample Output:
n
Hello[Synchronized[World]
g.i
]
]
rin
As we can see, by calling sleep( ), the call( ) method allows execution to switch to another
thread. This results in the mixed-up output of the three message strings.
In this program, nothing exists to stop all three threads from calling the same method, on
ee
the same object, at the same time. This is known as a race condition, because the three threads
are racing each other to complete the method.
gin
This example used sleep( ) to make the effects repeatable and obvious. In most situations,
a race condition is more subtle and less predictable, because we can’t be sure when the con-
text switch will occur. This can cause a program to run right one time and wrong the next.
En
To fix the preceding program, we must serialize access to call(). That is, we must restrict
its access to only one thread at a time. To do this, we simply need to precede call()’s definition
arn
with the keyword synchronized, as shown here:

This prevents other threads from entering call( ) while another thread is using it.
class Callme
Le
{
synchronized void call(String msg)
w.
{
...
ww
Following is the sample java program after synchronized has been added to call( ):
class Callme
{
synchronized void call(String msg)
{
try
{
Thread.sleep(1000);
}
{
n
g.i
}
rin
}
} ee
gin
{
String msg;
En
Callme target;
Thread t;
arn

{
target = targ;
Le
msg = s;
w.
t.start();
ww
}
public void run()
{
target.call(msg);
}
}
public class Synch

{
{
n
g.i
rin
try
{ ee
ob1.t.join();
ob2.t.join();
gin
ob3.t.join();
}
En
{
arn
}
}
Le
}
Output:
w.
[Hello]
ww
[Synchronized]
[World]
using synchronized statement
While creating synchronized methods within classes that we create is an easy and effec-
tive means of achieving synchronization, it will not work in all cases. We have to put calls to
the methods defined by the class inside a synchronized block.
Syntax:
synchronized(object)
{
// statements to be synchronized
}
Here, object is a reference to the object being synchronized. A synchronized block en-
sures that a call to a method that is a member of object occurs only after the current thread has
successfully entered object’s monitor.
n
Here is an alternative version of the preceding example, using a synchronized block with-
g.i
in the run( ) method:
// This program uses a synchronized block.
rin
class Callme
{ ee
void call(String msg)
{
gin
try
En
{
Thread.sleep(1000);
arn
}
{
Le
}
w.
ww
}
}
{
String msg;
Callme target;
Thread t;

{
target = targ;
msg = s;
t.start();
n
}
g.i
// synchronize calls to call()
public void run()
rin
{
synchronized(target) ee
{
// synchronized block
gin
target.call(msg);
}
En
}
}
arn
public class Synch1

{
Le
{
w.

ww

try
{
ob1.t.join();
ob2.t.join();
ob3.t.join();
}
{
}
n
}
g.i
}
Here, the call( ) method is not modified by synchronized. Instead, the synchronized state-
ment is used inside Caller’s run( ) method. This causes the same correct output as the preced-
rin
ing example, because each thread waits for the prior one to finish before proceeding.
Sample Output:
ee
[Hello]
[World]
gin
[Synchronized]
Priority of a thread (thread Priority):
En
Each thread has a priority. Priorities are represented by a number between 1 and 10. In
most cases, thread schedular schedules the threads according to their priority (known as pre-
emptive scheduling). But it is not guaranteed because it depends on JVM specification that
arn
which scheduling it chooses.

3 constants defined in Thread class:
Le
1. public static int MIN_PRIORITY
2. public static int NORM_PRIORITY

w.
3. public static int MAX_PRIORITY

ww
Default priority of a thread is 5 (NORM_PRIORITY). The value of MIN_PRIORITY is

1 and the value of MAX_PRIORITY is 10.
sample Java Program:
public class TestMultiPriority1 extends Thread
{
public void run()
{
System.out.println(“running thread name is:”+Thread.currentThread().getName());

System.out.println(“running thread priority is:”+Thread.currentThread().getPriority());
}
{
TestMultiPriority1 m1=new TestMultiPriority1();
n
TestMultiPriority1 m2=new TestMultiPriority1();
g.i
m1.setPriority(Thread.MIN_PRIORITY);
m2.setPriority(Thread.MAX_PRIORITY);
rin
m1.start();
m2.start(); ee
}
}
gin
Output:
running thread name is:Thread-0
En
running thread priority is:10

running thread name is:Thread-1
arn
running thread priority is:1

4.4 inter-thread CoMMuniCation
Inter-process communication (IPC) is a mechanism that allows the exchange of data be-
Le
tween processes. By providing a user with a set of programming interfaces, IPC helps a
programmer organize the activities among different processes. IPC allows one application to
control another application, thereby enabling data sharing without interference.
w.
IPC enables data communication by allowing processes to use segments, semaphores, and
other methods to share memory and information. IPC facilitates efficient message transfer
ww
between processes. The idea of IPC is based on Task Control Architecture (TCA). It is a flex-
ible technique that can send and receive variable length arrays, data structures, and lists. It
has the capability of using publish/subscribe and client/server data-transfer paradigms while
supporting a wide range of operating systems and languages.
Inter-thread communication or Co-operation is all about allowing synchronized threads to
communicate with each other. Interthread communication is important when you develop an
application where two or more threads exchange some information.
Cooperation (Inter-thread communication) is a mechanism in which a thread is paused

running in its critical section and another thread is allowed to enter (or lock) in the same criti-
cal section to be executed. It is implemented by following methods of Object class:
• wait()
• notify()
• notifyAll()
All these methods belong to object class as final so that all classes have them. They must
n
be used within a synchronized block only.
g.i
1) wait() method
Causes current thread to release the lock and wait until either another thread invokes the
notify() method or the notifyAll() method for this object, or a specified amount of time has
rin
elapsed. The current thread must own this object’s monitor, so it must be called from the syn-
chronized method only otherwise it will throw exception.
ee
2) notify() method
Wakes up a single thread that is waiting on this object’s monitor. If any threads are waiting
gin
on this object, one of them is chosen to be awakened. The choice is arbitrary and occurs at the
discretion of the implementation. Syntax:
public final void notify()
En
3) notifyAll() method
Wakes up all threads that are waiting on this object’s monitor. Syntax:
arn
public final void notifyAll()

// Java program to demonstrate inter-thread communication (wait(), join() and notify()) in
Le
Java
import java.util.Scanner;
w.
public class Thread_Example

{
ww
public static void main(String[] args) throws InterruptedException

{
final Producer_Consumer pc = new Producer_Consumer ();
Thread t1 = new Thread(new Runnable()
{
public void run()
{
try
{
pc.producer();
}
{
n
e.printStackTrace();
g.i
}
}
rin
});
Thread t2 = new Thread(new Runnable()
ee
{
public void run()
gin
{
try
En
{
pc.consumer();
arn
}
{
Le
e.printStackTrace();
}
w.
}
ww
});
t1.start();
t2.start();
t1.join();
t2.join();
}
public static class Producer_Consumer

{
public void producer()throws InterruptedException
{
synchronized(this)
{
n
System.out.println(“producer thread running”);
g.i
wait();
System.out.println(“Resumed”);
rin
}
} ee
public void consumer()throws InterruptedException
{
gin
Thread.sleep(1000);
Scanner ip = new Scanner(System.in);
En
synchronized(this)
{
arn
System.out.println(“Waiting for return key.”);

ip.nextLine();
System.out.println(“Return key pressed”);
Le
notify();
Thread.sleep(1000);
w.
}
ww
}
}
}
The following statements explain how the above producer-Consumer program works.
• The use of synchronized block ensures that only one thread at a time runs. Also since
there is a sleep method just at the beginning of consumer loop, the produce thread
gets a kickstart.
• When the wait is called in producer method, it does two things.

it releases the lock it holds on PC object.
it makes the produce thread to go on a waiting state until all other threads have
terminated, that is it can again acquire a lock on PC object and some other
method wakes it up by invoking notify or notifyAll on the same object.
• Therefore we see that as soon as wait is called, the control transfers to consume thread
and it prints -“Waiting for return key”.
n
• After we press the return key, consume method invokes notify(). It also does 2 things-
Firstly, unlike wait(), it does not releases the lock on shared resource therefore for
g.i
getting the desired result, it is advised to use notify only at the end of your method.
Secondly, it notifies the waiting threads that now they can wake up but only after the
rin
current method terminates.
• As you might have observed that even after notifying, the control does not immediately
passes over to the produce thread. The reason for it being that we have called Thread.
ee
sleep() after notify(). As we already know that the consume thread is holding a lock
on PC object, another thread cannot access it until it has released the lock. Hence only
gin
after the consume thread finishes its sleep time and thereafter terminates by itself, the
produce thread cannot take back the control.
• After a 2 second pause, the program terminates to its completion.
En
• The following program is one more example for interthread communication
class InterThread_Example
arn
{
public static void main(String arg[])
Le
{
w.
final Client c = new Client();

new Thread()
ww
{
public void run()
{
c.withdraw(15000);
}
}.start();
new Thread()
{
public void run()
{
c.deposit(10000);
}
n
}.start();
g.i
new Thread()
rin
{
public void run() ee
{
c.deposit(10000);
gin
}
}.start();
En
}
}
arn
class Client
Le
{
w.
int amount = 10000;

ww
synchronized void withdraw(int amount)

{
System.out.println(“Available Balance “ + this. amount);
System.out.println(“withdrawal amount.” + amount);
if (this.amount < amount)
{
System.out.println(“Insufficient Balance waiting for deposit.”);
try
{
wait();
} catch (Exception e)
n
{
g.i
System.out.println(“Interruption Occured”);
rin
}
} ee
this.amount -= amount;
System.out.println(“Detected amount: “ + amount);
gin
System.out.println(“Balance amount : “ + this.amount);

}
En
synchronized void deposit(int amount)

{
arn
System.out.println(“Going to deposit “ + amount);

this.amount += amount;
Le
System.out.println(“Available Balance “ + this.amount);

w.
System.out.println(“Transaction completed.\n”);
notify();
ww
}
}
4.5 daeMon thread
Daemon thread is a low priority thread that runs in background to perform tasks such as
garbage collection. Daemon thread in java is a service provider thread that provides services
to the user thread. Its life depend on the mercy of user threads i.e. when all the user threads
dies, JVM terminates this thread automatically.
There are many java daemon threads running automatically e.g. gc, finalizer etc.
• It provides services to user threads for background supporting tasks. It has no role in
life than to serve user threads.
• Its life depends on user threads.
• It is a low priority thread.
The command jconsole typed in the command prompt provides information about the
loaded classes, memory usage, running threads etc.
n
The purpose of the daemon thread is that it provides services to user thread for back-
g.i
ground supporting task. If there is no user thread, why should JVM keep running this thread.
That is why JVM terminates the daemon thread if there is no user thread.
rin
Properties:
• They cannot prevent the JVM from exiting when all the user threads finish their
execution.
ee
• JVM terminates itself when all user threads finish their execution
gin
• If JVM finds running daemon thread, it terminates the thread and after that shutdown
itself. JVM does not care whether Daemon thread is running or not.
• It is an utmost low priority thread.
En
Methods for Java daemon thread by thread class

The java.lang.Thread class provides two methods for java daemon thread.
arn
Method description
public void setDaemon(boolean status) used to mark the current thread as daemon
thread or user thread.
Le
public boolean isDaemon() used to check that current is daemon.

// Java program to demonstrate the usage of setDaemon() and isDaemon() method.
w.
public class DaemonThread extends Thread

{
ww
public void run()

{
// Checking whether the thread is Daemon or not
if(Thread.currentThread().isDaemon())
{
System.out.println(“This is Daemon thread”);
}
else
{
System.out.println(“This is User thread”);
}
}
n
g.i
{
DaemonThread t1 = new DaemonThread();
rin
ee
// Setting user thread t1 to Daemon
t1.setDaemon(true);
gin
// starting all the threads

t1.start();
En
t2.start();
t3.start();
arn
// Setting user thread t3 to Daemon

t3.setDaemon(true);
}
Le
}
Output:
w.
This is Daemon thread

ww
This is User thread

This is Daemon thread
// Java program to demonstrate the usage of exception in Daemon() Thread
public class DaemonThread extends Thread
{
public void run()
{

n
g.i
rin
ee
gin
En
arn
Le
w.
ww

n
g.i
rin
ee
gin
En
arn
Le
w.
ww
4.6 thread grouP in Java

Java provides a convenient way to group multiple threads in a single object. In such way,
we can suspend, resume or interrupt group of threads by a single method call. ThreadGroup
creates a group of threads. It offers a convenient way to manage groups of threads as a unit.
This is particularly valuable in situation in which you want to suspend and resume a number
of related threads.
• The thread group form a tree in which every thread group except the initial thread
group has a parent.
n
• A thread is allowed to access information about its own thread group but not to access
g.i
information about its thread group’s parent thread group or any other thread group.
Constructors of threadgroup class
rin
There are only two constructors of ThreadGroup class.
Constructor description
ee
Thread Group (String name) creates a thread group with given name.
Thread Group (ThreadGroup parent, creates a thread group with given parent group
gin
String name) and name.

En
arn
Le
w.
ww
System.out.println(“Thread Group Name: “+tg1.getName());

tg1.list();
}
}
Sample Output:
one
n
two
g.i
three
Thread Group Name: Parent ThreadGroup
rin
java.lang.ThreadGroup[name=Parent ThreadGroup,maxpri=10]
Thread [one,5,Parent ThreadGroup] ee
Thread [two,5,Parent ThreadGroup]
Thread [three,5,Parent ThreadGroup]
gin
Methods of threadgroup class

There are many methods in ThreadGroup class. A list of important methods are given
below.
En
Method description
arn
int activeCount() returns no. of threads running in current group.
int activeGroupCount() returns a no. of active group in this thread group.

Le
void destroy() destroys this thread group and all its sub groups.
String getName() returns the name of this group.

w.
ThreadGroup getParent() returns the parent of this group.

ww
void interrupt() interrupts all threads of this group.
void list() prints information of this group to standard console.
The following programs explain the threadgroup example.

// Java code illustrating activeCount() method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
n
g.i
super(tgob, threadname);
start();
rin
}
public void run() ee
{
gin
for (int i = 0; i < 1000; i++)

{
En
try
{
arn
Thread.sleep(10);
}
catch (InterruptedException ex)
Le
{
System.out.println(“Exception encounterted”);
w.
}
}
ww
}
}
public class ThreadGroup_example
{
public static void main(String arg[])
{
// creating the thread group

ThreadGroup gfg = new ThreadGroup(“parent thread group”);
NewThread t1 = new NewThread(“one”, gfg);

System.out.println(“Starting one”);
NewThread t2 = new NewThread(“two”, gfg);
n
System.out.println(“Starting two”);
g.i
// checking the number of active thread
rin
System.out.println(“number of active thread: “
ee + gfg.activeCount());
}
}
gin
Output:
Starting one
En
Starting two
number of active thread: 2
arn
Le
w.
ww
Event Driven Programming  5.1
UNIT-5
EVENT DRIVEN PROGRAMMING
n
Java AWT
g.i
The Abstract Window Toolkit (AWT) is Java’s original platform-independent window-
ing, graphics, and user-interface widget toolkit. The AWT classes are contained in the
rin
java.awt package.
• Contains all of the classes for creating user interfaces and for painting graphics and
images.
ee
• an API to develop GUI or window-based applications in java.
gin
The hierarchy of Java AWT classes are shown below.
En
arn
Le
w.
ww
Component
A component is an object having a graphical representation that can be displayed on the
screen and that can interact with the user.
Examples :
buttons, checkboxes, and scrollbars
The Component class is the abstract superclass of all user interface elements that are
displayed on the screen. A Component object remembers current text font, foreground and
n
background color.
g.i
Container
The Container class is the subclass of Component. The container object is a component
that can contain other AWT components. It is responsible for laying out any components that
rin
it contains.
Window
ee
The class Window is a top level window with no border and no menubar. The default lay-
out for a window is BorderLayout. A window must have either a frame, dialog, or another
gin
window defined as its owner when it’s constructed.

Panel
En
The class Panel is the simplest container class. It provides space in which an application
can attach any other component, including other panels. The default layout manager for a
panel is the FlowLayout layout manager
arn
Frame
A Frame is a top-level window with a title and a border. It uses BorderLayout as default
layout manager.
Le
Dialog
A Dialog is a top-level window with a title and a border that is typically used to take some
w.
form of input from the user.

Canvas
ww
A Canvas component represents a blank rectangular area of the screen onto which the
application can draw or from which the application can trap input events from the user. An
application must subclass the Canvas class in order to get useful functionality such as creat-
ing a custom component. The paint method must be overridden in order to perform custom
graphics on the canvas. It is not a part of hierarchy of Java AWT.
java.awt.Graphics class
The java.awt.Graphics class provides many methods for graphics programming. A graph-
ics context is encapsulated by the Graphics class and is obtained in two ways:
• It is passed to an applet when one of its various methods, such as paint( ) or
update( ) is called.
• It is returned by the getGraphics( ) method of Component.
Graphics Methods
n
The commonly used methods of Graphics class are as follows.
g.i
Method Description
abstract Graphics create() Creates a new Graphics object that is a
rin
copy of this Graphics object
abstract void drawString(String str, int Draws the text given by the specified
x, int y) string
ee
void drawRect(int x, int y, int width, intdraws a rectangle with the specified width
height) and height
gin
void draw3DRect(int x, int y, int width, Draws a 3-D highlighted outline of the
int height, boolean raised) specified rectangle.
abstract void drawRoundRect(int x, int Draws an outlined round-cornered rect-
En
y, int width, int height, int arcWidth, int

angle using this graphics context’s current
arcHeight) color
abstract void fillRect(int x, int y, int fill rectangle with the default color and
arn
width, int height) specified width and height.

abstract void drawPolygon(int[] xPoints, Draws a closed polygon defined by arrays
int[] yPoints, int nPoints) of x and y coordinates.
Le
abstract void fillPolygon(int[] xPoints, Fills a closed polygon defined by arrays of

int[] yPoints, int nPoints) x and y coordinates.
abstract void drawOval(int x, int y, int draw oval with the specified width and
w.
width, int height) height.

abstract void fillOval(int x, int y, int fill oval with the default color and speci-
ww
width, int height) fied width and height.

abstract void drawLine(int x1, int y1, intdraw line between the points(x1, y1) and
x2, int y2) (x2, y2).
abstract boolean drawImage(Image img, draw the specified image.
int x, int y, ImageObserver observer)
abstract void drawArc(int x, int y, int draw a circular or elliptical arc.
width, int height, int startAngle, int arc
Angle)
abstract void fillArc(int x, int y, int width, fill a circular or elliptical arc.
int height, int startAngle, int arcAngle)
abstract void setColor(Color c) set the graphics current color to the speci-
fied color.
abstract void setFont(Font font) set the graphics current font to the speci-
fied font.
Example:
GraphicsDemo.java
n
g.i
import java.applet.Applet;
import java.awt.*;
rin
public class GraphicsDemo extends Applet{
public void paint(Graphics g){ ee
g.setColor(Color.red); // set font color
g.drawString(“Welcome”,50, 50); // display text
gin
g.drawLine(120,120,200,300); // draw a line

// draw and fill rectangle
En
g.drawRect(170,100,60,50);
g.fillRect(170,100,60,50);
arn
// draw and fill rounded rectangle

g.drawRoundRect(190, 10, 60, 50, 15, 15);
g.fillRoundRect(190, 10, 60, 50, 15, 15);
Le
// draw and fill oval

g.drawOval(70,200,50,50);
w.
g.setColor(Color.green);
g.fillOval(170,200,50,50);
ww
// draw and fill arc

g.drawArc(90,150,70,70,0,75);
g.fillArc(270,150,70,70,0,75);
// draw a polygon
int xpoints[] = {30, 200, 30, 200, 30};
int ypoints[] = {30, 30, 200, 200, 30};
int num = 5;
g.drawPolygon(xpoints, ypoints, num);
}
}
Test.html
<html>
n
<body>
g.i
<applet code=”GraphicsDemo4.class” width=”300” height=”300”>
</applet>
rin
</body>
</html> ee
Sample Output:
gin
En
arn
Le
w.
ww
Note:
Steps to be followed to compile and run applet in DOS.
Compile the java file using javac command (for example, javac GraphicsDemo.
java).
2. Create a separate html file. Mention the name of the java class file in the applet code
parameter (for example code=”GraphicsDemo.class”)
3. Run the html file using appletviewer command (for example, appletviewer test.html)
n
Frames
g.i
A Frame is a top-level window with a title and a border. Frames are capable of generating
the following types of window events: WindowOpened, WindowClosing, WindowClosed,
WindowIconified, WindowDeiconified, WindowActivated, WindowDeactivated.
rin
Frame Constructor
Frame()
ee
Constructs a new instance of Frame that is initially invisible.
gin
Frame(String)
Constructs a new, initially invisible Frame object with the specified title.
Some of the commonly used methods of Frame class are as follows.
En
Methods Description
String getTitle() Gets the title of the frame.
arn
void setBackground(Color bgColor) Sets the background color of this window.

void setResizable (boolean resizable) Sets whether this frame is resizable by the user.
void setShape (Shape shape) Sets the shape of the window.
Le
void setTitle (String title) Sets the title for this frame to the specified
string.
w.
void setSize (Dimension d) Resizes this component so that it has width d.

width and height d.height.
void setVisible(boolean b) Shows or hides this Window depending on the
ww
value of parameter b.
public void show() Makes the Window visible
void setMenuBar (MenuBar) mb) Sets the menu bar for this frame to the specified
menu bar
Creating a Frame
We can generate a window by creating an instance of Frame. The created frame can be
made visible by calling setVisible( ). When created, the window is given a default height and
width. The size of the window can be changed explicitly by calling the setSize( ) method. A
label can be added to the current frame by creating an Label instance and calling the add()
method.
Example:
import java.awt.*;
public class AwtFrame{
n
g.i
Frame frm = new Frame(“Java AWT Frame”);
rin
Label lbl = new Label(“Welcome”,Label.CENTER);
ee
frm.add(lbl);
frm.setSize(400,400);
gin
frm.setVisible(true);
En
}
arn
Sample Output:
Le
w.
ww
n
g.i
rin
ee
gin
Creating an Frame Window in an Applet

The steps to be followed to create a child frame within an applet are as follows.
En
Create a subclass of Frame

Override any of the standard window methods, such as init(),start(),stop(),and
arn
paint().
3. Implement the windowClosing() method of the windowListener interface,calling
setVisible(false) when the window is closed
Le
Once you have defined a Frame subclass, you can create an object of that class. But it
will note be initially visible
w.
When created, the window is given a default height and width

6. You can set the size of the window explicitly by calling the setSize() method
ww
Example:
AppletFrame.java
// Create a child frame window from within an applet.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
// Create a subclass of Frame.

class SampleFrame extends Frame {
SampleFrame(String title) {
super(title);
// create an object to handle window events
MyWindowAdapter adapter = new MyWindowAdapter(this);
n
// register it to receive those events
g.i
addWindowListener(adapter);
}
rin
public void paint(Graphics g) {
g.drawString(“This is in frame window”, 10, 40);
ee
}
}
gin
class MyWindowAdapter extends WindowAdapter {

SampleFrame sampleFrame;
En
public MyWindowAdapter(SampleFrame sampleFrame) {

this.sampleFrame = sampleFrame;
arn
}
public void windowClosing(WindowEvent we) {
sampleFrame.setVisible(false);
Le
}
}
w.
// Create frame window.

ww
public class AppletFrame extends Applet {

Frame f;
//init(), start(), paint(), and stop() methods are called automatically in the specified se-
quence.
public void init() {
f = new SampleFrame(“A Frame Window”);
f.setSize(150, 150);
f.setVisible(true);
}
public void start() {
f.setVisible(true); // make the window visible
}
public void stop() {
n
f.setVisible(false); // hide the window
g.i
}
rin
g.drawString(“This is in applet window”, 15, 30); // Display the given text in the win-
dow
}
ee
}
gin
Test1.html
<html>
<body>
En
<applet code=”AppletFrame.class” width=”400” height=”300”>

</applet>
arn
</body>
</html>
Le
Sample Output:
w.
ww
Components
Java AWT Component classes exist in java.awt package. The Component class is a super
class of all components such as buttons, checkboxes, scrollbars, etc.
Component class constructor:
Component() // constructs a new component
Properties of Java AWT Components:
• A Component object represents a graphical interactive area displayable on the screen
n
that can be used by the user.
g.i
• Any subclass of a Component class is known as a component. For example, button
is a component.
rin
• Only components can be added to a container, like frame.
Some of the commonly used methods of Component class are as follows.
ee
Method Description
setBackground(Color) Sets the background color of this component.
gin
setBounds(int, int, int, int) Moves and resizes this component.

setEnabled(boolean) Enables or disables this component, depending on the
value of the parameter b.
En
setFont(Font) Sets the font of this component.

setForeground(Color) Sets the foreground color of this component.
arn
setLocation(int, int) Moves this component to a new location.

setSize(int, int) Resizes this component so that it has width
width and height.
Le
setVisible(boolean) Shows or hides this component depending on the

value of parameter b.
update(Graphics) Updates this component.
w.
repaint() Repaints this component.

repaint(int, int, int, int) Repaints the specified rectangle of this component.
ww
add(Component c) Inserts a component on this component.

remove(Component c) Removes the specified component from this
component.
Working with 2D shapes
Java supports 2-dimensional shapes, text and images using methods available in Graph-
ics2D class. The Graphics2D class extends the Graphics class to provide more sophisticated
control over geometry, coordinate transformations, color management, and text layout.
Graphics2D class Constructor

Graphics2D() //Constructs a new Graphics2D object.
This class inherits the methods from java.lang.Object. Some of the commonly used meth-
ods of Graphics2D class are as follows.
Method Description
void draw(Shape s) Strokes the outline of a Shape using the
settings of the current Graphics2D context
n
void draw3DRect(int x, int y, int width, Draws a 3-D highlighted outline of the
int height, boolean raised) specified rectangle.
g.i
void drawImage(BufferedImage img, Renders a BufferedImage that is filtered with
BufferedImageOp op, int x, int y) a BufferedImageOp.
rin
boolean drawImage(Image img, Affine Renders an image, applying a transform
Transform xform, ImageObserver obs) from image space into user space before
drawing.
ee
void drawString(String str, float x, float Renders the text specified by the specified
y) String, using the current text attribute state
gin
in the Graphics2D context

void fill(Shape s) Fills the interior of a Shape using the
settings of the Graphics2D context.
En
void rotate(double theta) Concatenates the current Graphics2D

Transform with a rotation transform.
void scale(double sx, double sy) oncatenates the current Graphics2D
arn
Transform with a scaling transformation

Subsequent rendering is resized according
to the specified scaling factors relative to the
Le
previous scaling.
void setBackground(Color color) Sets the background color for the
Graphics2D context.
w.
void setPaint(Paint paint) Sets the Paint attribute for the Graphics2D
context.
ww
void setStroke(Stroke s) Sets the Stroke for the Graphics2D context.

void shear(double shx, double shy) Concatenates the current Graphics2D
Transform with a shearing transform.
void transform(AffineTransform Tx) Composes an AffineTransform object with
the Transform in this Graphics2D according
to the rulelast-specified-first-applied.
void translate(int x, int y) Translates the origin of the Graphics2D con-

text to the point (x, y) in the current coordi-
nate system.
Example:
import java.awt.*;
/*
n
<applet code=”ShapesDemo” width=350 height=300>
g.i
</applet>
*/
rin
public class ShapesDemo extends Applet {
public void init() {}
ee
gin
Graphics2D g2d = (Graphics2D)g;
g2d.setColor(Color.blue);
g2d.drawRect(75,75,300,200);
En
Font exFont = new Font(“TimesRoman”,Font.PLAIN,40);

g2d.setFont(exFont);
arn
g2d.setColor(Color.black);
g2d.drawString(“Graphics2D Example”,120.0f,100.0f);
Le
g2d.setColor(Color.green);
g2d.drawLine(100,100,300,200);
w.
g2d.drawOval(150,150,100,200);
g2d.fillOval(150,150,100,200);
ww
}
}
Sample Output:
n
g.i
rin
ee
gin
En
Colors in Java
To support different colors Java package comes with the Color class. The Color class
arn
states colors in the default sRGB color space or colors in arbitrary color spaces identified by
a ColorSpace.
Color class static color variables available are:
Le
Color.black Color.lightGray
Color.blue Color.magenta
w.
Color.cyan Color.orange
Color.darkGray Color.pink
ww
Color.gray Color.red
Color.green Color.white
Color.yellow
Color class constructor
Color(float r, float g, float b) – create color with specified red, green, and blue values in
the range (0.0 - 1.0)
Color(int r, int g, int b)- create color with the specified red, green, and blue values in the
range (0 - 255).
Some of the commonly used methods supported by the Color class are as follows.
Method Description
int getRed() Returns the red component in the range 0-255 in the
default sRGB space.
Returns the green component in the range 0-255 in the
int getGreen() default sRGB space.
n
int getBlue() Returns the blue component in the range 0-255 in the
g.i
default sRGB space.
Color getHSBColor(float h, Creates a Color object based on the specified values for
rin
float s, float b) the HSB color model.
The current graphics color can be changed using setColor() method defined in Graphics
class.
ee
void setColor(Color newColor) // newColor indicates new drawing color
The current color detail can be obtained using getColor() method. Its syntax is.
gin
Color getColor()
Example:
En
import java.awt.*;
arn
/*
<applet code=”ColorDemo” width=350 height=300>
</applet>
Le
*/
w.
public class ColorDemo extends Applet {

public void init() {
ww
setBackground(Color.CYAN);
}
g.setColor(Color.red); // predefined color
g.drawRect(50, 100, 150, 100); // rectangle outline is red color
Color clr = new Color(200, 100, 150);
g.setColor(clr);
g.fillRect(220,100, 150, 100); // rectangle filled with clr color

}
}
Sample Output:
n
g.i
rin
ee
gin
En
arn
Fonts in Java
The Font class states fonts, which are used to render text in a visible way.
Font class constructor
Le
Font(Font font) //Creates a new Font from the specified font.

Font(String name, int style, int size) //Creates a new Font from the specified name, style
w.
and point size.

Font variables available in Font class are:
ww
Font.BOLD Font. SANS_SERIF

Font.ITALIC Font. CENTER_BASELINE
Font. PLAIN Font. DIALOG
Font. MONOSPACED Font. SERIF
Font. TRUETYPE_FONT Font. TYPE1_FONT
int size int style
float pointSize String name
Some of the commonly used methods supported by the Font class are as follows.
Method Description
String getFamily() Returns the family name of this Font.
int getStyle() Returns the style of this Font.
boolean isBold() Indicates whether or not this Font object’s style is BOLD
boolean isItalic() Indicates whether or not this Font object’s style is ITALIC.
boolean isPlain() Indicates whether or not this Font object’s style is PLAIN.
static Font getFont(String nm) Returns a Font object fom the system properties list.
n
static Font decode(String str) Returns the Font that the str argument describes.
g.i
String toString() Converts this Font object to a String representation.
Example:
rin
import java.awt.*;
ee
/* <APPLET CODE =”FontDemo.class” WIDTH=300 HEIGHT=200> </APPLET> */
gin
public class FontDemo extends java.applet.Applet

{
En
Font f;
String m;
arn
public void init()

{
Le
f=new Font(“Arial”,Font.ITALIC,20);
m=”Welcome to Java”;
w.
setFont(f);
}
ww
public void paint(Graphics g)

{
Color c=new Color(100,100,255);
g.setColor(c);
g.drawString(m,4,20);
Font plainFont = new Font(“Serif”, Font.PLAIN, 24);
g.setFont(plainFont);
g.drawString(“Font in PLAIN”, 50, 70);
Font italicFont = new Font(“Serif”, Font.ITALIC, 24);
g.setFont(italicFont);
g.drawString(“Font in ITALIC”, 50, 120);
Font boldFont = new Font(“Serif”, Font.BOLD, 24);
n
g.setFont(boldFont);
g.i
g.drawString(“Font in BOLD”, 50, 170);
Font boldItalicFont = new Font(“Serif”, Font.BOLD+Font.ITALIC, 24);
rin
g.setFont(boldItalicFont);
g.drawString(“Font in BOLD ITALIC”, 50, 220);
ee
}
}
gin
Sample Output:
En
arn
Le
w.
ww
Images in Java
Image control is superclass for all image classes representing graphical images.
Image class constructor
Image() // create an Image object
Some of the commonly used methods supported by the Image class are as follows.
Method Description
Graphics getGraphics() Creates a graphics context for drawing to an off-
screen image.
int getHeight(ImageObserver observer) Determines the height of the image.
Image getScaledInstance(int width, int Creates a scaled version of this image.
height, int hints)
n
ImageProducer getSource() Gets the object that produces the pixels for the
image.
g.i
int getWidth(ImageObserver observer) Determines the width of the image.
The java.applet.Applet class provides following methods to access image.
rin
getImage() method that returns the object of Image. Its syntax is as follows.
public Image getImage(URL u, String image){}
ee
getDocumentBase() method returns the URL of the document in which applet is em-
bedded.
gin
public URL getDocumentBase(){}

URL getCodeBase() method returns the base URL.
En
public URL getCodeBase()

Example:
arn
import java.awt.*;
Le
import java.net.URL;
w.
/* <APPLET CODE =”ImageDemo.class” WIDTH=300 HEIGHT=200> </APPLET> */

public class ImageDemo extends java.applet.Applet
ww
{
Image img;
public void init()
{
}
{
URL url1 = getCodeBase();

img = getImage(url1,”java.jpg”);
g.drawImage(img, 60, 120, this);
}
}
Sample Output:
n
g.i
rin
ee
gin
En
arn
Event Handling
Any change in the state of any object is called event. For Example: Pressing a button, en-
Le
tering a character in Textbox, Clicking or dragging a mouse, etc. The three main components
in event handling are:
w.
• Events: An event is a change in state of an object. For example, mouseClicked,

mousePressed.
• Events Source: Event source is an object that generates an event. Example: a button,
ww
frame, textfield.
• Listeners: A listener is an object that listens to the event. A listener gets notified when
an event occurs. When listener receives an event, it process it and then return. Listeners
are group of interfaces and are defined in java.awt.event package. Each component
has its own listener. For example MouseListener handles all MouseEvent.
Some of the event classes and Listener interfaces are listed below.
Event Classes Generated when Listener Interfaces
ActionEvent button is pressed, menu-item is selected, Action Listener
list-item is double clicked
MouseEvent mouse is dragged, moved, clicked, pressed Mouse Listener and
or released and also when it enters or exit Mouse Motion
a component Listener
MouseWheelEvent mouse wheel is moved Mouse Wheel Listener
n
KeyEvent input is received from keyboard Key Listener
g.i
ItemEvent check-box or list item is clicked Item Listener
value of textarea or textfield is changed Text Listener
rin
AdjustmentEvent scroll bar is manipulated Adjustment Listener
WindowEvent window is activated, deactivated, deico- Window Listener
nified, iconified, opened or closed
ee
ComponentEvent component is hidden, moved, resized or Component Listener
set visible
gin
ContainerEvent component is added or removed from Container Listener

container
FocusEvent component gains or losses keyboard Focus Listener
En
focus
Java program for handling keyboard events.
arn
Test.java
Le
w.
import java.awt.*;
//Implementing KeyListener interface to handle keyboard events
ww
public class Test extends Applet implements KeyListener

{
String msg=””;
public void init()
{
addKeyListener(this); //use keyListener to monitor key events
}
public void keyPressed(KeyEvent k) // invoked when any key is pressed down
{
showStatus(“KeyPressed”);
}
public void keyReleased(KeyEvent k) // invoked when key is released
n
{
g.i
showStatus(“KeyRealesed”);
}
rin
//keyTyped event is called first followed by key pressed or key released event
public void keyTyped(KeyEvent k) ee //invoked when a textual key is pressed
{
msg = msg+k.getKeyChar();
gin
repaint();
}
En

{
arn
g.drawString(msg, 20, 40);

}
}
Le
Test1.html
<html>
w.
<body>
ww
<applet code=”Test.class” width=”400” height=”300”>

</applet>
</body>
</html>
Sample Output:
n
g.i
rin
ee
Adapter Classes
An adapter class provides the default implementation of all methods in an event listener
gin
interface. Adapter classes are very useful when you want to process only few of the events
that are handled by a particular event listener interface. For example MouseAdapter provides
empty implementation of MouseListener interface. It is useful because very often you do not
En
really use all methods declared by interface, so implementing the interface directly is very
lengthy.
• Adapter class is a simple java class that implements an interface with only EMPTY
arn
implementation.
• Instead of implementing interface if we extends Adapter class ,we provide
implementation only for require method
Le
The adapter classes are found in java.awt.event, java.awt.dnd and javax.swing.

event packages. The Adapter classes with their corresponding listener interfaces are as fol-
w.
lows.
Adapter Class Listener Interface
ww
Window Adapter Window Listener

Key Adapter Key Listener
Mouse Adapter Mouse Listener
Mouse Motion Adapter Mouse Motion Listener
Focus Adapter Focus Listener
Component Adapter Component Listener
Container Adapter Container Listener
HierarchyBoundsAdapter HierarchyBoundsListener
Example:
import java.awt.*;
public class AdapterExample{
Frame f;
AdapterExample(){
n
f=new Frame(“Window Adapter”);
g.i
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) {
rin
f.dispose();
} ee
});
gin
f.setSize(400,400);
f.setLayout(null);
En
f.setVisible(true);
}
arn

new AdapterExample();
}
Le
}
Sample Output:
w.
ww
Actions
The Java Action interface and AbstractAction class are terrific ways of encapsulating be-
haviors (logic), especially when an action can be triggered from more than one place in your
Java/Swing application.
javax.swing
Interface Action
An Action can be used to separate functionality and state from a component. For example,
n
if you have two or more components that perform the same function, consider using an Ac-
tion object to implement the function.
g.i
An Action object is an action listener that provides not only action-event handling, but
also centralized handling of the state of action-event-firing components such as tool bar but-
rin
tons, menu items, common buttons, and text fields. The state that an action can handle in-
cludes text, icon, mnemonic, enabled, and selected status.
ee
The most common way an action event can be triggered from multiple places in a Java/
Swing application is through the Java menubar (JMenuBar) and toolbar (JToolBar)
gin
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
En
import javax.swing.JFrame;
public class ButtonAction {
arn
private static void createAndShowGUI() {

JFrame frame1 = new JFrame(“JAVA Program”);
Le
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JButton button = new JButton(“ << Java Action >>”);
w.
//Add action listener to button

button.addActionListener(new ActionListener() {
ww
public void actionPerformed(ActionEvent e)

{
System.out.println(“You clicked the button”);
}
});
frame1.getContentPane().add(button);
frame1.pack();
frame1.setVisible(true);
}
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
n
g.i
createAndShowGUI();
}
rin
});
} ee
Output:
gin
En
arn
Le
w.
MouseEvent:
An event which indicates that a mouse action occurred in a component. A mouse action
ww
is considered to occur in a particular component if and only if the mouse cursor is over the
unobscured part of the component’s bounds when the action happens. For lightweight com-
ponents, such as Swing’s components, mouse events are only dispatched to the component if
the mouse event type has been enabled on the component.
A mouse event type is enabled by adding the appropriate mouse-based EventListener to
the component (Mouse Listener or Mouse Motion Listener), or by invoking Component.en-
ableEvents (long) with the appropriate mask parameter
(AWTEvent.MOUSE_EVENT_MASK or AWTEvent.MOUSE_MOTION_EVENT_
MASK).
If the mouse event type has not been enabled on the component, the corresponding mouse
events are dispatched to the first ancestor that has enabled the mouse event type.Iif a MouseLis-
tener has been added to a component, or enableEvents(AWTEvent.MOUSE_EVENT_MASK) has
been invoked, then all the events defined by MouseListener are dispatched to the component.
On the other hand, if MouseMotionListener has not been added and enableEvents has not
been invoked with AWTEvent.MOUSE_MOTION_EVENT_MASK, then mouse motion events
n
are not dispatched to the component. Instead the mouse motion events are dispatched to the
g.i
first ancestor that has enabled mouse motion events.
The hierarchy of MouseEvent class is shown below.
rin
ee
gin
En
arn
• Mouse Events are

○ a mouse button is pressed
Le
○ a mouse button is released

○ a mouse button is clicked (pressed and released)
w.
○ the mouse cursor enters the unobscured part of component’s geometry

ww
○ the mouse cursor exits the unobscured part of component’s geometry

• Mouse Motion Events are
○ the mouse is moved
○ the mouse is dragged
A MouseEvent object is passed to every MouseListener or MouseAdapter object which
is registered to receive the “interesting” mouse events using the component’s addMouseLis-
tener method. The MouseAdapter objects implement the MouseListener interface. Each such
listener object gets a MouseEvent containing the mouse event.
A MouseEvent object is also passed to every MouseMotionListener or MouseMotion-

Adapter object which is registered to receive mouse motion events using the component’s ad-
dMouseMotionListener method. (MouseMotionAdapter objects implement the MouseMo-
tionListener interface.) Each such listener object gets a MouseEvent containing the mouse
motion event.
When a mouse button is clicked, events are generated and sent to the registered MouseLis-
teners. The state of modal keys can be retrieved using InputEvent.getModifiers() and InputE-
vent.getModifiersEx(). The button mask returned by InputEvent.getModifiers() reflects only
the button that changed state, not the current state of all buttons.. To get the state of all buttons
n
and modifier keys, use InputEvent.getModifiersEx(). The button which has changed state is
g.i
returned by getButton().
For example, if the first mouse button is pressed, events are sent in the following order:
rin
id modifiers button
MOUSE_PRESSED: BUTTON1_MASK BUTTON1
ee
MOUSE_RELEASED: BUTTON1_MASK BUTTON1
MOUSE_CLICKED: BUTTON1_MASK BUTTON1
gin
When multiple mouse buttons are pressed, each press, release, and click results in a sepa-
rate event.
En
For example, if the user presses button 1 followed by button 2, and then releases them in
the same order, the following sequence of events is generated:
id modifiers button
arn

Le

w.

ww
If button 2 is released first, the MOUSE_RELEASED/MOUSE_CLICKED pair for BUT-

TON2_MASK arrives first, followed by the pair for BUTTON1_MASK.
MOUSE_DRAGGED events are delivered to the Component in which the mouse button
was pressed until the mouse button is released (regardless of whether the mouse position is
within the bounds of the Component). Due to platform-dependent Drag&Drop implementa-
tions, MOUSE_DRAGGED events may not be delivered during a native Drag&Drop opera-
tion.
In a multi-screen environment mouse drag events are delivered to the Component even
if the mouse position is outside the bounds of the Graphics Configuration associated with
that Component. However, the reported position for mouse drag events in this case may differ
from the actual mouse position:
• In a multi-screen environment without a virtual device: The reported coordinates for mouse
drag events are clipped to fit within the bounds of the GraphicsConfiguration associated
with the Component.
• In a multi-screen environment with a virtual device: The reported coordinates for
n

g.i
rin
ee
gin
En
arn
Le
w.
ww

n
g.i
rin
ee
Output:
gin
En
arn
Le
w.
ww
Java AWT Hierarchy

The hierarchy of Java AWT classes are given below.
n
g.i
rin
ee
gin
En
Container
The Container is a component in AWT that can contain another component like buttons,
textfields, labels etc. The classes that extend Container class are known as container such as
arn
Frame, Dialog and Panel.

Window
Le
The window is the container that has no borders and menu bars. You must use frame,
dialog or another window for creating a window.
Panel
w.
The Panel is the container that doesn’t contain title bar and menu bars. It can have other
components like button, textfield etc.
ww
Frame
The Frame is the container that contain title bar and can have menu bars. It can have other
components like button, textfield etc.
The following table gives the methods of Component class:

Method Description
public void add(Component c) inserts a component on this component.
public void setSize(int width,int height) sets the size (width and height) of the compo-
nent.
public void setLayout(Layout Manager defines the layout manager for the component.
m)
public void setVisible(boolean status) changes the visibility of the component, by de-
n
fault false.
g.i
The following programs are the examples of Java AWT:
rin
To create simple awt program, we need to create a frame. There are two ways to create a
frame in AWT.
• By extending Frame class (inheritance)
ee
By creating the object of Frame class (association)
gin
En
arn
Le
w.
ww
Output:
n
g.i
rin
ee
gin

En
arn
Le
w.
ww
Output:
n
g.i
rin
ee
gin
Java Swing
En
Swing was developed to provide a more sophisticated set of GUI components than the
earlier Abstract Window Toolkit (AWT). Swing provides a look and feel that emulates the
look and feel of several platforms, and also supports a pluggable look and feel that allows ap-
arn
plications to have a look and feel unrelated to the underlying platform. It has more powerful
and flexible components than AWT.
In addition to familiar components such as buttons, check boxes and labels, Swing pro-
Le
vides several advanced components such as tabbed panel, scroll panes, trees, tables, and
lists.
Unlike AWT components, Swing components are not implemented by platform-specific
w.
code. Instead, they are written entirely in Java and therefore are platform-independent. The
term “lightweight” is used to describe such an element.
ww
Java Swing is a part of Java Foundation Classes (JFC) that is used to create window-
based applications. It is built on the top of AWT (Abstract Windowing Toolkit) API and
entirely written in java.
Unlike AWT, Java Swing provides platform-independent and lightweight components.
The javax.swing package provides classes for java swing API such as JButton, JText-
Field, JTextArea, JRadioButton, JCheckbox, JMenu, JColorChooser etc.
Swing Features
• Light Weight - Swing component are independent of native Operating System’s
API as Swing API controls are rendered mostly using pure JAVA code instead of
underlying operating system calls.
• Rich controls - Swing provides a rich set of advanced controls like Tree, TabbedPane,
slider, colourpicker, table controls
• Highly Customizable - Swing controls can be customized in very easy way as visual
appearance is independent of internal representation.
n
• Pluggable look-and-feel- SWING based GUI Application look and feel can be
g.i
changed at run time based on available values.
Hierarchy of Java Swing classes
rin
The hierarchy of java swing API is given below.
ee
gin
En
arn
Le
w.
ww
The following program is an example for Java Swing.

import javax.swing.*;
public class FirstSwingExample {
JFrame f=new JFrame();//creating instance of JFrame
Button b=new JButton(“click”);//creating instance of JButton
n
b.setBounds(130,100,100, 40);//x axis, y axis, width, height
g.i
f.add(b);//adding button in JFrame
f.setSize(400,500);//400 width and 500 height
rin
f.setLayout(null);//using no layout managers
f.setVisible(true);//making the frame visible
ee
}
}
gin
Output:
En
arn
Le
w.
ww

CS8392 Object Oriented Programming Notes 1

Uploaded by

CS8392 Object Oriented Programming Notes 1

Uploaded by

www.studymaterialz.

CS8392 OBJECT ORIENTED PROGRAMMING

UNIT I INTRODUCTION TO OOP AND JAVA FUNDAMENTALS

UNIT II INHERITANCE AND INTERFACES

UNIT III EXCEPTION HANDLING AND I/O

UNIT IV MULTITHREADING AND GENERIC PROGRAMMING

UNIT V EVENT DRIVEN PROGRAMMING

Introduction to Oop and Java Fundamentals  1.1

INTRODUCTION TO OOP AND JAVA FUNDAMENTALS

C++ IDLscript Ruby

COBOL Java Simula

Cobra LISP Smalltalk

ColdFusion Objective-C Tcl

Common Lisp Perl since v5

Abstraction is one of the key concepts of object-oriented programming (OOP) languages.

A powerful way to manage abstraction is through the use of hierarchical classifications.

as behaviors – wagging the tail, barking, eating. An object is an instance of a class.

fields and behavior is shown via methods.

Following is an example of a class.

• Each method or variable in a class may be marked private or public.

Introduction to Oop and Java Fundamentals  1.5

Variables (Static Attributes) name, gender, dept, marks radius, color

(Dynamic Behaviors) calculateGrade() printArea()

Name (or identity): identifies the class.

1.6  Object Oriented Programming

John : Student Priya : Student Anil : Student

Interface in Java is a collection of abstract methods and static constants. In an interface,

So an interface is a group of related methods with empty bodies.

A java class is the example of encapsulation.

Polymorphism in Java is of two types:

run time polymorphism:

is resolved at runtime rather than at compile-time. Method overriding is an example of run

In Java, compile time polymorphism refers to a process in which a call to an overloaded

of compile time polymorphism.

1.10  Object Oriented Programming

• Java is machine independent.

• Java supports cross-platform code through the use of Java bytecode.

User interface toolkits Abstract Window Toolkit (AWT)

Drag and Drop (DnD)

Java Database Connectivity (JDBC)

base libraries International support

1.5 Java vIRtual machINe (Jvm)

1.6 setting uP an envirOnment fOr java

setting up the Path for Windows

• Right-click on ‘My Computer’ and select ‘Properties’.

1.7 POPuLar java editOrs

To write Java programs, we need any of the following:

1.8 java sOurce fiLe structure

Figure: Java Source File Structure

An optional package declaration to specify a package name.

public void travel();

Part 2: Zero or More import Declarations

the compiler to find the specified class.

We may import a single class or all the classes belonging to a package.

Examples of the import statement:

.java extension at the end.

classes in the source file.

Java code needs to be compiled twice in order to be executed:

interpreting and running the Program

Quick compilation procedure

Save the file as HelloWorld.java.

Windows; and, Terminal on Linux and Mac OS.

1.10 fundamentaL PrOgramming structures in java

//Comment //This is single line comment

continues multi line

*tags are used in order to specify a parameter

*or method or heading

Figure: Data types in java

the Primitive types

name Width in bits range

double 64 4.9e–324 to 1.8e+308

variable is assigned with a datatype. It is name of reserved area allocated in memory. In

Fig. Types of variables

○ numbers, the default value is 0,

○ Object references it is null.

• Instance variables cannot be declared as static.