Page 1

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 Templates
Difference between error and exception
Errors indicate serious problems and abnormal conditions that most applicationsshould not try
to handle. Error defines problems that are not expected to be caught under normal circumstances
by our program. For example memory error, hardware error, JVM error etc.
Exceptions are conditions within the code. A developer can handle such conditionsand take
necessary corrective actions. Few examples
 DivideByZero exception
 NullPointerException
 ArithmeticException
 ArrayIndexOutOfBoundsException

 An exception (or exceptional event) is a problem that arises during the execution of a
program.

 When an Exception occurs the normal flow of the program is disrupted and the
program/Application terminates abnormally, which is not recommended,
therefore, these exceptions are to be handled.
 If an exception is raised, which has not been handled by programmer then program
execution can get terminated and system prints a non user friendly error message.

Ex: Exception in thread "main" java.lang.ArithmeticException: / by zero at

ExceptionDemo.main(ExceptionDemo.java:
1)

Where, ExceptionDemo : The class name

main : The method name ExceptionDemo.java : The filename
java:5 : Line number
An exception can occur for many different reasons. Following are some scenarios
where an exception occurs.
  A user has entered an invalid data.

 A file that needs to be opened cannot be found.

 A network connection has been lost in the middle of communications or the JVM

hasrun out of memory.

Exception Hierarchy
All exception classes are subtypes of the java.lang.Exception class. The exception class is
a subclass of the Throwable class.

Key words used in Exception handling

There are 5 keywords used in java exception handling.

1. try A try/catch block is placed around the code that might generate an
exception. Code within a try/catch block is referred to as protected code.

A catch statement involves declaring the type of exception we are trying

2. catch to catch.

A finally block of code always executes, irrespective of occurrence of an

3. finally Exception.

4. throw It is used to execute important code such as closing connection, stream

etc. throw is used to invoke an exception explicitly.

5. throws throws is used to postpone the handling of a checked

 //Example-predefined Excetion - for
try //ArrayindexoutofBounds Exception
{ public class ExcepTest
//Protected code {
} public static void main(String args[])
{ int a[] = new int[2];
catch(ExceptionType1 e1) try
{ System.out.println("Access element three :" +
{ a[3]);
//Catch block }
} catch(ArrayIndexOutOfBoundsException e)
catch(ExceptionType2 e2) { System.out.println("Exception thrown :" +
e); { }
//Catch block finally
}
catch(ExceptionType3 e3) System.out.println("First element value: " + a[0]);
System.out.println("The finally statement is
{ executed");
//Catch block }
} }
}
finally
{
Output
Exception thrown :
//The finally block always executes.
java.lang.ArrayIndexOutOfBoundsException:3
}
First element value: 6
The finally statement is executed
Note : here array size is 2 but we are trying to access
3rdelement.

Uncaught Exceptions
This small program includes an expression that intentionally causes a divide-by- zero error: class
Exc0 { public static void main(String args[]) { int d = 0; int a =42 / d; } } When the Java run-time
system detects the attempt to divide by zero, it constructs a new exception object and then throws
this exception. This causes the execution of Exc0 to stop, because once an exception has been
thrown, it must be caught by an exception handler and dealt with immediately

Any exception that is not caught by your program will ultimately be processed by the default
handler. The default handler displays a string describing the exception, prints a stack trace from
the point at which the exception occurred, and terminates the program. Here is the exception
generated when this example is executed:
java.lang.ArithmeticException: / by zero at Exc0.main(Exc0.java:4)

Stack Trace:
Stack Trace is a list of method calls from the point when the application was started to the point
where the exception was thrown. The most recent method calls are at the top. A stacktrace is a
very helpful debugging tool. It is a list of the method calls that the application was in the middle
of when an Exception was thrown. This is very useful because it doesn't only show you
where the error happened, but also how the program ended up in that place of the code.
Using try and Catch
To guard against and handle a run-time error, simply enclose the code that you want to monitor
inside a try block. Immediately following the try block, include a catch clause that specifies the
exception type that you wish to catch. A try and its catch statement form a unit. The the following
program includes a try block and a catch clause that processes the ArithmeticException generated
by the division-by-zero error:

class Exc2 {
public static void main(String args[]) { int d, a;
try { // monitor a block of code. d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
} catch (ArithmeticException e) { // catch divide-by-zero error
System.out.println("Division by zero.");
}
System.out.println("After catch statement.");
}
}
This program generates the following output:
Division by zero.
After catch statement.
The call to println( ) inside the try block is never executed. Once an exception is thrown, program
control transfers out of the try block into the catch block.

Multiple catch Clauses

In some cases, more than one exception could be raised by a single piece of code. To handle this
type of situation, you can specify two or more catch clauses, each catching a different type of
exception. When an exception is thrown, each catch statement 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: //

Demonstrate multiple catch statements.
class MultiCatch {
public static void main(String args[])
{
try {
int a = args.length; System.out.println("a
= " + a); int b = 42 / a;
int c[] = { 1 }; c[42] =
99;
} catch(ArithmeticException e) { System.out.println("Divide by 0: "
+ e);
} catch(ArrayIndexOutOfBoundsException e)
{ System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}

Here is the output generated by running it both ways:

C:\>java MultiCatch a = 0
Divide by 0: java.lang.ArithmeticException: / by zero After try/catch
blocks.
C:\>java MultiCatch TestArg a = 1

Nested try Statements

The try statement can be nested. That is, a try statement can be inside the block of another try.
Each time a try statement is entered, the context of that exception is pushed on the stack. If an
inner try statement does not have a catch handler for a particular exception, the stack is unwound
and the next try statement’s catch handlers are inspected for a match. This continues until one of
the catch statements succeeds, or until all of the nested try statements are exhausted. If no catch
statement matches, then the Java run-time system will handle the exception.

// An example of nested try statements. class

NestTry {
public static void main(String args[]) { try {
int a = args.length;
/* If no command-line args are present, the following statement will generate
a divide-by-zero exception. */
int b = 42 / a;
System.out.println("a = " + a);
try {
// nested try block
/* If one command-line arg is used, then a divide-by-zero exception
will be generated by the following code. */
if(a==1) a = a/(a-a);
// division by zero
/* If two command-line args are used, then generate an out-of-bounds exception. */
if(a==2)
{
int c[] = { 1 };

c[42] = 99; // generate an out-of-bounds exception

}
}

catch(ArrayIndexOutOfBoundsException e) {

System.out.println("Array index out-of-bounds: " + e);

}
} catch(ArithmeticException e)

System.out.println("Divide by 0: " + e);

}}}
C:\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by zero C:\
>java NestTry One
a=1
Divide by 0: java.lang.ArithmeticException: / by zero C:\
>java NestTry One Two
a=2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException:
42
throw
it is possible for your program to throw an exception explicitly, using the throw statement.
The general form of throw is shown here:

throw ThrowableInstance;
Here, ThrowableInstance must be an object of type Throwable or a subclass of Throwable.

Primitive types, such as int or char, as well as non-Throwable classes, such as String and
Object, cannot be used as exceptions. There are two ways you can obtain a Throwable object:
using a parameter in a catch clause, or creating one with the new operator.
The flow of execution stops immediately after the throw statement; any subsequent statements are
not executed. The nearest enclosing try block is inspected to see if it has a catch statement that
matches the type of exception. If it does find a match, control is transferred 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 the stack trace
// Demonstrate throw. class
ThrowDemo { static void
demoproc() { try {
throw new NullPointerException("demo");
} catch(NullPointerException e)
{ System.out.println("Caught inside demoproc."); throw e; //
rethrow the exception
}
}
public static void main(String args[]) { try {
demoproc();
} catch(NullPointerException e) { System.out.println("Recaught: " +
e);
}
}
}

Here is the resulting output:

Caught inside demoproc.
Recaught: java.lang.NullPointerException: demo
Throws
If a method is capable of causing an exception that it does not handle, it must specify this
behaviour so that callers of the method can guard themselves against that exception. You do this
by including a throws clause in the method’s declaration. A throws clause lists the types of
exceptions that a method might throw. This is necessary for all exceptions, except those of type
Error or RuntimeException, or any of their subclasses. All other exceptions that a method can
throw must be declared in the throws clause. This is the general form of a method declaration that
includes a throws clause:
type method-name(parameter-list) throws exception-list
{
// body of method
}
Here, exception-list is a comma-separated list of the exceptions that a method can throw.

class ThrowsDemo {
static void throwOne() throws IllegalAccessException { System.out.println("Inside
throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[]) { try {
throwOne();
} catch (IllegalAccessException e) {

System.out.println("Caught " + e);

}
}
}
Here is the output generated by running this example program: inside
throwOne
caught java.lang.IllegalAccessException: demo

finally
The finally keyword is designed to address this contingency. finally creates a block of code that will be
executed after a try/catch block has completed and before the code following the try/catch block. The
finally block will execute whether or not an exception is thrown. If an exception is
If an exception is thrown, the finally block will execute even if no catch statement matches the
exception. Any time a method is about to return to the caller from inside a try/catch block, via an
uncaught exception or an explicit return statement, the finally clause is also executed just before
the method returns. This can be useful for closing file handles and freeing up any other resources
that might have been allocated at the beginning of a method with the intent of disposing of them
before returning. The finally clause is optional.
// Demonstrate finally. class
FinallyDemo {
// Through an exception out of the method. static
void procA() {
try {
System.out.println("inside procA"); throw
new
System.out.println("procA's finally");
}
}
// Return from within a try block. static void
procB() {
try {
System.out.println("inside procB"); return;
} finally { System.out.println("procB's
finally");
}
}
// Execute a try block normally. static
void procC() {
try {
System.out.println("inside procC");
} finally { System.out.println("procC's
finally");
}
}
public static void main(String args[]) { try {
procA();
} catch (Exception e)
{ System.out.println("Exception caught");
}
procB();
procC();
}
}
Here is the output generated by the preceding program: inside
procA
procA’s finally
Exception caught inside
procB procB’s finally
inside procC procC’s
finally

Categories of Exceptions
Checked exceptions −A checked exception is an exception that occurs at the compiletime, these
are also called as compile time exceptions. These exceptions cannot simply be ignored at the
time of compilation, the programmer should take care of (handle) these exceptions.
Unchecked exceptions − An unchecked exception is an exception that occurs at thetime of
execution. These are 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.

Common scenarios where exceptions may occur:

There are given some scenarios where unchecked exceptions can occur. They are as follows:
1) Scenario where ArithmeticException occurs
If we divide any number by zero, there occurs an ArithmeticException. int
a=50/0;//ArithmeticException

2) Scenario where NullPointerException occurs

 If we have null value in any variable, performing any operation by the variable occurs an
NullPointerException.
String s=null; System.out.println(s.length());// NullPointerException

3) Scenario where ArrayIndexOutOfBoundsException occurs

If you are inserting any value in the wrong index, it would result
ArrayIndexOutOfBoundsException as shown below:
int a[]=new int[5];
a[10]=50; //ArrayIndexOutOfBoundsException

Java’s Built-in Exceptions User-

defined Exceptions
All exceptions must be a child of Throwable.
If we want to write a checked exception that is automatically enforced by the Handle ,we need to
extend the Exception class.

User defined exception needs to inherit (extends) Exception class in order to act as an
exception.
throw keyword is used to throw such exceptions.

class MyOwnException extends Exception

{ public
MyOwnException(String msg) { super(msg);
}
}
class EmployeeTest {
static void employeeAge(int age) throws
MyOwnException { if(age < 0)
throw new MyOwnException("Age can't be less than zero"); else
System.out.println("Input is valid!!");
}
public static void main(String[] args)
{
try { employeeAge(-2);
}
catch (MyOwnException e)
{
e.printStackTrace();
}
}
}

Advantages of Exception Handling

Exception handling allows us to control the normal flow of the program by using exception
handling in program.
It throws an exception whenever a calling method encounters an error providing that
the calling method takes care of that error.
It also gives us the scope of organizing and differentiating between different error types using a
separate block of codes. This is done with the help of try-catch blocks.
IO IN JAVA

Java I/O (Input and Output) is used to process the input and produce the output based
on the input. Java uses the concept of stream to make I/O operation fast. The java.io
package contains all the classes required for input and output operations.

Stream
A stream can be defined as a sequence of data. there are two kinds of Streams
 InputStream: The InputStream is used to read data from a source.
 OutputStream: the OutputStream is used for writing data to a
destination.
Byte Streams
Java byte streams are used to perform input and output of 8-bit bytes FileInputStream ,
FileOutputStream.
Character Streams
Java Character streams are used to perform input and output for 16-bit unicode. FileReader
, FileWriter

Standard Streams
 Standard Input: This is used to feed the data to user's program and
usually a keyboard is used as standard input stream and represented as System.in.
 Standard Output: This is used to output the data produced by the user's
program and usually a computer screen is used to standard output stream and
represented as System.out.
  Standard Error: This is used to output the error data produced by the user's
program and usually a computer screen is used to standard error stream and represented as
System.err.

Classification of Stream Classes:

Byte Stream Classes:

ByteStream classes have been designed to provide functional features for creating and manipulating
streams and files for reading and writing bytes. Since the streams are unidirectional, they can
transmit bytes in only one direction and therefore, Java provides two kinds of byte stream classes:
InputStream class and OutputStream class.
Input Stream Classes
Input stream classes that are used to read 8-bit bytes include a super class known as InputStream and
number of subclasses for supporting various input- related functions.
Hierarchy of Input Stream Classes
The super class InputStream is an abstract class, so we cannot create object for the class.
InputStream class defines the methods to perform the following functions:-
 Reading Bytes
 Closing Streams
 Marking position in
Streams 
Skipping ahead in streams
 Finding the number of bytes in
stream.

The DataInput interface contains the following methods

OutputStream Class
The super class InputStream is an abstract class, so we cannot create object for the class.
InputStream class defines the methods to perform the following functions:
 Writing Bytes
 Closing Streams
 Flushing
Streams
Hierarchy of OutputStream Classes
OutputStream Methods

Character Stream Vs Byte Stream in Java I/O Stream

A stream is a method to sequentially access a file. I/O Stream means an input source or output
destination representing different types of sources e.g. disk files.The java.io package provides
classes that allow you to convert between Unicode character streams and byte streams of non-
Unicode text.
Stream: A sequence of data.
Input Stream: reads data from source. Output Stream:
writes data to destination. Character Stream
In Java, characters are stored using Unicode conventions (Refer this for details). Character stream
automatically allows us to read/write data character by character. For example FileReader and
FileWriter are character streams used to read from source andwrite to destination.

// Java Program illustrating that we can read a file in

// a human readable format using FileReader
importjava.io.*; // Accessing FileReader, FileWriter, IOException
publicclassGfG
{
publicstaticvoidmain(String[] args) throwsIOException
{
FileReader sourceStream = null; try
{
sourceStream = newFileReader("test.txt");
// Reading sourcefile and writing content to
// target file character by character. inttemp;
while((temp = sourceStream.read()) != -1)
System.out.println((char)temp);
}
finally
{
// Closing stream as no longer in use if(sourceStream != null)
sourceStream.close();
}
}
}

Reading and Writing Files:

A stream can be defined as a sequence of data. The InputStream is used to read data from a
source and the OutputStream is used for writing data to a destination.
TheInputStream is used to read data from a source and the OutputStream is used for writing
data to a destination.The two important streams are FileInputStream and
FileOutputStream
Here is a hierarchy of classes to deal with Input and Output streams.
FileInputStream
This stream is used for reading data from the files. Objects can be created using the keyword new
and there are several types of constructors available.
Following constructor takes a file name as a string to create an input stream object to read the
file –
 InputStream f = new FileInputStream("C:/java/hello");

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);
Once you have InputStream object in hand, then there is a list of helper methods which can be used
to read to stream or to do other operations on the stream.
Example:
import java.io.*;
class C{
public static void main(String args[])throws
Exception{ FileInputStream fin=new
FileInputStream("C.java"); FileOutputStream fout=new
FileOutputStream("M.java"); int i=0; while((i=fin.read())!=-
1){ fout.write((byte)i);
}
fin.close();
}
}

Byte Stream
Byte streams process data byte by byte (8 bits). For example FileInputStream is used to read from
source and FileOutputStream to write to the destination.
// Java Program illustrating the Byte Stream to copy
// contents of one file to another file.
importjava.io.*; publicclassBStream
{
Public static void main(String[] args) throws IOException {
FileInputStream sourceStream = null;
FileOutputStream targetStream = null; try
{
sourceStream = newFileInputStream("sorcefile.txt");
targetStream = newFileOutputStream ("targetfile.txt");

// Reading source file and writing content to target // file byte by byte
inttemp;
while((temp = sourceStream.read()) != -1)
targetStream.write((byte)temp);
}
finally
{
if(sourceStream != null)
sourceStream.close(); if(targetStream != null)
targetStream.close();
}
Final Keyword In Java – Final variable, Method and Class
final keyword can be used along with variables, methods and classes.
1) final variable

2) final method

3) final class
1) final variable
final variables are nothing but constants. We cannot change the value of a final variable once it is
initialized. Lets have a look at the below code:
classDemo{
finalint MAX_VALUE=99; void
myMethod(){
MAX_VALUE=101;
}
Public static void main(String args[]){ Demo
obj=newDemo();
obj.myMethod();
}
}
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The final field Demo.MAX_VALUE cannot be assigned at
beginnersbook.com.Demo.myMethod(Details.java:6) at
beginnersbook.com.Demo.main(Details.java:10)
We got a compilation error in the above program because we tried to change the
value of a final variable “MAX_VALUE”.
2) final method
A final method cannot be overridden. Which means even though a sub class can call the final
method of parent class without any issues but it cannot override it. Example:
class XYZ{
finalvoid demo(){ System.out.println("XYZ Class
Method");
}
}
class ABC extends XYZ{ void demo()
{
System.out.println("ABC Class Method");
}
public static void main(String args[]){ ABC
obj=new ABC(); obj.demo();
}
}
The above program would throw a compilation error, however we can use the parent class final
method in sub class without any issues. Lets have a look at this code: This program would run
fine as we are not overriding the final method. That shows that final methods are inherited but
they are not eligible for overriding.
class XYZ{ finalvoid
demo(){
System.out.println("XYZ Class Method");
}
}
class ABC extends XYZ{
public static void main(String args[]){ ABC
obj=new ABC(); obj.demo();
}
}
Output:
XYZ ClassMethod
3) final class
We cannot extend a final class. Consider the below example: finalclass XYZ{
}
class ABC extends XYZ{ void demo()
{
System.out.println("My Method");
}
Public static void main(String args[]){ ABC
obj=new ABC(); obj.demo();
}
}
Output:
The type ABC cannot subclass the final class XYZ
UNIT IV
MULTITHREADING AND GENERIC PROGRAMMING

Differences between multithreading and multitasking , thread life cycle, creating

threads, creating threads, synchronizing threads, Inter-thread communication,
daemon threads, thread groups. Generic Programming - Generic classes-
generic methods-Bounded Types-Restrictions and Limitations

Thread:
A thread is a single sequential (separate) flow of control within program.
Sometimes, it is called an execution context or light weight process.
Multithreading
Multithreading is a conceptual programming concept where a program (process)
is divided into two or more subprograms (process), which can be implemented
at the same time in parallel. A multithreaded program contains two or more
parts that can run concurrently. Each part of such a program is called a thread,
and each thread defines a separate path of execution.
Multitasking
Executing several tasks simultaneously is called multi-tasking.
There are 2 types of multi-tasking
1. Process-based multitasking
2. Thread-based multi-tasking
1. Process-based multi-tasking
Executing various jobs together where each job is a separate independent
operation is called process-based multi-tasking.
2. Thread-based multi-tasking
Executing several tasks simultaneously where each task is a separate
independent part of the same program is called Thread-based multitasking and
each independent part is called Thread. It is best suitable for the programmatic
level. The main goal of multi-tasking is to make or do a better performance of
the system by reducing response time
Multithreading vs Multitasking
Multitasking is to run multiple
Multithreading is to execute multiple
processes on a computer
threads in a process concurrently.
concurrently.

Execution

In Multithreading, the CPU switches In Multitasking, the CPU switches

between multiple threads in the same between multiple processes to
process. complete the execution.

Resource Sharing
In Multithreading, resources are
In Multitasking, resources are shared
shared among multiple threads in a
among multiple processes.
process.

Complexity
Multithreading is light-weight and Multitasking is heavy-weight and
easy to create. harder to create.

Life Cycle of Thread

A thread can be in any of the five following states
1. Newborn State:
When a thread object is created a new thread is born and said to be in
Newborn state.
2. Runnable State:
If a thread is in this state it means that the thread is ready for execution
and waiting for the availability of the processor. If all threads in queue are of
same priority then they are given time slots for execution in round robin fashion
3. Running State:
It means that the processor has given its time to the thread for
execution. A thread keeps running until the following conditions occurs
(a) Thread give up its control on its own and it can happen in the following
situations
i.A thread gets suspended using suspend() method which can only
be revived with resume() method
ii.A thread is made to sleep for a specified period of time using
sleep(time) method, where time in milliseconds
iii.A thread is made to wait for some event to occur using wait ()
method. In this case a thread can be scheduled to run again using notify ()
method.
(b) A thread is pre-empted by a higher priority thread
4. Blocked State:
If a thread is prevented from entering into runnable state and
subsequently running state, then a thread is said to be in Blocked state.
5. Dead State:
A runnable thread enters the Dead or terminated state when it completes its
task or otherwise
The Main Thread
When we run any java program, the program begins to execute its code
starting from the main method. Therefore, the JVM creates a thread to start
executing the code present in main method. This thread is called as main thread.
Although the main thread is automatically created, you can control it by
obtaining a reference to it by calling currentThread() method.
Two important things to know about main thread are,
 It is the thread from which other threads will be produced.
 main thread must be always the last thread to finish execution.
class MainThread
{
public static void main(String[] args)
{
Thread t1=Thread.currentThread();
t.setName("MainThread");
System.out.println("Name of thread is "+t1);
}
}
Output:
Name of thread is Thread[MainThread,5,main]

Creation Of Thread
Thread Can Be Implemented In Two Ways
1) Implementing Runnable Interface
2) Extending Thread Class

1. Create Thread by Implementing Runnable

The easiest way to create a thread is to create a class that implements the
Runnable interface. To implement Runnable, a class need only implement a
single method called run()
Example:
public class ThreadSample implements
Runnable {
public void
run() {
try
{
for (int i = 5; i > 0;
i--) {
System.out.println("Child Thread" + i);
Thread.sleep(1000);
}
}
catch (InterruptedException
e) {
System.out.println("Child
interrupted"); }
 System.out.println("Exiting Child Thread");
}
}
public class MainThread
{
public static void main(String[] arg)
{
ThreadSample d = new ThreadSample();
Thread s = new Thread(d);
s.start();
try
{
for (int i = 5; i > 0; i--)
{
System.out.println("Main Thread" + i);
Thread.sleep(5000);
}
}
catch (InterruptedException e)
{
System.out.println("Main interrupted");
}
System.out.println("Exiting Main Thread");
}}
2. Extending Thread Class
The second 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.
Example:
public class ThreadSample extends Thread
{
public void run()
{
try
{
for (int i = 5; i > 0; i--)
{
System.out.println("Child Thread" + i);
Thread.sleep(1000);
}
}
catch (InterruptedException e)
{
System.out.println("Child interrupted");
}
System.out.println("Exiting Child Thread");
}
}
public class MainThread
{
public static void main(String[] arg)
{
ThreadSample d = new ThreadSample();
d.start();
try
{
 for (int i = 5; i > 0; i--)
{
System.out.println("Main Thread" + i);
Thread.sleep(5000);
}
}
catch (InterruptedException e)
{
System.out.println("Main interrupted");
}
System.out.println("Exiting Main Thread");
}
}
Thread priority:
Each thread have 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 preemptive scheduling).
But it is not guaranteed because it depends on JVM specification that
which scheduling it chooses.
3 constants defined in Thread class:
public static int MIN_PRIORITY
public static int
NORM_PRIORITY public static
int MAX_PRIORITY
Default priority of a thread is 5 (NORM_PRIORITY). The value of
MIN_PRIORITY is 1 and the value of MAX_PRIORITY is 10.
Example :
public class MyThread1 extends Thread
{ MyThread1(String s)
{
 super(s);
start();
}
public void run()
{
for(int i=0;i<5;i++)
{
Thread cur=Thread.currentThread();
cur.setPriority(Thread.MAX_PRIORITY);
int p=cur.getPriority();
System.out.println("Thread
Name"+Thread.currentThread().getName());
System.out.println("Thread Priority"+cur);
}
}
}
class MyThread2 extends Thread
{ MyThread2(String s)
{
super(s);
start();
}
public void run()
{
for(int i=0;i<5;i++)
{
Thread cur=Thread.currentThread();
cur.setPriority(Thread.MIN_PRIORITY);
System.out.println(cur.getPriority());
 int p=cur.getPriority();
System.out.println("Thread
Name"+Thread.currentThread().getName());
System.out.println("Thread
Priority"+cur); }
}
}
public class ThreadPriority {
public static void main(String[]
args) {
MyThread1 m1=new
MyThread1("MyThread1"); MyThread2
m2=new MyThread2("MyThread2");
}
}
Synchronizing Threads
o Synchronization in java is the capability to control the access of
multiple threads to any shared resource.
o Java Synchronization is better option where we want to allow only
one thread to access the shared resource

General Syntax :
synchronized(object)
{
//statement to be
synchronized }
Why use Synchronization
The synchronization is mainly used to
o To prevent thread interference.
o To prevent consistency
problem.
 Types of Synchronization
There are two types of synchronization
 Process Synchronization 
Thread Synchronization
Thread Synchronization
There are two types of thread synchronization mutual exclusive and inter-thread
communication.
1. Mutual Exclusive
 Synchronized
method.  Synchronized
block.
 static
synchronization.
2. Cooperation (Inter-thread communication in java)

Synchronized method
 If you declare any method as synchronized, it is known as synchronized
method.
 Synchronized method is used to lock an object for any shared resource.
 When a thread invokes a synchronized method, it automatically acquires
the lock for that object and releases it when the thread completes its task.
Example of synchronized method
package Thread; public
class SynThread {
public static void main(String
args[]) {
share s = new share();
MyThread m1 = new MyThread(s,
"Thread1"); MyThread m2 = new
MyThread(s, "Thread2");
 MyThread m3 = new MyThread(s, "Thread3");
}
}
class MyThread extends Thread
{
share s;
MyThread(share s, String str)
{
super(str);
this.s = s;
start();
}
public void run()
{
s.doword(Thread.currentThread().getName());
}
}
class share
{
public synchronized void doword(String str)
{
for (int i = 0; i < 5; i++)
{
System.out.println("Started:" + str);
try
{
Thread.sleep(1000);
}
catch (Exception e)
 {
}}}}
Synchronized block.
 Synchronized block can be used to perform synchronization on any
specific resource of the method.
 Suppose you have 50 lines of code in your method, but you want to
synchronize only 5 lines, you can use synchronized block.
 If you put all the codes of the method in the synchronized block, it will
work same as the synchronized method.
Example of synchronized block
class Table{
void printTable(int n)
{ synchronized(this){//synchronized
block for(int i=1;i<=5;i++){
System.out.println(n*i);
try{
Thread.sleep(400);
}catch(Exception e){System.out.println(e);}
}
}
}//end of the method
}
class MyThread1 extends
Thread{ Table t;
MyThread1(Table t){
this.t=t;
}
public void run(){
t.printTable(5);
}
}
class MyThread2 extends
Thread{ Table t;
MyThread2(Table t){
this.t=t;
}
public void run(){
t.printTable(100);
}
}
public class
TestSynchronizedBlock1{ public static
void main(String args[]){ Table obj = new
Table();//only one object MyThread1
t1=new MyThread1(obj); MyThread2
t2=new MyThread2(obj); t1.start();
t2.start();
}
}
Static synchronization
If you make any static method as synchronized, the lock will be on the
class not on object.
Example of static synchronization
In this example we are applying synchronized keyword on the static
method to perform static synchronization.
class Table{
synchronized static void printTable(int n)
{ for(int i=1;i<=10;i++){
 System.out.println(n*i);
try{
Thread.sleep(400);
}catch(Exception e){}
}
}
}
class MyThread1 extends
Thread{ public void run(){
Table.printTable(1);
}
}
class MyThread2 extends
Thread{ public void run(){
Table.printTable(10);
}
}
class MyThread3 extends
Thread{ public void run(){
Table.printTable(100);
}
}
class MyThread4 extends
Thread{ public void run(){
Table.printTable(1000);
}
}
public class
TestSynchronization4{ public static
void main(String t[]){
MyThread1 t1=new
MyThread1(); MyThread2
t2=new MyThread2();
MyThread3 t3=new
MyThread3(); MyThread4
t4=new MyThread4(); t1.start();
t2.start();
t3.start();
t4.start();
}
}
Inter-thread communication
Inter-thread communication or Co-operation is all about allowing
synchronized threads to communicate with each other.
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 critical section to be executed.It is implemented by following methods
of Object class:
 wait()
 notify()
 notifyAll()
wait()
tells calling thread to give up monitor and go to sleep until some
other thread enters the same monitor and call notify.
notify()
wakes up a thread that called wait() on same
object. notifyAll()
wakes up all the thread that called wait() on same object.
wait() sleep()

wait() method releases the lock sleep() method doesn't release the
lock.

is the method of Object class is the method of Thread class

is the non-static method is the static method

should be notified by notify() or after the specified amount of

notifyAll() methods time, sleep is completed.

Example of inter thread communication in java

class Customer{
int
amount=10000;
synchronized void withdraw(int amount)
{ System.out.println("going to withdraw...");
if(this.amount<amount){
System.out.println("Less balance; waiting for deposit...");
try{wait();}catch(Exception e){}
}
this.amount-=amount;
System.out.println("withdraw completed...");
}
synchronized void deposit(int amount)
{ System.out.println("going to
deposit..."); this.amount+=amount;
System.out.println("deposit completed...
");
}
}
class Test{
public static void main(String args[]){
final Customer c=new Customer();
new Thread(){
public void run(){c.withdraw(15000);}
}.start();
new Thread(){
public void run(){c.deposit(10000);}
}.start();
}}
Daemon Thread in Java
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.
Example:
public class TestDaemonThread1 extends
Thread{ public void run(){
if(Thread.currentThread().isDaemon()){//checking for daemon thread
System.out.println("daemon thread work");
}
else{
System.out.println("user thread work");
}
}
public static void main(String[] args){
TestDaemonThread1 t1=new TestDaemonThread1();//creating thread
TestDaemonThread1 t2=new TestDaemonThread1();
 TestDaemonThread1 t3=new TestDaemonThread1();
t1.setDaemon(true);//now t1 is daemon thread
t1.start();//starting threads
t2.start();
t3.start();
}
}

Thread Group
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.
Constructors of ThreadGroup class
There are only two constructors of ThreadGroup class.
1. ThreadGroup(String name)-creates a thread group with given
name.
2. ThreadGroup(ThreadGroup parent, String name)-creates a
thread group with given parent group and name.
Important methods of ThreadGroup class
There are many methods in ThreadGroup class. A list of
important methods are given below.

1) int activeCount()-returns no. of threads running in current group.

2) int activeGroupCount()-returns a no. of active group in this thread
group.
3) void destroy()-destroys this thread group and all its sub groups.
4) String getName()-returns the name of this group.
5)ThreadGroup getParent()-returns the parent of this
group.
6) void interrupt()-interrupts all threads of this group.
 7) void list()-prints information of this group to standard console.

Let's see a code to group multiple threads. ThreadGroup

tg1 = new ThreadGroup("Group A"); Thread t1 = new
Thread(tg1,new MyRunnable(),"one");
Thread t2 = new Thread(tg1,new MyRunnable(),"two");
Thread t3 = new Thread(tg1,new MyRunnable(),"three");

Now all 3 threads belong to one group. Here, tg1 is the thread group
name, MyRunnable is the class that implements Runnable interface and "one",
"two" and "three" are the thread names.
Now we can interrupt all threads by a single line of
code only.
Thread.currentThread().getThreadGroup().interrupt();

ThreadGroup Example
public class ThreadGroupDemo implements
Runnable{ public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
ThreadGroupDemo runnable = new ThreadGroupDemo();
ThreadGroup tg1 = new ThreadGroup("Parent ThreadGroup");
Thread t1 = new Thread(tg1, runnable,"one");
t1.start();
Thread t2 = new Thread(tg1, runnable,"two"); t2.start();
Thread t3 = new Thread(tg1, runnable,"three");
t3.start();
 System.out.println("Thread Group Name:
"+tg1.getName()); tg1.list();
}
}
Output:

one
two
three
Thread Group Name: Parent ThreadGroup
java.lang.ThreadGroup[name=Parent
ThreadGroup,maxpri=10]
Thread[one,5,Parent ThreadGroup]
Thread[two,5,Parent ThreadGroup]
Thread[three,5,Parent ThreadGroup]

Generic Programming
Generic programming enables the programmer to create
classes,interfaces and methods that automatically works with all types of
data(Integer, String, Float etc). It has expanded the ability to reuse the code
safely and easily. Advantage of Java Generics
There are mainly 3 advantages of generics. They are as follows:
1) Type-safety : We can hold only a single type of objects in generics. It doesn’t
allow to store other objects.
2) Type casting is not required: There is no need to typecast the object.
3)Compile-Time Checking: It is checked at compile time so problem will not
occur at runtime. The good programming strategy says it is far better to handle
 Generic class
 A class that can refer to any type is known as generic class.
 Generic class declaration defines set of parameterized type one for
each possible invocation of the type parameters
Example:
class TwoGen<T, V>
{
T ob1;
V ob2;
TwoGen(T o1, V o2)
{
ob1 = o1; ob2
= o2;
}
void showTypes() {
System.out.println("Type of T is " + ob1.getClass().getName());
System.out.println("Type of V is " + ob2.getClass().getName());
}
T getob1()
{
return ob1;
}

V getob2()
{
return ob2;
}
}
public class MainClass
{
public static void main(String args[])
{
TwoGen<Integer, String> tgObj = new TwoGen<Integer,
String>(88,"Generics");
tgObj.showTypes();
int v = tgObj.getob1();
System.out.println("value: " + v);
String str = tgObj.getob2();
System.out.println("value: " + str);
}
}

Generic Method
Like generic class, we can create generic method that can accept any type
of argument.
public class TestGenerics4{
public static < E > void printArray(E[] elements)
{ for ( E element : elements){
System.out.println(element );
}
System.out.println();
}
public static void main( String args[] )
{ Integer[] intArray = { 10, 20, 30, 40, 50 };
Character[] charArray = { 'J', 'A', 'V', 'A'};
System.out.println( "Printing Integer Array"
); printArray( intArray );
System.out.println( "Printing Character Array" );
 printArray( charArray );
}
}
Bounded type
The type parameters could be replaced by any class type. This is fine for
many purposes, but sometimes it is useful to limit the types that can be passed
to a type parameter
Syntax :
<T extends superclass>
Example
class Stats<T extends Number>
{ T[] nums;
Stats(T[] o)
{ nums = o;}
double average()
{ double sum =
0.0;
for(int i=0; i < nums.length; i+
+) sum +=
nums[i].doubleValue(); return
sum / nums.length;
}
}
public class MainClass {
public static void main(String args[]) {
Integer inums[] = { 1, 2, 3, 4, 5 };
Stats<Integer> iob = new
Stats<Integer>(inums); double v =
iob.average(); System.out.println("iob average
is " + v);
Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
Stats<Double> dob = new Stats<Double>(dnums);
 double w = dob.average();
System.out.println("dob average is " + w);
}
}
Restrictions on Generics
To use Java generics effectively, you must consider the following
restrictions:

 Cannot Instantiate Generic Types with Primitive Types

 Cannot Create Instances of Type Parameters
 Cannot Declare Static Fields Whose Types are Type Parameters
 Cannot Use Casts or instanceof With Parameterized Types
 Cannot Create Arrays of Parameterized Types
 Cannot Create, Catch, or Throw Objects of Parameterized Types
 Cannot Overload a Method Where the Formal Parameter Types of Each
Overload Erase to the Same Raw Type
 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 and Interfaces, Exception handling,
Multithreaded programming, Strings, Input/output

Graphics programming
 Java contains support for graphics that enable programmers to visually enhance applications
 Java contains many more sophisticated drawing capabilities as part of the Java 2D API
AWT
 Java AWT (Abstract Window Toolkit) is an API to develop GUI or window-based applications
in java.
 Java AWT components are platform-dependent i.e. components are displayed according to the
view of operating system.
 AWT is heavyweight i.e. its components are using the resources of OS.The java.awt package
provides classes for AWT api such as TextField, Label, TextArea, RadioButton, CheckBox,
Choice, List etc.

Java AWT Hierarchy

The hierarchy of Java AWT classes are given below.

1
Container
The Container is a component in AWT that can contain another components like buttons,
textfields, labels etc. The classes that extend Container class are known as container such as Frame,
Dialog and Panel. Window
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
The Panel is the container that doesn't contain title bar and menu bars. It can have other components
like button, textfield etc.
Frame
The Frame is the container that contain title bar and can have menu bars. It can have other
components like button, textfield etc.
There are two ways to create a Frame. They are,
 By Instantiating Frame class
 By extending Frame class
Example:
import java.awt.*;
import java.awt.event.*;
class MyLoginWindow extends Frame
{
TextField name,pass;
Button b1,b2;
MyLoginWindow()
{
setLayout(new FlowLayout());
this.setLayout(null);
Label n=new Label("Name:",Label.CENTER);
Label p=new Label("password:",Label.CENTER);
name=new TextField(20);
pass=new TextField(20);
pass.setEchoChar('#');
b1=new Button("submit");
b2=new Button("cancel");
this.add(n);
this.add(name);
this.add(p);
this.add(pass);
this.add(b1);
this.add(b2);

2
 n.setBounds(70,90,90,60);
p.setBounds(70,130,90,60);
name.setBounds(200,100,90,20);
pass.setBounds(200,140,90,20);
b1.setBounds(100,260,70,40);
b2.setBounds(180,260,70,40);
}
public static void main(String args[])
{
MyLoginWindow ml=new
MyLoginWindow();
ml.setVisible(true);
ml.setSize(400,400);
ml.setTitle("my login window");
}}

Event handling:
Changing the state of an object is known as an event. For example, click on button, dragging mouse
etc. The java.awt.event package provides many event classes and Listener interfaces for event handling.
Event handling has three main components,
 Events : An event is a change in state of an object.
 Events Source : Event source is an object that generates an event.
 Listeners : A listener is an object that listens to the event. A listener gets notified when
an event occur

3
How Events are handled ?
A source generates an Event and send it to one or more listeners registered with the source. Once
event is received by the listener, they process the event and then return. Events are supported by a number
of Java packages, like java.util, java.awt and java.awt.event.
Important Event Classes and Interface

Event Classes Description Listener Interface

ActionEvent generated when button is pressed, menu-item is selected, ActionListener

list-item is double clicked

MouseEvent generated when mouse is dragged, moved,clicked,pressed MouseListener

or released and also when it enters or exit a
component

KeyEvent generated when input is received from keyboard KeyListener

ItemEvent generated when check-box or list item is clicked ItemListener

TextEvent generated when value of textarea or textfield is changed TextListener

MouseWheelEvent generated when mouse wheel is moved MouseWheelListener

WindowEvent generated when window is activated, deactivated, WindowListener

deiconified, iconified, opened or closed

ComponentEvent generated when component is hidden, moved, resized or ComponentEventListener

set visible

ContainerEvent generated when component is added or removed from ContainerListener

container

AdjustmentEvent generated when scroll bar is manipulated AdjustmentListener

4
FocusEvent generated when component gains or loses keyboard FocusListener
focus

Steps to handle events:

 Implement appropriate interface in the class.
 Register the component with the listener.

How to implement Listener

1. Declare an event handler class and specify that the class either implements an
ActionListener(any listener) interface or extends a class that implements an ActionListener interface.
For example:

public class MyClass implements ActionListener

{
// Set of Code
}
2. Register an instance of the event handler class as a listener on one or more components.
For example:
someComponent.addActionListener(instanceOfMyClass);
3. Include code that implements the methods in listener interface. For
example: public void actionPerformed(ActionEvent e) {
//code that reacts to the action
}

Mouse Listener

package Listener;
import java.awt.Frame;
import java.awt.Label;
import java.awt.TextArea;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

5
public class Mouse implements MouseListener
{ TextArea s;
public Mouse()
{
Frame d=new Frame("kkkk");
s=new TextArea("");
d.add(s);
s.addMouseListener(this);
d.setSize(190, 190);
d.show();
}
public void mousePressed(MouseEvent e) {
System.out.println("MousePressed");
int a=e.getX();
int b=e.getY();
System.out.println("X="+a+"Y="+b);
}
public void mouseReleased(MouseEvent e) {
System.out.println("MouseReleased");
}
public void mouseEntered(MouseEvent e) {
System.out.println("MouseEntered");
}
public void mouseExited(MouseEvent e) {
System.out.println("MouseExited");
}
public void mouseClicked(MouseEvent e) {
System.out.println("MouseClicked");
}
public static void main(String arg[])
{
Mouse a=new Mouse();

6
 }
}

Mouse Motion Listener

package Listener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
public class MouseMotionEventDemo extends JPanel implements MouseMotionListener
{MouseMotionEventDemo()
{
JTextArea a=new JTextArea();
a.addMouseMotionListener(this);
JFrame b=new JFrame();
b.add(a);
b.setVisible(true);
}
public void mouseMoved(MouseEvent e)
{ System.out.println("Mouse is Moving");
}
public void mouseDragged(MouseEvent e) {
System.out.println("MouseDragged");
}
public static void main(String arg[])
{
MouseMotionEventDemo a=new MouseMotionEventDemo();
}
}

7
KEY LISTENER

package Listener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class KeyEventDemo implements KeyListener
{
public KeyEventDemo()
{
JFrame s=new JFrame("hai");
JTextField typingArea = new JTextField(20);
typingArea.addKeyListener(this);
s.add(typingArea);
s.setVisible(true);
}
public void keyTyped(KeyEvent e) {
System.out.println("KeyTyped");
}
/** Handle the key-pressed event from the text field. */
public void keyPressed(KeyEvent e) {
System.out.println("KeyPressed");
}
/** Handle the key-released event from the text field. */
public void keyReleased(KeyEvent e) {
System.out.println("Keyreleased");
}
public static void main(String g[])
{
KeyEventDemo a=new KeyEventDemo();
}
}

8
ITEM LISTENER

package Listener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class itemlistener implements ItemListener
{
public itemlistener()
{
JFrame s=new JFrame("hai");
JCheckBox a=new JCheckBox("Ok");
a.addItemListener(this);
s.add(a);
s.setVisible(true);
}
public static void main(String g[])
{
itemlistener l=new itemlistener();
}
public void itemStateChanged(ItemEvent arg0) {
System.out.println("State changed");
}
}

9
Window Listener
package Listener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
public class window extends JPanel implements WindowListener {
window()
{
JFrame b=new JFrame();
b.addWindowListener(this);
b.setVisible(true);
}
public static void main(String arg[])
{
window a=new window();
}
public void windowActivated(WindowEvent arg0) {
System.out.println("Window activated");
}
public void windowClosed(WindowEvent arg0) {
// TODO Auto-generated method stub
System.out.println("Window closed");
}
public void windowClosing(WindowEvent arg0) {
// TODO Auto-generated method stub
System.out.println("Window closing");
}
public void windowDeactivated(WindowEvent arg0) {
// TODO Auto-generated method stub

10
 System.out.println("Window deactivated");
}
public void windowDeiconified(WindowEvent arg0)
{
// TODO Auto-generated method stub
System.out.println("Window deiconified");
}
public void windowIconified(WindowEvent arg0)
{
// TODO Auto-generated method stub
System.out.println("Window Iconified");
}
public void windowOpened(WindowEvent arg0)
{
// TODO Auto-generated method stub
System.out.println("Window opened");
}}

WINDOW FOCUS LISTENER

package Listener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
public class window1 extends JPanel implements WindowFocusListener
{ window1()
{
JFrame b=new JFrame();

11
 public static void main(String
arg[]) {
window1 b=new window1();
}
public void windowGainedFocus(WindowEvent e)
{
// TODO Auto-generated method stub
System.out.println("Window gained");
}
public void windowLostFocus(WindowEvent e)
{
// TODO Auto-generated method stub
System.out.println("Windowlostfocus");
}}

WindowStateListener

package Listener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowStateListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
public class window2 extends JPanel implements WindowStateListener
{ window2()
{
JFrame b=new JFrame();
b.addWindowStateListener(this);
b.setVisible(true);
}
public static void main(String

12
 }
public void windowStateChanged(WindowEvent e)
{
// TODO Auto-generated method
stub System.out.println("State
Changed");
}}
ACTION LISTENER

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;
public class A extends JFrame implements ActionListener
{
Scientific() {
JPanel buttonpanel = new JPanel();
JButton b1 = new JButton("Hai");
buttonpanel.add(b1);
b1.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
System.out.println(“Hai button”);
}
public static void main(String args[])
{ A f = new A();
f.setTitle("ActionListener");
f.setSize(500,500);
f.setVisible(true);
}}

Java adapter classes

Java adapter classes provide the default implementation of listener interfaces. If you inherit the

13
 The adapter classes are found in java.awt.event, java.awt.dnd and javax.swing.event packages.

Adapter class Listener interface

WindowAdapter WindowListener

KeyAdapter KeyListener

MouseAdapter MouseListener

MouseMotionAdapter MouseMotionListener

FocusAdapter FocusListener

ComponentAdapter ComponentListener

ContainerAdapter ContainerListener

HierarchyBoundsAdapter HierarchyBoundsListener

Java WindowAdapter Example

import java.awt.*;
import java.awt.event.*;
public class AdapterExample{
Frame f; AdapterExample()
{
f=new Frame("Window Adapter");
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e)
{ f.dispose();
}
});
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);

14
 }
public static void main(String[] args)
{ new AdapterExample();
} }

Java MouseAdapter Example

import java.awt.*;
import java.awt.event.*;
public class MouseAdapterExample extends MouseAdapter{
Frame f;
MouseAdapterExample(){
f=new Frame("Mouse Adapter");
f.addMouseListener(this);
f.setSize(300,300);
f.setLayout(null);
f.setVisible(true);
}
public void mouseClicked(MouseEvent e)
{ Graphics g=f.getGraphics();
g.setColor(Color.BLUE);
g.fillOval(e.getX(),e.getY(),30,30);
}
public static void main(String[] args) {
new MouseAdapterExample();
} }

Java MouseMotionAdapter Example

import java.awt.*;
import java.awt.event.*;
public class MouseMotionAdapterExample extends MouseMotionAdapter{
Frame f;
MouseMotionAdapterExample(){
f=new Frame("Mouse Motion Adapter");

15
 f.addMouseMotionListener(this);
f.setSize(300,300);
f.setLayout(null);
f.setVisible(true);
}
public void mouseDragged(MouseEvent e)
{ Graphics g=f.getGraphics();
g.setColor(Color.ORANGE);
g.fillOval(e.getX(),e.getY(),20,20);
}
public static void main(String[] args) {
new MouseMotionAdapterExample();
} }

Java KeyAdapter Example

import java.awt.*;
import java.awt.event.*;
public class KeyAdapterExample extends
KeyAdapter{ Label l;
TextArea area;
Frame f;
KeyAdapterExample(){
f=new Frame("Key Adapter");
l=new Label();
l.setBounds(20,50,200,20);
area=new TextArea();
area.setBounds(20,80,300, 300);
area.addKeyListener(this);
f.add(l);f.add(area);
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);
}

16
 public void keyReleased(KeyEvent e)
{ String text=area.getText();
String words[]=text.split("\\s");
l.setText("Words: "+words.length+" Characters:"+text.length());
}
public static void main(String[] args)
{ new KeyAdapterExample();
} }

AWT EVENT HIERARCHY

Swing
 Java Swing tutorial 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, JTextField,
JTextArea, JRadioButton, JCheckbox, JMenu, JColorChooser etc.

17
 The hierarchy of java swing API is given
below

Difference between AWT and Swing

There are many differences between java awt and swing that are given below.

No.Java AWT Java Swing

1 AWT components are platform- Java swing components

dependent. are platform-independent.

2 AWT components are heavyweight. Swing components

are lightweight.

3 AWT doesn't support pluggable look and Swing supports pluggable

feel. look and feel.

4 AWT provides less components than Swing provides more

Swing. powerful componentssuch as
tables, lists, scrollpanes,
colorchooser, tabbedpane etc.

5 AWT doesn't follows MVC(Model View Swing follows MVC.

Controller) where model represents data,
view represents presentation and
controller acts as an interface between
model and view.

18
Layout management
Java LayoutManagers
The LayoutManagers are used to arrange components in a particular manner. LayoutManager is an
interface that is implemented by all the classes of layout managers. There are following classes that
represents the layout managers:
AWT Layout Manager Classes
Following is the list of commonly used controls while designing GUI using AWT.

Sr.No. LayoutManager & Description

BorderLayout
1 The borderlayout arranges the components to fit in the five regions: east, west,
north, south, and center.

CardLayout
2 The CardLayout object treats each component in the container as a card. Only one
card is visible at a time.

3 FlowLayout
The FlowLayout is the default layout. It layout the components in a directional flow.

4 GridLayout
The GridLayout manages the components in the form of a rectangular
grid.
GridBagLayout
This is the most flexible layout manager class. The object of GridBagLayout aligns
the component vertically, horizontally, or along their baseline without requiring the
components of the same size.

GroupLayout
6 The GroupLayout hierarchically groups the components in order to position them
in a Container.

SpringLayout
7 A SpringLayout positions the children of its associated container according to a
set of constraints.

8 BoxLayout
The BoxLayout is used to arrange the components either vertically or horizontally.

ScrollPaneLayout
9 The layout manager used by JScrollPane. JScrollPaneLayout is responsible for nine
components: a viewport, two scrollbars, a row header, a column header, and four
"corner" components.

19
Border layout:
Example:
import java.awt.*;
import javax.swing.*;
public class Border
{ JFrame f;
Border(){
f=new JFrame();
JButton b1=new JButton("NORTH");;
JButton b2=new JButton("SOUTH");;
JButton b3=new JButton("EAST");;
JButton b4=new JButton("WEST");;
JButton b5=new JButton("CENTER");;
f.add(b1,BorderLayout.NORTH);
f.add(b2,BorderLayout.SOUTH);
f.add(b3,BorderLayout.EAST);
f.add(b4,BorderLayout.WEST);
f.add(b5,BorderLayout.CENTER);
f.setSize(300,300);
f.setVisible(true);
}
public static void main(String[] args)
{ new Border();
} }

ScrollPaneLayout:
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
public class ScrollPaneDemo extends JFrame

20
{
public ScrollPaneDemo()
{ super("ScrollPane
Demo");
ImageIcon img = new ImageIcon("child.png");
JScrollPane png = new JScrollPane(new JLabel(img));
getContentPane().add(png);
setSize(300,250);
setVisible(true);
}
public static void main(String[] args) {
new ScrollPaneDemo();
} }

Boxlayout
import java.awt.*;
import javax.swing.*;
public class BoxLayoutExample1 extends Frame
{ Button buttons[];
public BoxLayoutExample1 ()
{ buttons = new Button [5];
for (int i = 0;i<5;i++) {
buttons[i] = new Button ("Button " + (i + 1));
add (buttons[i]);
}
setLayout (new BoxLayout (this, BoxLayout.Y_AXIS));
setSize(400,400);
setVisible(true);
}
public static void main(String args[]){
BoxLayoutExample1 b=new BoxLayoutExample1();
}

21
Group layout:
Example
public class GroupExample
{
public static void main(String[] args)
{
JFrame frame = new JFrame("GroupLayoutExample");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container contentPanel = frame.getContentPane();
GroupLayout groupLayout = new GroupLayout(contentPanel);
contentPanel.setLayout(groupLayout);
JLabel clickMe = new JLabel("Click
Here"); JButton button = new JButton("This
Button"); groupLayout.setHorizontalGroup(
groupLayout.createSequentialGroup()
.addComponent(clickMe)
.addGap(10, 20, 100)
.addComponent(button));
groupLayout.setVerticalGroup(
groupLayout.createParallelGroup(GroupLayout.Alignment.BASELINE)
.addComponent(clickMe)
.addComponent(button));
frame.pack();
frame.setVisible(true);
} }}

Swing components:
Text Fields
The object of a JTextField class is a text component that allows the editing of a single line text. It
inherits JTextComponent class.
Text Areas
The object of a JTextArea class is a multi line region that displays text. It allows the editing of
multiple line text. It inherits JTextComponent class

22
Buttons
The JButton class is used to create a labeled button that has platform independent implementation.
The application result in some action when the button is pushed. It inherits AbstractButton
class. import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
public class SwingFirstExample {
public static void main(String[] args) {
// Creating instance of JFrame
JFrame frame = new JFrame("My First Swing Example");
// Setting the width and height of frame
frame.setSize(350, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
/* Creating panel. This is same as a div tag in HTML
* We can create several panels and add them to specific
* positions in a JFrame. Inside panels we can add text
* fields, buttons and other components.
*/
JPanel panel = new JPanel();
// adding panel to frame
frame.add(panel);
/* calling user defined method for adding components
* to the panel.
*/
placeComponents(panel);
// Setting the frame visibility to
true frame.setVisible(true); }
private static void placeComponents(JPanel panel) {
/* We will discuss about layouts in the later sections * of this tutorial. For now we are setting the
layout * to null */

23
 panel.setLayout(null);
// Creating JLabel
JLabel userLabel = new JLabel("User");
/* This method specifies the location and size
* of component. setBounds(x, y, width, height)
* here (x,y) are cordinates from the top left
* corner and remaining two arguments are the width
* and height of the component.
*/
userLabel.setBounds(10,20,80,25);
panel.add(userLabel);
/* Creating text field where user is supposed to
* enter user name.
*/
JTextField userText = new JTextField(20);
userText.setBounds(100,20,165,25);
panel.add(userText);
// Same process for password label and text field.
JLabel passwordLabel = new JLabel("Password");
passwordLabel.setBounds(10,50,80,25);
panel.add(passwordLabel);
/*This is similar to text field but it hides the user
* entered data and displays dots instead to protect
* the password like we normally see on login screens.
*/
JPasswordField passwordText = new JPasswordField(20);
passwordText.setBounds(100,50,165,25);
panel.add(passwordText);
// Creating login button
JButton loginButton = new JButton("login");
loginButton.setBounds(10, 80, 80, 25);
panel.add(loginButton);
}}

24
Output:

Check Boxes
The JCheckBox class is used to create a checkbox. It is used to turn an option on (true) or off
(false). Clicking on a CheckBox changes its state from "on" to "off" or from "off" to "on ".It inherits
JToggleButton class.
Example:
import javax.swing.*;
public class CheckBoxExample
{
CheckBoxExample(){
JFrame f= new JFrame("CheckBox Example");
JCheckBox checkBox1 = new JCheckBox("C++");
checkBox1.setBounds(100,100, 50,50);
JCheckBox checkBox2 = new JCheckBox("Java", true);
checkBox2.setBounds(100,150, 50,50);
f.add(checkBox1);
f.add(checkBox2);
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);
}
public static void main(String args[])
{
new CheckBoxExample();

25
 }}

Radio Buttons The JRadioButton class is used to create a radio button. It is used to choose one option from
multiple options. It is widely used in exam systems or quiz. It should be added in ButtonGroup to
select one radio
button only.
import javax.swing.*;
import java.awt.event.*;
class RadioButtonExample extends JFrame implements ActionListener{
JRadioButton rb1,rb2;
JButton b;
RadioButtonExample(){
rb1=new JRadioButton("Male");
rb1.setBounds(100,50,100,30);
rb2=new JRadioButton("Female");
rb2.setBounds(100,100,100,30);
ButtonGroup bg=new ButtonGroup();
bg.add(rb1);bg.add(rb2);
b=new JButton("click");
b.setBounds(100,150,80,30);
b.addActionListener(this);
add(rb1);add(rb2);add(b);
setSize(300,300);
setLayout(null);
setVisible(true);
}
public void actionPerformed(ActionEvent e){
if(rb1.isSelected()){
JOptionPane.showMessageDialog(this,"You are Male.");
}
if(rb2.isSelected()){
JOptionPane.showMessageDialog(this,"You are Female.");
} }

26
public static void main(String args[])
{ new RadioButtonExample();
}}

Lists
The object of JList class represents a list of text items. The list of text items can be set up so that
the user can choose either one item or multiple items. It inherits JComponent
class. import javax.swing.*;
public class ListExample
{
ListExample(){
JFrame f= new JFrame();
DefaultListModel<String> l1 = new DefaultListModel<>();
l1.addElement("Item1");
l1.addElement("Item2");
l1.addElement("Item3");
l1.addElement("Item4");
JList<String> list = new
JList<>(l1); list.setBounds(100,100,
75,75); f.add(list);
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);
}
public static void main(String
args[])
{
new ListExample();

27
Choices (JComboBox)
The object of Choice class is used to show popup menu of choices. Choice selected by user is shown
on the top of a menu. It inherits JComponent class.
import javax.swing.*;
public class ComboBoxExample
{
JFrame f;
ComboBoxExample(){
f=new JFrame("ComboBox Example");
String country[]={"India","Aus","U.S.A","England","Newzealand"};
JComboBox cb=new JComboBox(country);
cb.setBounds(50, 50,90,20);
f.add(cb);
f.setLayout(null);
f.setSize(400,500);
f.setVisible(true);
}
public static void main(String[] args)
{ new ComboBoxExample();

28
Output:

Scrollbars
The object of JScrollbar class is used to add horizontal and vertical scrollbar. It is an implementation
of a scrollbar. It inherits JComponent class.
mport javax.swing.*;
class ScrollBarExample
{
ScrollBarExample(){
JFrame f= new JFrame("Scrollbar Example");
JScrollBar s=new JScrollBar();
s.setBounds(100,100, 50,100);
f.add(s);
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);
}
public static void main(String args[])
{
new ScrollBarExample();
}}

29
Output:

Windows
The class JWindow is a container that can be displayed but does not have the title bar
Menus
The JMenuBar class is used to display menubar on the window or frame. It may have several
menus. The object of JMenu class is a pull down menu component which is displayed from the
menu bar. It
inherits the JMenuItem class.
The object of JMenuItem class adds a simple labeled menu item. The items used in a menu must
belong to the JMenuItem or any of its subclass.
import javax.swing.*;
class MenuExample
{
JMenu menu, submenu;
JMenuItem i1, i2, i3, i4, i5;
MenuExample(){
JFrame f= new JFrame("Menu and MenuItem Example");
JMenuBar mb=new JMenuBar();
menu=new JMenu("Menu");
submenu=new JMenu("Sub Menu");
i1=new JMenuItem("Item 1");
i2=new JMenuItem("Item 2");
i3=new JMenuItem("Item 3");
i4=new JMenuItem("Item 4");
i5=new JMenuItem("Item 5");
menu.add(i1); menu.add(i2); menu.add(i3);

30
 menu.add(submenu);
mb.add(menu);
f.setJMenuBar(mb);
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);
}
public static void main(String args[])
{
new MenuExample();
}}
Output :

Dialog Boxes.
The JDialog control represents a top level window with a border and a title used to take some form
of input from the user. It inherits the Dialog class.Unlike JFrame, it doesn't have maximize and minimize
buttons.
Example:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class DialogExample
{ private static JDialog d;
DialogExample() {
JFrame f= new JFrame();

31
 d = new JDialog(f , "Dialog Example", true);
d.setLayout( new FlowLayout() );
JButton b = new JButton ("OK");
b.addActionListener ( new ActionListener()
{
public void actionPerformed( ActionEvent e )
{
DialogExample.d.setVisible(false); }}};
d.add( new JLabel ("Click button to continue."));
d.add(b);
d.setSize(300,300);
d.setVisible(true);
}
public static void main(String args[])
{
new DialogExample(); }}
Output:

32