Multi Threading

Topics to be Covered:
1.Multi-Threaded Programming
2.Interrupting Thread
3.Thread States
4.Thread Properties
5.Thread Synchronization
6.Thread-Safe Collections
7.Executors
8.Synchronizers
9.Threads and Event-Driven Programming

INTRODUCTION
1. Multithreading extends the idea of multitasking into applications, so you can
subdivide specific operations within a single application into individual
threads. Each of the threads can run in parallel.
2. Those who are familiar with the modern operation systems such as windows 95
may recognize that they can execute several programs simultaneously. This
ability is known as multitasking. In Systems terminology, it is called
multithreading.
3. Multithreading is a conceptual programming paradigm where a program is
divided into two or more subprograms, which can be implemented at the
same time in parallel.
4. In most of our computers, we have only a single processor and therefore, in
reality, the processor is doing only one thing at a time. However, the
processor switches between the processes so fast that it appears to human
beings that all of them are being done simultaneously.
5. Java programs contain only a single sequential flow of control. This is what
happens when we execute a normal program. The program begins, runs
through a sequence of executions, and finally ends. At any given point of
time, there is only one statement under execution.
6. A thread is similar to a program that has a single flow of control. It has a
beginning, a body and an end, and executes commands sequentially. In fact, all
main programs in our earlier examples can be called single threaded
programs.

SINGLE THREADED PROGRAM

class ABC
{
--------------------------------------------------------------------------------------------------------------}

Beginning

Single
threaded body
of execution
End

MULTITHREADED PROGRAM
Main Thread
_______________
_______________
_______________
_______________
_______________
_______________
_______________
_______________
star
t
_______________
_______________
_______________
_______________
_______________
_______________
_______________
_______________
Thread A

switchin
g

star
t
_______________
_______________
_______________
_______________
_______________
_______________
_______________
_______________
Thread B

Main method
module

star
t

switchin
g

_______________
_______________
_______________
_______________
_______________
_______________
_______________
_______________
Thread C

7. A program that contains multiple flows of control is known as

multithreaded program.
8. The above fig. is a java program with four threads, one main and three
others. The main thread is actually the main method module, which is
designed to create and start the other three threads, namely A, B and C
9. Once initiated by the main thread, the threads A, B and C run
concurrently and share the resources jointly. The ability of a language to
support multithreads is referred to as concurrency.
10. Threads in java are subprograms of main application program and share
the same memory space, they are known as lightweight threads or
lightweight processes..
Note:
It is important to remember that threads running in
parallel does not really mean that they actually run at the same
time. Since all the threads are running on a single processor, the
flow of execution is shared between the threads.

CREATING THREADS
1. Creating threads in Java is simple.
2. Threads are implemented in the form of objects that contain a
method
called run().
3. The run() method is the heart and soul of any thread. It makes
up the
entire body of a thread and is the only method in which the
threads
behavior can be implemented.
4. A typical
run()
would
appear as follows:
public
void
run()
{
----------------------------------Statements for implementing
-----------------thread
}

5. The run() method should be invoked by an object for the concerned

thread.
6. This can be achieved by creating the thread and initiating it with the
help of
another thread method called start().
7. A new thread can be created in two ways.
a. By extending a thread class:
Define a class that extends Thread class and override
its run() method
with the code required by the thread.
b. By converting a class to a thread:
Define a class that implements Runnable interface. The
Runnable
interface has only one method, run(), that
is to be defined in the
method with the code to be executed by the thread.

1. EXTENDING THE THREAD CLASS

We can make our class runnable as a thread by extending the class
java.lang.Thread. This gives us access to all the thread methods directly.
It includes the following steps:
1. Declare the class as extending the Thread class
executing the

2. Implement the run() method that is responsible for

sequence of code that the thread will execute.

initiate the

3. Create a thread object and call the start() method to

thread execution.

1. Declaring the
class
class MyThread extends Thread
{
--------------------------------------------------------}

2. Implementing the run()

Method
public void run()
{
----------------------------------------------------------------}

Thread Code Here

3. Starting New
Thread
MyThread aThread = new MyThread();
aThread.start();

//Invoke run() method

Creating threads using the thread

class A extendsclass
Thread
{

public void run()

{
for(int i = 1;i <= 5;i++)
{
System.out.println("\tFrom Thread A : i = " + i);
}
System.out.println("Exit from A ");
}
}
class B extends Thread
{
public void run()
{
for(int j = 1;j <= 5;j++)
{
System.out.println("\tFrom Thread B : j = " + j);
}
System.out.println("Exit from B ");
}
}

class C extends Thread

{
public void run()
{
for(int k = 1;k <= 5;k++)
{
System.out.println("\tFrom Thread C : k = " + k);
}
System.out.println("Exit from C ");
}
}
class ThreadExtend
{
public static void main(String args[])
{
A a = new A();
B b = new B();
C c = new C();
a.start();
b.start();
c.start();
}
}

Output:
From Thread A : i = 1
From Thread C : k =
From Thread B : j =
From Thread C : k =
From Thread A : i =
From Thread C : k =
From Thread B : j =
From Thread C : k =
From Thread A : i =
From Thread C : k =
From Thread B : j =
Exit from C
From Thread A : i =
From Thread B : j =
From Thread A : i =
From Thread B : j =
Exit from A
Exit from B

2. IMPLEMENTING THE RUNNABLE INTERFACE

The Runnable interface declares the run() method that is required for
implementing threads in our programs. To do this, we must perform the steps
listed below:
1. Declare the class an implementing the Runnable interface.
2. Implementing the run() method.
3. Create a thread by defining an object that is instantiated from
the
runnable class as the target of the thread.
4. Call the threads start() method to run the thread.
1. Creating Class:
class MyThread implements Runnable
{
--------------------------------------------------------}

2. Implementing the run()

Method
public void run()
{
----------------------------------------------------------------}

Thread Code Here

3. Starting New Thread and assign the

runnable object
MyThread runnableObj = new MyThread();
Thread t = new Thread(runnableObj);
t.start();

//Invoke run() method

import java.lang.Thread;
class X implements Runnable
{
public void run()
{
for(int i = 1;i <= 5;i++)
{
System.out.println("\tFrom Thread A : i = " + i);
}
System.out.println("Exit from A ");
}
}
class Y implements Runnable
{
public void run()
{
for(int j = 1;j <= 5;j++)
{
System.out.println("\tFrom Thread B : j = " + j);
}
System.out.println("Exit from B ");
}
}

class Z implements Runnable

{
public void run()
{
for(int k = 1;k <= 5;k++)
{
System.out.println("\tFrom Thread C : k = " + k);
}
System.out.println("Exit from C ");
}
}
class RunnableTest
{
public static void main(String args[])
{
X runnableX = new X();
Thread threadX = new Thread(runnableX);
Y runnableY = new Y();
Thread threadY = new Thread(runnableY);
Z runnableZ = new Z();
Thread threadZ = new Thread(runnableZ);
threadX.start();
threadY.start();
threadZ.start();
}
}

Interrupting Thread:
Using sleep() method:
Make the thread to sleep for a while. In that particular sleep time the
processor executes the other Threads which is ready for an execution.
It should thrown a exception called java.lang.InterruptedException, so it
must be handled in the program using try-catch.
Syntax:
Thread.sleep(millisec);
class A implements Runnable
{
public void run()
{
try{
for(int i = 1;i <= 5;i++)
{
System.out.println("\tFrom Thread A : i = " +
i);
Thread.sleep(1000);
}
}
catch(InterruptedException e) {
System.out.println("Thread 1 Interrupted");
}
System.out.println("Exit from A ");

class B extends Thread{

public void run()
{
try{
for(int j = 1;j <= 5;j++) {
System.out.println("\tFrom Thread B : j = " +
j);
Thread.sleep(2000);
}
}
catch(InterruptedException e) {
System.out.println("Thread 2 Interrupted");
}
System.out.println("Exit from B ");
}
}
class ThreadSleep{
public static void main(String args[])
{
A a = new A();
B b = new B();
Thread t1 = new Thread(a);
t1.start();
b.start();
}

Thread Class and Runnable Interface:

To create a new thread, your program will either extend Thread class or
implements the Runnable interface.
The Thread class defines several methods that help manage threads.
Methods

Meaning

getName()

Obtain a threads name

getPriority()

Obtain a threads priority

isAlive()

Determine if a thread is still

running

join()

Wait for a thread to terminate

run()

Entry point for the thread

sleep()

Suspend a thread for a period of

time

start()

Start a thread by calling its run

method

currentThread(
)

Return the Currently executing

thread

LIFE CYCLE OF A
THREAD
During the life time of a thread, there are many states it can enter.
They include
1. Newborn state
2. Runnable state
3. Running state
4. Blocked state
5. Dead state

State Transition diagram of a Thread

New
Thread

Newborn
start

stop

Active Thread

Runnable

Running

stop

Dead

yield

suspen
d

resum
e

sleep

notify

wait
Idle Thread
(Not
Runnable)

Killed
Thread

Blocked

stop

import java.lang.Thread;
class A extends Thread
{
public void run()
{
for(int i = 1;i <= 5;i++)
{
if(i == 1) yield();
System.out.println("\tFrom Thread A : i = " + i);
}
System.out.println("Exit from A ");
}
}
class B extends Thread
{
public void run()
{
for(int j = 1;j <= 5;j++)
{
System.out.println("\tFrom Thread B : j = " + j);
if(j==3) stop();
}
System.out.println("Exit from B ");
}
}

class C extends Thread

{
public void run()
{
for(int k = 1;k <= 5;k++)
{
System.out.println("\tFrom Thread C : k = " + k);
if(k==1)
try
{
sleep(1000);
}
catch(Exception e)
{
}
}
System.out.println("Exit from C ");
}
}
Output:
class ThreadTest_1
Start Thread A
{
Start Thread B
public static void main(String args[])
From Thread A : i = 1
{
From Thread B : j = 1
A a = new A();
From Thread B : j = 2
B b = new B();
Start Thread C
C c = new C();
System.out.println("Start Thread A");
a.start();
System.out.println("Start Thread B");
b.start();
System.out.println("Start Thread C");
c.start();
System.out.println("End of main Thread");
}
}

From Thread B
From Thread A
From Thread C
End of main Thread
From Thread A
From Thread A
From Thread A
Exit from A
From Thread C
From Thread C
From Thread C
From Thread C
Exit from C

:j=3
:i=2
:k=1
:i=3
:i=4
:i=5
:
:
:
:

k
k
k
k

=
=
=
=

2
3
4
5

Using isAlive() and join()

isAlive()
Two ways exist to determine whether a thread has finished or not. First,
you can call isAlive() on the thread. The method is defined by Thread, and its
general form is shown here:
final boolean isAlive()
The isAlive() method returns true if the thread upon which it is called is still
running. It returns false otherwise.

join()
While isAlive() is occasionally useful, the method that you will more
commonly use to wait for a thread to finish is called join(), shown here:
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.

class A extends Thread

{
public void run()
{
for(int i = 1;i <= 5;i++)
{
System.out.println("\tFrom Thread A : i = " + i);
}
System.out.println("Exit from A ");
}
}
class B extends Thread
{
public void run()
{
for(int j = 1;j <= 5;j++)
{
System.out.println("\tFrom Thread B : j = " + j);
}
System.out.println("Exit from B ");
}
}

class C extends Thread

{
public void run()
{
for(int k = 1;k <= 5;k++)
{
System.out.println("\tFrom Thread C : k = " +
k);
}
System.out.println("Exit from C ");
}
}
class AliveJoin
{
public static void main(String args[])
{
A a = new A();
B b = new B();
C c = new C();

System.out.println("Start Thread A");

a.start();
System.out.println("Start Thread B");
b.start();
System.out.println("Start Thread C");
c.start();
System.out.println("End of main Thread");
System.out.println("Thread One is Alive: " +
a.isAlive());
System.out.println("Thread two is Alive: " +
b.isAlive());
System.out.println("Thread three is Alive: " +
c.isAlive());
try
{
a.join();

b.join(); c.join();

}
catch(InterruptedException e)
{
System.out.println("Main Thread Interrupted");
}
System.out.println("Thread One is Alive: " +

THREAD PRIORITY
1. In java, each thread is assigned a priority, which affects the order in which it is
scheduled for running.
2. The threads of the same priority are given equal treatment by the Java scheduler
and, therefore, they share the processor of a first come, first serve basis.

ThreadName.setPriority(int Number);
The intNumber is an integer value to which the threads priority is set.
The Thread class defines several priority constants:
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
The intNumber may assume one of these constants or any value
between 1 and 10. Note that the default setting is NORM_PRIORITY.

import java.lang.Thread;
class A extends Thread
{
public void run()
{
for(int i = 1;i <= 5;i++)
{
System.out.println("\tFrom Thread A : i
= " + i);
}
System.out.println("Exit from A ");
}
}
class B extends Thread
{
public void run()
{
for(int j = 1;j <= 5;j++)
{
System.out.println("\tFrom Thread B : j = " + j);
}
System.out.println("Exit from B ");

class C extends Thread

{
public void run()
{
for(int k = 1;k <= 5;k++)
{
System.out.println("\tFrom Thread C : k = " + k);
}
System.out.println("Exit from C ");
}
}
class ThreadPriority
{
public static void main(String args[])
{
A a = new A();
B b = new B();
C c = new C();
c.setPriority(5); //c.setPriority(NORM_PRIORITY);
b.setPriority(10); //b.setPriority(MAX_PRIORITY);
a.setPriority(1); //a.setPriority(MIN_PRIORITY);
a.start();
System.out.println("Priority of A class Thread: "+ a.getPriority());
b.start();
System.out.println("Priority of B class Thread: "+ b.getPriority());
c.start();
System.out.println("Priority of C class Thread: "+ c.getPriority());
}
}

yield() method:
Thread gives up CPU for other threads ready to run
class MyThread extends Thread
{
private String name;
public MyThread(String name)
{
this.name = name;
}
public void run()
{
for (int i=0;i<10;i++) {
System.out.println(name + ": hello world");
yield();
}
}
}
public class Main3
{
public static void main(String [] args)
{
MyThread t1 = new MyThread("thread1");
MyThread t2 = new MyThread("thread2");
t1.start(); t2.start();
}
}

Race Condition:
Two or more threads need to share access to the same data.
If two threads have access to the same object and each calls to a method
that modifies the state of the object, then the threads depend on the order
in which the data were accessed, corrupted objects can result. Such a
condition is often called Race Condition.
class MyThread extends Thread
{
private String name;
public MyThread(String name)
{
this.name = name;
}
public void run()
{
for (;;)
System.out.println(name + ": hello world");
}
}
public class RaceCondition
{
public static void main(String [] args) {
MyThread t1 = new MyThread("thread1");
MyThread t2 = new MyThread("thread2");
t1.start(); t2.start();
}
}

Synchronization in Threads:

When we start two or more threads within a program, there may be a

situation when multiple threads try to access the same resource and
finally they can produce unforeseen result due to concurrency issue.
For example if multiple threads try to write within a same file then they
may corrupt the data because one of the threads can overwrite data or
while one thread is opening the same file at the same time another thread
might be closing the same file.
So there is a need to synchronize the action of multiple threads and
make sure that only one thread can access the resource at a given point
in time.
This is implemented using a concept calledmonitors (also called as
Semaphore).
Each object in Java is associated with a monitor, which a thread can lock
or unlock.
Only one thread at a time may hold a lock on a monitor.
To enter an objects monitor, just call a method that has been modified
with the synchronized keyword.
The monitor is used to control the way in which synchronized methods are
allowed to access the class or object.
When a synchronized method is invoked for a given object, it is said
toacquirethe monitor for that object. No other synchronized method may
be invoked for that object until the monitor is released.
A monitor is automatically released when the method completes its
execution and returns. A monitor may also be released when a synchronized

 While creating Synchronized methods within classes that you create is an

easy and effective means of achieving synchronization, it will not work in
all cases.
Syntax:
access_specifier
synchronized
method_name(parameters)
{
---------// function body
}
class MyThread extends Thread
{
static String message[] ={
"Engineering",
"Technology."};
String id;
public MyThread(String id)
{
this.id = id;
}
public void run()
{

"Chettinad",

void

"College",

"of",
"and",

class SynchronizedOutput
{
public static synchronized void displayList(String name,String
list[])
{
try {
for(int i=0;i<list.length;++i)
{
System.out.println(name+list[i]);
Thread.sleep(1000);
}
}
catch(InterruptedException e)
{
System.out.println("Interruption occured");
}
}
}
class ThreadSynchronization
{
public static void main(String args[])
{
try{
MyThread thread1 = new MyThread("Thread1:

thread1.start();
if (thread1.isAlive())
{
thread1.join();
System.out.println("Thread1 is dead.");
}
thread2.start();
if (thread2.isAlive())
{
thread2.join();
System.out.println("Thread 2 is dead.");
}
}
catch(InterruptedException e)
{
}
}
}

Output:
Thread1: Chettinad
Thread1: College
Thread1: of
Thread1: Engineering
Thread1: and
Thread1: Technology.
Thread1 is dead.
Thread2: Chettinad
Thread2: College
Thread2: of
Thread2: Engineering
Thread2: and
Thread2: Technology.
Thread 2 is dead.

APPLETS
38

What is Applets?
1. An applet is a program written in the Java programming language that can be included in an
HTML page, much in the same way an image is included in a page.
2. When you use a Java technology-enabled browser to view a page that contains an applet, the
applet's code is transferred to your system and executed by the browser's Java Virtual
Machine (JVM).

What are the differences between Applets and Application?

1. Applets do not use the main() method for initiating the execution of the code. Applets, when
loaded, automatically call certain methods of Applet class to start and execute the applet
code.
2. Unlike stand alone applications, applets cannot be run independently. They are run from
inside a Web page using a special feature known as HTML tag.
3. Applets cannot read from or write to the files in the local computer.
4. Applets cannot communicate with other servers on the network.
5. Applets cannot run any program from the local computer.
6. Applets are restricted from using libraries from other languages such as C or C++. (Java
39
language supports this feature through native methods.)

Applet Architecture
1. An applet is a window based program.
2. First, applets are event driven.
3. Event driven architecture impacts the design of an applet.
4. An applet resembles a set of interrupt service routines.
5. An applet waits until an event occurs.
6. The AWT notifies the applet about an event by calling an event handler appropriate action
and then quickly return control to the AWT.
7. Second, the user initiates interaction with an applet - not the other way around.
8. As you know, in a non - windowed program, when the program needs input, it will prompt
the user and then call some input method, such as readLine().
9. This not the way it works in an applet. Instead, the user interacts with the applet as he or she
wants, when must respond.
10. For example, when the user clicks a mouse inside the applets window, a mouse clicked
event is generated. If the user presses a key while the applets window has input focus, a
keypress event is generated.
11. Applets can contain various controls, such as push buttons and check boxes.

40

Applet Architecture . . . .
12. When the user interacts with one of these controls, an event is generated.
13. While the architecture of an applet is not as easy to understand as that of a console based
program, Javas AWT makes it as simple as possible.
14. If you have written programs for windows, you know how intimidating that environment can
be.
15. Fortunately, Javas AWT provides a much cleaner approach that is more quickly mastered.

41

An Applet Skeleton or Applet Life Cycle

Begin

Born

(Load Applet)

Initialization

start( )

stop( )

Running

Stopped

Idle

start( )

Display

paint( )

destroy( )

Destroyed

Dead

End

42
Exit of Browser

An Applet Skeleton or Applet Life Cycle

1. All but the the most trivial applets override a set of methods that provides the basic
mechanism by which the browser or applet viewer interfaces to the applet and controls its
execution.
2. Four of these methods init( ), start( ), stop( ), and destroy( ) are defined by Applet.
Another, paint(), is defined by the AWT Component class.
3. Default implementations for all of these methods are provided.
4. Applets do no need to override those methods they do not use.
5. However, only very simple applets will not need to define all of them.
The applet states is:
1. Born or initialization state
2. Running state
3. Idle state
4. Dead or destroyed state
5. Display state
43

1. Initialization State
Applet enters the initialisation state when it is first loaded. This is achieved by calling the
init() method of Applet Class. The applet is born. At this stage, we may do the following, if
required,
a. Create objects needed by the applet.
b. Set up initial values
c. Load images or fonts
d. set up colors
public void init( )
{
----------------------------------------------------------------}

Action

44

2. Running State
Applets enters the running state when the system call the start () method of Applet Class.
This occurs automatically after the applet is initailized. Starting can also occur if the applet is
already in stopped state. For example, we may leave the web page containing the applet
temporarily to another page and return back to the page. This again starts the applet running.
Note that, unlike init() method, the start() method may be called more than once. We may
override the start() method to create a threa to control the applet.

public void start( )

{
----------------------------------------------------------------}

Action

45

3. Idle or Stopped State

An applet becomes idle when it is stopped from running. Stopping occurs automatically when
we leave the page containing the currently running applet. We can also do so by calling the
stop() method explicitly. If we use a thread to run the applet, then we must use stop() method
to terminate the thread. We can achieve by overriding the stop( ) method:

public void stop( )

{
----------------------------------------------------------------}

Action

46

4. Dead State
An applet is said to be dead when it is removed from memory. This occurs automatically by
invoking the destroy( ) method when we quit the browser. Like initialization, destroying
stage occurs only once in the applets life cycle. If the applet has created any resources. Like
threads we may override the destroy( ) method to clean up these resouces.

public void destroy( )

{
----------------------------------------------------------------}

Action

47

5. Display State
Applet moves to the display state whenever it has to perform some output operations on the
screen. This happens immediately after the applet enters into the running state. The paint()
method is called to accomplish this task. Almost every applet will have a paint() method.
Like other methods in the life cycle, the default version of paint() method does absolutely
nothing. We must therefore override this method if we want anything to be displayed on the
screen.
public void paint (Graphics g)
{
--------------------------------Display Statements
--------------------------------}

48

import java.awt.*;
import java.applet.*;
/*
<applet code = "AppletDemo" width = 300 height =
300>
</applet>
*/
public class AppletDemo extends Applet
{
String msg;
public void init()
{
setBackground(Color.cyan);
}
public void start()
{
msg += "This is Start method";
}
public void stop()
{
msg += "This is Stop method";
}
public void destroy()
{
msg += "This is Destroy method";
}
public void paint(Graphics g)
{
g.drawString(msg,100,100);
}
}

Specified Colors

Specified Colors

1. Color.black

10. Color.pink

2. Color.blue

11. Color.red

3. Color.cyan

12. Color.white

4. Color.darkGray

13. Color.yellow

5. Color.gray
6. Color.green
7. Color.lightGray
8. Color.magenta
9. Color.orange

49

How the applets to be displayed in the Browser

<HTML>
<HEAD>
<TITLE>WELCOME TO cHETTINAD</TITLE>
</HEAD>
<BODY>
<APPLET
CODE = AppletDemo.class
WIDTH = 300
HEIGHT = 200
</APPLET>
</BODY>
</HTML>

50

The HTML APPLET Tag

< APPLET
[CODEBASE = codebaseURL]
CODE = appletFile
[ALT = alternateText]
[NAME = appletInstanceName]
WIDTH = pixels
HEIGHT = pixels
[ALIGN = alignment]
[VSPACE = pixels]
[HSPACE = pixels]
>
[<PARAM NAME = AttributeName VALUE = AttributeValue>]
[<PARAM NAME = AttributeName VALUE = AttributeValue>]
.......
[HTML Displayed in the absence of Java]
</APPLET>

51

ATTRIBUTE

MEANING

CODE = AppletFileName.class

Specifies the name of the applet class to be loaded. That is, the name of the
already compiled .class file in which the executable. Java bytecode for the
applet is stored. This attribute must be specified.

CODEBASE = codebase_URL
(Optional)

Specifies the URL of the directory in which the applet resides. If the applet
resides in the same directory as the HTML file, then the CODEBASE
attirbute may be omitted entirely.

WIDTH = pixels
HEIGHT = pixels

These attributes specify the width and height of the space on the HTML
page that will be reserved for the applet.

NAME=applet_instance_name
(Optional)

A name for the applet may optionally be specified so that other applets on
the page may refer to this applet. This facilitates inter applet
communication.

ALIGN = alignment
(Optional)

This optional attribute specifies where on the page the applet will appear.
Possible values for alignment are TOP, BOTTOM, LEFT, RIGHT,
MIDDLE, ABSMIDDLE, ABSBOTTOM, TEXTTOP, AND BASELINE.

HSPACE = pixels
(Optional)

Used only when ALIGN is set to LEFT or RIGHT , this attribute specifies
the amount of horizontal blank space the browser should leave surrounding
the applet.

VSPACE = pixels
(Optional)

Used only when some vertical alignment is specified with the ALIGN
attribute (TOP, BOTTOM, etc.,) VSPACE specifes the amount of vertical
blank space the browser should leave surrounding the applet.

ALT = alternate_text
(Optional)

Non java browser will display this text where the applet would normally
go. This attribute is optional.

PARAM NAME AND VALUE

The PARAM tag allows you to specify applet specific arguments in an

52
HTML page. Applets access their attributes with the getParameter()
method

Passing Parameters to Applets

import java.awt.*;
import java.applet.*;
/*
<applet code="ParamDemo" width = 300 height = 300>
<param name = fontName value=Courier>
<param name = fontSize value = 30>
<param name = leading value=2>
<param name = accountEnabled value = true>
</applet>
*/
public class ParamDemo extends Applet
{
String fontName;
int fontSize;
float leading;
boolean active;
public void start()
{
String param;
fontName = getParameter("fontName");
if(fontName == null)
fontName = "Not Found";

53

param = getParameter("fontSize");
try
{
if(param != null) //if not found
fontSize = Integer.parseInt(param);
else
fontSize = 0;
}
catch(NumberFormatException e)
{
fontSize = -1;
}
param = getParameter("leading");
try
{
if(param != null) //if not found
leading = Float.valueOf(param).floatValue();
else
leading = 0;
}
catch(NumberFormatException e)
{
leading = -1;
}

54

param = getParameter("accountEnabled");
if(param != null)
active = Boolean.valueOf(param).booleanValue();
}
public void paint(Graphics g)
{
g.drawString("Font name: " + fontName,0,10);
g.drawString("Font Size: " + fontSize,0,20);
g.drawString("Leading: " + leading, 0,42);
g.drawString("Account Active: " + active,0,58);
}
}

55

getCodeBase() and getDocumentBase()

import java.awt.*;
import java.applet.*;
import java.net.*;
/*
<applet code=ParamDemo_2.class width = 300 height = 300>
</applet>
*/
public class ParamDemo_2 extends Applet
{
public void paint(Graphics g)
{
String msg;
URL url = getCodeBase();
msg = "Code Base: " + url.toString();
g.drawString(msg,10,20);
url = getDocumentBase();
msg = "Document Base: " + url.toString();
g.drawString(msg,10,40);
}
}

56

The AudioClip Interface

The AudioClip interface defines these methods:
1. play ( )

play a clip from the beginning.

2. stop ( )

stop playing the clip.

3. loop ( )

play the loop continuously.

4. getAudioClip ( ) - After you have loaded an audio clip

import java.applet.*;
import java.awt.event.*;
import java.awt.*;
/*
<applet code=SoundExample width = 300 height = 300>
</applet>
*/
public class SoundExample extends Applet implements MouseListener
{
AudioClip soundFile1;
AudioClip soundFile2;

57

public void init()

{
soundFile1 = getAudioClip(getDocumentBase(),"c:\\windows\\media\\ding.wav");
soundFile2 = getAudioClip(getDocumentBase(),"c:\\windows\\media\\start.wav");

addMouseListener(this);
setBackground(Color.yellow);
soundFile1.play();
}
public void paint(Graphics g)
{
g.drawString("Click to hear a sound",20,20);
}
public void mouseClicked(MouseEvent evt)
{
soundFile2.play();
}
public void mousePressed(MouseEvent evt) {}
public void mouseReleased(MouseEvent evt) {}
public void mouseEntered(MouseEvent evt) {}
public void mouseExited(MouseEvent evt) {}
}
58

AppletStub Interface
The AppletStub interface provides a way to get information from the run-time browser
environment. The Applet class provides methods with similar names that call these
methods. Methods
public abstract boolean isActive ()
The isActive() method returns the current state of the applet. While an applet is
initializing, it is not active, and calls to isActive() return false. The system marks the
applet active just prior to calling start(); after this point, calls to isActive() return true.
public abstract URL getDocumentBase ()
The getDocumentBase() method returns the complete URL of the HTML file that loaded
the applet. This method can be used with the getImage() or getAudioClip() methods to
load an image or audio file relative to the HTML file.
public abstract URL getCodeBase ()
The getCodeBase() method returns the complete URL of the .class file that contains the
59
applet. This method can be used with the getImage() method or the getAudioClip()

public abstract String getParameter (String name)

The getParameter() method allows you to get parameters from <PARAM> tags within the
<APPLET> tag of the HTML file that loaded the applet. The name parameter of
getParameter() must match the name string of the <PARAM> tag; name is case insensitive.
The return value of getParameter() is the value associated with name; it is always a String
regardless of the type of data in the tag. If name is not found within the <PARAM> tags of
the <APPLET>, getParameter() returns null.
public abstract void appletResize (int width, int height)
The appletResize() method is called by the resize method of the Applet class. The method
changes the size of the applet space to width x height. The browser must support changing
the applet space; if it doesn't, the size remains unchanged.

60

The Delegation Event Model

1. The modern approach to handling events is based on the delegation event model, which defines
standard and consistent mechanisms to generate and process events.
2. Its concept is quite simple: a source generates an event and sends it to one or more listeners.
3. In this scheme, the listener simply waits until it receives an event.
4. Once received, the listener processes the event and then returns.
5. The advantage of this design is that the application logic that processes events is cleanly separated
from the user interface logic that generates those events.
6. A user interface element is able to delegate the processing of an event to a separate piece of code.

Events
1. In the delegation model, an event is an object that describes a state change in a source.
2. It can be generated as a consequence of a person interacting with the elements in a graphical user
interface.
3. Some of the activities that cause events to be generated are pressing a button, entering a character
via the keyboard, selecting an item in a list, and clicking the mouse.
4. Event may also occur that are not directly caused by interactions with a user interface. For
example, an event may be generated when a timer expires, a counter exceeds a value, a software or
61
hardware failure occurs, or an operation is completed.

Event Sources
1. A source is an object that generates an event.
2. This occurs when the internal state of that object changes in some way.
3. Sources may generate more than one type of event.
4. A source must register listeners in order for the listeners to receive notifications about a specific
type of event.
5. Each type of event has its own registration method.
6. Here is the general form:

public void addTypeListener(TypeListener el)

7. Here, type is the name of the event and el is a reference to the event listener.
8. For example the method that registers a keyboard event listener is called addKeyListener().
9. The method that registers a mouse motion listener is called addMouseListener().
10. When an event occurs, all registered listeners are notified and receive a copy of the event object.
11. This known as multicasting the event. Some sources may allow only one listener to register.
12. The general form of such method is this:
62
public void addTypeListener(TypeListener el) throws java.util.TooManyListenersException

13. Here, Type is the name of the event and el is a reference to the event listener.
14.When such an event occurs, the registered listener is notified. This is known a s unicasting the
event.
15. A source must also provide a method that allows a listener to unregister an interest in a specific
type of event.
16. The general form of such a method is this:
public void removeTypeListener(TypeListener el)
17. Here, Type is the name of the event and el is reference to the event listener.
18. For Example, to remove a keyboard listener, you would call removeKeyListener().
19. The methods that add or remove listeners are privided by the source that generates events.
20. For example, the Component class provides methods to add and remove keyboard and mouse event
listeners.

Event Listeners
21. A Listener is an object that is notified when an event occurs. It has major requirements.
22. First, it must have been registered with one or more sources to receive notification about specific
type of events.
23. Second, it must implement methods to receive and process these notifications.

63

24. The methods that receive and pricess events are defined in a set of interfaces found in
java.awt.event.
25. For example, the MouseMotionListener interface defines two method to receive notifications when
the mouse is dragged or moved.
26. Any object may receive and process one or both of these events if it provides an implementation of
this interface.

64

EVENT CLASSES

65

Event Classes
1. The classes that represent events are at the core of Javas event handling
mechanism.
2. At the root of the Java event class hierarchy is EventObject, which is in java.util.
3. It is the superclass for all events. Its one constructor is shown here:
EventObject(Object src)
4. Here, src is the object that generates this event.
5. EventObject contains two methods: getSource() and toString().
6. The getSource() method returns the source of the event.
7. Its general form is shown here:
Object getSource()
8. As expected, toString() returns the string equivalent of the event.
9. The AWTEvent, defined within the java.awt package, is a subclass of EventObject.
10. It is the superclass of all AWT based events used by the delegation event model.
11. Its getID() method can be used to determine the type of the event. The signature of
this method is shown here:

int getID()

66

The package java.awt.event defines several types of events that are generated by
various user interface elements.
EVENT CLASSES

DESCRIPTION

ActionEvent

Generated when a button is pressed, a list item is double - clicked, or a menu

item is selected.

AdjustmentEvent

Generated when a scroll bar is manupulated

ComponentEvent

Generated when a component is hidden, moved, resized, or becomes visible.

ContainerEvent

Generated when a component is added to or removed from a container.

FocusEvent

Generated when a component gains or loses keyboard focus.

InputEvent

Abstract super class for all component input event classes.

ItemEvent

Generated when a check box or list item is clicked; also occurs when a choice
selection is made or a checkable menu item is selected or deselecte.

KeyEvent

Generated when input is received from the keyboard.

MouseEvent

Generated when the mouse is dragged, moved, clicked, pressed, or , released;

also generated when the mouse enters or exits a component.

MouseWheelEvent

Generated when the mouse wheel is moved.

TextEvent

Generated when the value of a text area or text field is changed.

WindowsEvent

Generated when a window is activated, closed, deactivated, deiconified,

67
iconified, opened, or quit.

The ActionEvent Class

1. An ActionEvent is generated when a button is pressed, a list item is double - clicked, or a menu
item is selected.
2. The ActionEvent class defines fout integer constants that can be used to identify any modifiers
associated with an action event: ALT_MASK, CTRL_MASK, META_MASK, and
SHIFT_MASK.
3. In addition. There is an integer constant, ACTION_PERFORMED, which can be used to identify
action events. ActionEvent has these three constructors:
ActionEvent(Object src, int type, String cmd)
ActionEvent(Object src, int type, String cmd, int modifiers)
ActionEvent(Object src, int type, String cmd, long when, int modifiers)

4. Here, src is a reference to the object that generated this event.

5. The type of the event is specified by type, and its command string is cmd.
6. The argument modifiers indicates which modifier key were pressed when the event was generated.
7. The when parameter specifies when the event occurred.
68

Action Event Example Button Click

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
/*
<applet code="Button_Setnull.class" height=300 width=300>
</applet>
*/
public class Button_Setnull extends Applet implements ActionListener
{
TextField tf1,tf2,tf3;
Label l1,l2,l3;
Button b1;
int x,y,z;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);
//setTitle("Addition of Two Numbers");
setLayout(null);
69

l1 = new Label("Enter the A Value");

l1.setBounds(0,0,100,25);
l2 = new Label("Enter the B Value");
l2.setBounds(0,50,100,25);
l3 = new Label("Addition of the Two Numbers");
l3.setBounds(0,100,170,25);
tf1 = new TextField(10);
tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
b1 = new Button("Click Addition");
b1.setBounds(100,150,150,25);
add(l1); add(tf1); add(l2); add(tf2); add(l3); add(tf3); add(b1);
b1.addActionListener(this);

70

public void actionPerformed(ActionEvent ae)

{
if(ae.getActionCommand().equals("Click Addition"))
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x + y;
tf3.setText(String.valueOf(z));
}
}
}

71

Action Event Example List Box item Double Click

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
/*
<applet code=Listbox_Setnull.class" height=300 width=1000>
</applet>
*/
public class Listbox_Setnull extends Applet implements ActionListener
{
TextField tf1,tf2,tf3;
Label l1,l2,l3;
List ls;
int x,y,z;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);
setLayout(null);
l1 = new Label("Enter the A Value");
l1.setBounds(0,0,100,25);
l2 = new Label("Enter the B Value");
l2.setBounds(0,50,100,25);
l3 = new Label("Compute the Two Numbers");
72
l3.setBounds(0,100,170,25);

tf1 = new TextField(10);

tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
ls = new List();
ch.setBounds(100,150,150,25);
ls.add(""); ls.add("Addition"); ls.add("Subtraction");
ls.add("Multiplication"); ls.add("Division"); ls.add("Clear");
ls.add("Total No. of Item"); ls.add("Get Selected Item");
add(l1); add(tf1); add(l2); add(tf2); add(l3); add(tf3); add(ls);
ls.addActionListener(this);
}

73

public void actionPerformed(ActionEvent ae)

{
if(ls.getSelectedIndex() == 1)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x + y;
tf3.setText(String.valueOf(z));
}
if(ls.getSelectedIndex() == 2)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x - y;
tf3.setText(String.valueOf(z));
}

74

if(ls.getSelectedIndex() == 3)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x * y; tf3.setText(String.valueOf(z));
}
if(ls.getSelectedIndex() == 4)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x / y; tf3.setText(String.valueOf(z));
}
if(ls.getSelectedIndex() == 5)
{
tf1.setText(""); tf2.setText(""); tf3.setText("");
}
if(ls.getSelectedIndex() == 6)
{
int a = ch.getItemCount(); tf3.setText(String.valueOf(a));
}
if(ls.getSelectedIndex() == 7)
{
tf3.setText(ch.getItem(ch.getSelectedIndex()));
75
}
}

You can obtain the command name for the invoking ActionEvent object by using the
getActionCommand() method, shown here:
String getActionCommand()
For example, when a button is pressed, and action event is generated that has a command name equal
to the label on that button.
The getModifiers() method returns a value that indicates which modifier keys(ALT,CTRL,META and
SHIFT) were pressed when the event was generated. Its form is shown here:
String getModifiers()

The AdjustmentEvent Class

An AdjustementEvent is generated by a scroll bar. There are five types of adjustment events. The
AdjustementEvent class defines integer constants that can be used to identify them.
BLOCK_DECREMENT The user clicked inside the scroll bar to decrease its value.
BLOCK_INCREMENT The user Clicked inside the scroll bar to increase its value.
TRACK The slider was dragged.
UNIT_DECREMENT The button at the end of the scroll bar was clicked to decrease its value
UNIT_INCREMENT The button at the end of the scroll bar was clicked to increase its value.
76

In addition, there is an integer constant, ADJUSTMETN_VALUE_CHANGED,

that indicates that a change has occurred.
Here is one AdjustmentEvent constructor:
AdjustmentEvent(Adjustable src, int id, int type, int data)
Here, src is a reference to the object that generated this event. The id equals
ADJUSTEMENT_VALUE_CHANGED. The type of the event is specified by type, and its
associated data is data.
The getAdjustable() method returns the object that generated the event. Its
form is shown here:
Adjustable getAdjustable()
The type of the adjustement event may be obtained by the getAdjustmentType() method.
It returns one of the constant defined by AdjustmentEvent. The general form is shown
here:
int getAdjustmentType()
The amount of the adjustement can be obtained from the getValue() method, shown
here
int getValue()
77

import java.applet.*; AdjustmentEvent Example Horizontal and Vertical Scrollbar Changed

import java.awt.*;
import java.awt.event.*;
/*
<applet code="Scroll_Setnull.class" height=300 width=1000>
</applet>
*/
public class Scroll_Setnull extends Applet implements AdjustmentListener
{
TextField tf1,tf2,tf3;
Label l1,l2,l3;
Scrollbar sbh,sbv;
int x,y,z;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);
setLayout(null);
l1 = new Label("Enter the A Value");
l1.setBounds(0,0,100,25);
l2 = new Label("Enter the B Value");
l2.setBounds(0,50,100,25);
l3 = new Label("Compute the Two Numbers");
78
l3.setBounds(0,100,170,25);

tf1 = new TextField(10);

tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
int height = Integer.parseInt(getParameter("height"));
int width = Integer.parseInt(getParameter("width"));
sbh = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,height);
sbh.setBounds(0,275,975,25);
sbv = new Scrollbar(Scrollbar.VERTICAL,0,1,0,width);
sbv.setBounds(975,0,25,300);
sbh.setUnitIncrement(50);
sbh.setBlockIncrement(50);
sbv.setUnitIncrement(20);
sbv.setBlockIncrement(20);
add(l1); add(tf1); add(l2); add(tf2); add(l3); add(tf3); add(sbh);
add(sbv);
sbh.addAdjustmentListener(this);
sbv.addAdjustmentListener(this);
}

79

public void adjustmentValueChanged(AdjustmentEvent ae)

{
if(sbh.getValue() == 50)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x + y;
tf3.setText(String.valueOf(z));
}
if(sbh.getValue() == 100)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x - y;
tf3.setText(String.valueOf(z));
}

80

if(sbh.getValue() == 150)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x * y;
tf3.setText(String.valueOf(z));
}
if(sbh.getValue() == 200)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x / y;
tf3.setText(String.valueOf(z));
}
if(sbh.getValue() == 250)
{
tf1.setText("");
}
}
}

tf2.setText("");

tf3.setText("");
81

The ComponentEvent Class

A ComponentEvent is generated when the size, position, or visibility of a component is
changed. There are four types of component events. The ComponentEvent class defines
integer constants that can be used to identify them. The constant and their meanings are
shown here:
COMPONENT_HIDDEN
The component was hidden
COMPONENT_MOVED

The component was moved

COMPONENT_RESIZED

The component was resized

COMPONENT_SHOWN

The component became visible

ComponentEvent has this constructor

ComponentEvent(Component src, int type)
Here, src is a reference to the object that generated this event. The type of the event is
specified by type.
ComponentEvent is the superclass either directly or indirectly
ContainerEvent, FocusEvent, KeyEvent, MouseEvent, and WindowEvent.

of

The getComponent() method returns the component that generated the event.
It is shown here:
82
Component getComponent()

The ContainerEvent Class

1. A ContainerEvent is generated when a component is added to or removed from a
container.
2. There are two types of container events.
3. The ContainerEvent class defines int constants that can be used to identify them:
COMPONENT_ADDED and COMPONENET_REMOVED.
4. They indicate that a component has been added or removed form the container.
5. ContainerEvent is a subclass of ComponentEvent and has this constructor:
ContainerEvent(Component src, int type, Component comp)
Here, src is reference to the container that generated this event. The type of the event is
specified by type, and the component that has been added to or removed from the
container is comp.
You can obtain a reference to the container that generated this event by using
the getCotnainer() method, shown here:
Container getContainer()
The getChild() method returns a reference to the component that was added to
or removed from the container. Its general form is shown here:
83
Component getChild()

The FocusEvent Class

A FocusEvent is generated when a component gains or loses input focus. These events are
identified by the integer constants FOCUS_GAINED and FOCUS_LOST
FocusEvent is a subclass of ComponentEvent and has threse constructor:
FocusEvent(Component src, int type)
FocusEvent(Component src, int type, boolean temporaryFlag)
FocusEvent(Component src, int type, boolean temporaryFlag, Component other)
1. Here, src is a reference to the component that generated this event.
2. The type of the event is specified by type.
3. The argument temporaryFlag is set to true if the focus event is temporary.
4. Otherwise, it is set to false.
5. The other component involved in the focus change, called the apposite component, is passed in
other.
6. Therefore, if a FOCUS_GAINED event occurred, other will refer to the component that lost
focus.
7. Conversely, if a FOCUS_LOST event occurred, other will refer to the component that gains
focus.
84

import java.applet.*;
FocusEvent Example Focus Gained and Focus Lost in TextBox
import java.awt.*;
import java.awt.event.*;
/*
<applet code="Focus_Event.class" height=300 width=1000>
</applet>
*/
public class Focus_Event extends Applet implements FocusListener
{
TextField tf1,tf2,tf3;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);

tf1 = new TextField(10);

tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
add(tf1);
add(tf2);

add(tf3);

tf1.addFocusListener(this);

tf2.addFocusListener(this);

85

public void focusGained(FocusEvent fe)

{
tf2.setText("Focus Gained");
}
public void focusLost(FocusEvent fe)
{
tf1.setText("Focus Lost");
}
}

86

You can determine the other component by calling getOppositeComponent(),

shown here.
Component getOppositeComponent()
The isTemporary() method indicates if this focus change is temporary. Its form
is shown here:
boolean isTemprorary()
The method returns true if the change is temporary. Otherwise, it returns false.

The MouseEvent Class

There are eight types of mouse events. The MouseEvent class defines the following
integer constants that can be used to identify them:
MOUSE_CLICKED

The user clicked the mouse.

MOUSE_DRAGGED

The user dragged the mouse.

MOUSE_ENTERED

The mouse entered a component.

MOUSE_EXITED

The mouse exited from a component.

MOUSE_MOVED

The mouse moved.

MOUSE_PRESSED

The mouse was pressed.

MOUSE_RELEASED

The mouse was released.

MOUSE_WHEEL

The mouse wheel was moved.

87

MouseEvent is a subclass of InputEvent. Here is one of its constructor.

MouseEvent(Component src, int type, long when, int modifiers, int x,int y, int clicks, boolean triggersPopup

1. Here, src is a reference to the component that generated the event.

2. The type of the event is specified by type.
3. The system time at which the mouse event occurred is passed in when.
4. The modifiers aregument indicates which modifiers were pressed when a mouse
event occurred.
5. The coordinates of the mouse are passed in x and y.
6. The click count is passed in clicks.
7. The triggersPopup flag indicates if this event causes a pop up menu to appear on
this platform
Methods

Description

int getX() and int getY()

These retrun the X and Y coordinates of the mouse when the event
occured

Point getPoint()

It returns a Point object that contains the X, Y coordinates in its integer

members.

getClickCount()

The methods obtains the number of mouse clicks for this event

isPopupTrigger()

This method tests if this event causes a pop up menu to appear on 88

this
platform

import java.awt.*;
MouseEvent Example
import java.awt.event.*;
import java.applet.*;
/*
<applet code="Mouse" width=500 height=500>
</applet>
*/
public class Mouse extends Applet implements MouseListener,MouseMotionListener
{
int X=0,Y=20;
String msg="MouseEvents";
public void init()
{
addMouseListener(this);
addMouseMotionListener(this);
setBackground(Color.black);
setForeground(Color.red);
}
public void mouseEntered(MouseEvent m)
{
setBackground(Color.magenta);
showStatus("Mouse Entered");
repaint();
}
public void mouseExited(MouseEvent m)
{
setBackground(Color.black);
showStatus("Mouse Exited");
repaint();
}

in Mouse

89

public void mousePressed(MouseEvent m)

{
X=10;
Y=20;
msg="CCET";
setBackground(Color.green);
repaint();
}
public void mouseReleased(MouseEvent m)
{
X=10;
Y=20;
msg="Engineering";
setBackground(Color.blue);
repaint();
}
public void mouseMoved(MouseEvent m)
{
X=m.getX();
Y=m.getY();
msg="College";
setBackground(Color.white);
showStatus("Mouse Moved");
repaint();
}

90

public void mouseDragged(MouseEvent m)

{
msg="CSE";
setBackground(Color.yellow);
showStatus("Mouse Moved"+m.getX()+" "+m.getY());
repaint();
}
public void mouseClicked(MouseEvent m)
{
msg="Students";
setBackground(Color.pink);
showStatus("Mouse Clicked");
repaint();
}
public void paint(Graphics g)
{
g.drawString(msg,X,Y);
}
}

91

The MouseWheelEvent Class

The MouseWheelEvent class encapsulates a mouse wheel event. If a mouse has a
wheel, it is located between the left and right buttons. Mouse wheels, are used for
scrolling. MouseWheelEvent defines these two integer constants.
WHEEL_BLOCK_SCROLL
WHEEL_UNIT_SCROLL

A page up or page down scroll event occurred

-

A line up or line down scroll event occured

MouseWheelEvent defines the following constructor:

MouseWheelEvent(Component src, int type, long when, int modifiers, int x, int y, int clicks,
boolean triggersPopup, int scrollHow, int amount, int count)
Here, src is a reference to the object that generated the event. The type of the event is
specified by type. The system time at which the mouse event occurred is passed in
when. The modifiers argument indicates which modifiers were pressed when the event
occurred. The coordinates of the mouse are passed in x and y. The number of clicks the
wheel has rotated is passed in clicks. The triggers Popup flag indicates if this event
causes a pop up menu to appear on this platform. The scrollHow value must be either
is passes in amount. The count parameter indicates the number of roational units that
the wheel moved.
92

Methods

Description

int getWheelRotation()

It returns the number of rotational units. If the value is positive, the wheel
moved conterclockwise. If the value is negative, the wheel moved
clockwise.

int getScrollType()

It returns either WHEEL_UNIT_SCORLL or WHEEL_BLOCK_SCROLL

int getScrollAmount()

If the scroll type is WHEEL_UNIT_SCROLL you can obtain the number of

units to scroll by calling getScrollAmount().

The InputEvent Class

1. The abstract class InputEvent is a subclass of ComponentEvent and is the
superclass for component input events.
2. Its subclasses are keyEvent and MouseEvent.InputEvent defines several integer
constants that represent any modifiers, such as the control key being pressed, that
might be assocated with the event.
3. Originally, the InputEvent class defined the following eight values to represent the
modifiers.
ALT_MASK

BUTTON2_MASK

BUTTON3_MASK

SHIFT_MASK

BUTTON1_MASK

CTRL_MASK

META_MASK

93

4. However, because of possible conflicts between the modifiers used by keyboard

events and mouse events, and other issues, Java2 version 1.4, added the following
extended modifier values.
ALT_DOWN_MASK

BUTTON2_DOWN_MASK

BUTTON3_DOWN_MASK

SHIFT_DOWN_MASK

BUTTON1_DOWN_MASK

CTRL_DOWN_MASK

META_DOWN_MASK

5. When writing new code, it is recommended that you use the new, extended modifiers
rather that the original modifiers.
6. To test if a modifier was pressed at the time an event is generated, use the
isAltDown(), isAltGraphDown(), isControlDown(), isMetaDown(), and isShiftDown()
methods.
7. The forms of these methods are shown here:
boolean isAltDown()
boolean isAltGraphDown()
boolean isControlDown()
boolean isMetaDown()
boolean isShiftDown()

94

You can obtain a value that contains all of the original modifer flags by calling the
getModifiers() method. It is shown here:
int getModifiers()
You can obtain the extended modifiers by called getModifiersEx(), which is shown here:
int getModifiersEx()

The ItemEvent Class

1. An ItemEvent is generated when a check box or a list item is clicked or when a
checkable menu item is selected or deselected.
2. There are two types of item events, which are identified by the following integer
constants.
DESELECTED

- The user deselected an item

SELECTED

- The user selected an item

In addition, ItemEvent defines one integer constant, ITEM_STATE_CHANGED, that

signifies a change of state.
ItemEvent(ItemSelectable src, int type, Object entry, int state)

95

3. Here, src is a reference to the component that generated this event.

4. For example, this might be a list or choice element.
5. The type of the event is specified by type.
6. The specific item that generated the item event is passed in entry. The current state of
that item is in state.
7. The getItem() method can be used to obtain a reference to the item that generated an
event. Its signature is shown here:
Object getItem()
8. The getItemSelectable() method can be used to obtain a reference to the
ItemSelectable object that generated an event. Its general form shown here:
itemSelectable getItemSelectable()
9. Lists and choices are examples of user interface elements that implement the
ItemSelectable interface.
10. The getStateChange() method returns the state change for the event. It is shown
here:
int getStateChange()

96

import java.applet.*;
ItemEvent Example in Checkbox
import java.awt.*;
import java.awt.event.*;
/*
<applet code="Checkbox_Setnull.class" height=300 width=1000>
</applet>
*/
public class Checkbox_Setnull extends Applet implements ItemListener
{
TextField tf1,tf2,tf3;
Label l1,l2,l3;
Checkbox ch1,ch2,ch3,ch4,ch5;
int x,y,z;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);
setLayout(null);
l1 = new Label("Enter the A Value");
l1.setBounds(0,0,100,25);
l2 = new Label("Enter the B Value");
l2.setBounds(0,50,100,25);
l3 = new Label("Addition of the Two Numbers");
l3.setBounds(0,100,170,25);

97

tf1 = new TextField(10);

tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
ch1 = new Checkbox("Addition");
ch1.setBounds(100,150,150,25);
ch2 = new Checkbox("Subtraction");
ch2.setBounds(250,150,150,25);
ch3 = new Checkbox("Multiplication");
ch3.setBounds(400,150,150,25);
ch4 = new Checkbox("Division");
ch4.setBounds(550,150,150,25);
ch5 = new Checkbox("Clear");
ch5.setBounds(700,150,150,25);
add(l1); add(tf1); add(l2); add(tf2); add(l3); add(tf3); add(ch1);
add(ch2); add(ch3); add(ch4); add(ch5);
ch1.addItemListener(this); ch2.addItemListener(this);
ch3.addItemListener(this); ch4.addItemListener(this);
ch5.addItemListener(this);
}

98

public void itemStateChanged(ItemEvent ie)

{
if(ch1.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x + y;
tf3.setText(String.valueOf(z));
}
if(ch2.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x - y;
tf3.setText(String.valueOf(z));
}

99

if(ch3.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x * y;
tf3.setText(String.valueOf(z));
}
if(ch4.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x / y;
tf3.setText(String.valueOf(z));
}
if(ch5.getState()==true)
{
tf1.setText("");
}
}
}

tf2.setText("");

tf3.setText("");
100

import java.applet.*;
ItemEvent Example in CheckboxGroup
import java.awt.*;
import java.awt.event.*;
/*
<applet code="Checkboxgroup_Setnull.class" height=300 width=1000>
</applet>
*/
public class Checkboxgroup_Setnull extends Applet implements ItemListener
{
TextField tf1,tf2,tf3;
Label l1,l2,l3;
Checkbox ch1,ch2,ch3,ch4,ch5;
CheckboxGroup cbg;
int x,y,z;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);
setLayout(null);
cbg = new CheckboxGroup();
l1 = new Label("Enter the A Value");
l1.setBounds(0,0,100,25);
l2 = new Label("Enter the B Value");
l2.setBounds(0,50,100,25);
101
l3 = new Label("Compute the Two Numbers");
l3.setBounds(0,100,170,25);

tf1 = new TextField(10);

tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
ch1 = new Checkbox("Addition",cbg,false);
ch1.setBounds(100,150,150,25);
ch2 = new Checkbox("Subtraction",cbg,false);
ch2.setBounds(250,150,150,25);
ch3 = new Checkbox("Multiplication",cbg,false);
ch3.setBounds(400,150,150,25);
ch4 = new Checkbox("Division",cbg,false);
ch4.setBounds(550,150,150,25);
ch5 = new Checkbox("Clear",cbg,false);
ch5.setBounds(700,150,150,25);
add(l1); add(tf1); add(l2); add(tf2); add(l3); add(tf3); add(ch1);
add(ch2); add(ch3); add(ch4); add(ch5);
ch1.addItemListener(this); ch2.addItemListener(this);
ch3.addItemListener(this); ch4.addItemListener(this);
ch5.addItemListener(this);
}

102

public void itemStateChanged(ItemEvent ie)

{
if(ch1.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x + y;
tf3.setText(String.valueOf(z));
l3.setVisible(true);
tf3.setVisible(true);
}
if(ch2.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x - y;
tf3.setText(String.valueOf(z));
}

103

if(ch3.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x * y;
tf3.setText(String.valueOf(z));
}
if(ch4.getState()==true)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x / y;
tf3.setText(String.valueOf(z));
}
if(ch5.getState()==true)
{
tf1.setText("");
}
}
}

tf2.setText("");

tf3.setText("");
104

ItemEvent Example in Choice Box

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
/*
<applet code="Choicebox_Setnull.class" height=300 width=1000>
</applet>
*/
public class Choicebox_Setnull extends Applet implements ItemListener
{
TextField tf1,tf2,tf3;
Label l1,l2,l3;
Choice ch;
int x,y,z;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);
setLayout(null);
l1 = new Label("Enter the A Value");
l1.setBounds(0,0,100,25);
l2 = new Label("Enter the B Value");
l2.setBounds(0,50,100,25);
l3 = new Label("Compute the Two Numbers");
105
l3.setBounds(0,100,170,25);

tf1 = new TextField(10);

tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
ch = new Choice();
ch.setBounds(100,150,150,25);
ch.add(""); ch.add("Addition"); ch.add("Subtraction");
ch.add("Multiplication"); ch.add("Division"); ch.add("Clear");
ch.add("Total No. of Item"); ch.add("Get Selected Item");
add(l1); add(tf1); add(l2); add(tf2); add(l3); add(tf3); add(ch);
ch.addItemListener(this);
}

106

public void itemStateChanged(ItemEvent ie)

{
if(ch.getSelectedIndex() == 1)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x + y;
tf3.setText(String.valueOf(z));
}
if(ch.getSelectedIndex() == 2)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x - y;
tf3.setText(String.valueOf(z));
}

107

if(ch.getSelectedIndex() == 3)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x * y; tf3.setText(String.valueOf(z));
}
if(ch.getSelectedIndex() == 4)
{
x = Integer.parseInt(tf1.getText());
y = Integer.parseInt(tf2.getText());
z = x / y; tf3.setText(String.valueOf(z));
}
if(ch.getSelectedIndex() == 5)
{
tf1.setText(""); tf2.setText(""); tf3.setText("");
}
if(ch.getSelectedIndex() == 6)
{
int a = ch.getItemCount(); tf3.setText(String.valueOf(a));
}
if(ch.getSelectedIndex() == 7)
{
tf3.setText(ch.getItem(ch.getSelectedIndex()));
108
}
}

The KeyEvent Class

1. A KeyEvent is generated when keyboard input occurs.
2. There are three types of key events, which are identified by these integer constants:
KEY_PRESSED, KEY_RELEASED and KEY_TYPED.
3. The first two events are generated when any key is pressed or released.
4. The last event occurs only when a character is generated.
5. Remember, not all key presses result in characters.
6. For example, pressing the SHIFT key does not generate a character.
7. There are many other integer constants that are defined by KeyEvent.
8. For example, VK_0 through VK_9 and VK_A through VK_Z define the ASCII
equivalents of the numbers and letters. Here are some others:
VK_ENTER

VK_ESCAPE

VK_CANCEL

VK_UP

VK_DOWN

VK_LEFT

VK_RIGHT

VK_PAGE_DOWN

VK_PAGE_UP

VK_SHIFT

VK_ALT

VK_CONTROL
109

9. The VK constants specify virtual key codes and are independent of any modifiers,
such as control, shift, or alt. KeyEvent is a subclass of InputEvent.
10. Here are two of its constructors:
KeyEvent(Component src, int type, long when, int modifiers, int code)
KeyEvent(Component src, int type, long when, int modifiers, int code, char ch)
11. Here, src is a reference to the component that generated the event.
12. The type of the event is specified by type.
13. The system time at which the key was pressed is passed in when.
14. The modifiers argument indicates which modifiers where pressed when this key
event occurred.
15. The virutal key code, such as VK_UP, VK_A, and so forth, is passed in code.
16. The character equivalent is passed in ch. If no valid character exists, then ch
contains CHAR_UNDEFINED.
17. For KEY_TYPED events, code will contain VK_UNDEFINED.
18. The KeyEvent class defines several methods, but the most commonly used ones are
getKeyChar(), which returns the character that was entered, and getKeyCode(), which
110
returns the key code.

//the key event handles

import java.awt.*;
import java.awt.event.*;
import java.applet.*;
/*
<applet code=Key_Event.class width=300 height=100>
</applet>
*/
public class Key_Event extends Applet implements KeyListener
{
String msg="";
int x=10,y=20;
public void init()
{
addKeyListener(this);
}
public void keyPressed(KeyEvent ke)
{
showStatus("Key Down");
}
public void keyReleased(KeyEvent ke)
{
showStatus("Key Up");
}
public void keyTyped(KeyEvent ke)
{
msg+=ke.getKeyChar();
repaint();
}
public void paint(Graphics g)
{
g.drawString(msg,x,y);
}
}

KeyEvent Example in Keyboard

111

Their general forms are shown here:

char getKeyChar()
int getKeyCode()
If not valid character is available, then getKeyChar() returns CHAR_UNDEFINED. When
a KEY_TYPED event occurs, getKeyCode() returns VK_UNDEFINED

The TextEvent Class

Instances of this class describe text events. These are generated by text fields and text
areas when characters are entered by a user or program. TextEvent defines the integer
constant TEXT_VALUE_CHANGED. The one constructor for this class is shown here:
TextEvent(Object src, int type)

Here, src is a reference to the object that generated this event. The type of the event is
specified by type.
112

import java.applet.*;
TextEvent Example in Textbox
import java.awt.*;
import java.awt.event.*;
/*
<applet code="Text_Event.class" height=300 width=1000>
</applet>
*/
public class Text_Event extends Applet implements TextListener
{
TextField tf1,tf2,tf3;
public void init()
{
setBackground(Color.red);
setForeground(Color.green);
tf1 = new TextField(10);
tf1.setBounds(200,0,100,25);
tf2 = new TextField(10);
tf2.setBounds(200,50,100,25);
tf3 = new TextField(10);
tf3.setBounds(200,100,100,25);
add(tf1);
add(tf2);
add(tf3);
tf1.addTextListener(this);
tf2.addTextListener(this);
}
public void textValueChanged(TextEvent te)
{
tf3.setText(tf1.getText());
113
}
}

The WindowEvent Class

There are ten types of window events. The WindowEvent class defines integer constants
that can be used to identify them. The constant and their meanings are shown here:
WINDOW_ACTIVATED

- The window was activate

WINDOW_CLOSED

- The window has been closed

WINDOW_CLOSING

- The user requested that the window be closed

WINDOW_DEACTIVATED

- The window was deactivated.

WINDOW_DEICONIFIED

- The window was deiconified.

WINDOW_GAINED_FOCUS

- The window gained input focus.

WINDOW_ICONIFIED

- The window was iconified.

WINDOW_LOST_FOCUS

- The window lost input focus.

WINDOW_OPENED

- The window was opened.

WINDOW_STATE_CHANGED

- The state of the window changed.

114

WindowEvent is a subclass of ComponentEvent. It defines the following constructor.

WindowEvent(Window src, int type)
Here, src is a reference to the object that generated this event. The type of the event is
type.

The most commonly used method in this class is getWindow(). It returns the Window
object that generated the event. Its general form is shown here:
Window getWindow()

115

Event Classes

Event Listener Interfaces

Event Listener Interfaces Methods

ActionEvent

ActionListener

void actionPerformed(ActionEvent ae)

AdjustmentEvent

AdjustmentListener

void adjustmentValueChanged(AdjustmentEvent ae)

ComponentEvent

ComponentListener

void componentResized(ComponentEvent ce)

void componentMoved(ComponentEvent ce)
void componentShown(ComponentEvent ce)
void componentHidden(CommonentEvent ce)

ContainerEvent

ContainerListener

void componentAdded(ContainerEvent ce)

void componentRemoved(ContainterEvent ce)

FocusEvent

FocusListener

void focusGained(FocusEvent fe)

void focusLost(FocusEvent fe)

ItemEvent

ItemListener

void itemStateChanged(ItemEvent ie)

KeyEvent

KeyListener

Void keyPressed(KeyEvent ke)

Void keyReleased(KeyEvent ke)
Void KeyTyped(KeyEvent ke)

MouseEvent

MouseListener

void mouseClicked(MouseEvent me)

void mouseEntered(MouseEvent me)
void mouseExited(MouseEvent me)
void mousePressed(MouseEvent me)
void mouseReleased(MouseEvent me)

MouseMotionListener

void mouseDragged(MouseEvent me)

void mouseMoved(MouseEvent me)

InputEvent

116

Event Classes

Event Listener Interfaces

Event Listener Interfaces Methods

MouseWheelEvent

MouseWheelListener

void mouseWheelMoved(MouseWheelEvent mwe)

TextEvent

TextListener

void textChanged(TextEvent te)

WindowEvent

WindowsListener

void windowActivated(WindowEvent we)

void windowClosed(WindowEvent we)
void windowClosing(WindowEvent we)
void windowDeactivated(WindowEvent we)
void windowDeiconified(WindowEvent we)
void windowIconified(WindowEvent we)
void windowOpened(WindowEvent we)

WindowFocusListener

Void windowGainedFocus(WindowEvent we)

Void windowLostFocus(WindowEvent we)

117

Sources of Events
Event Source

Description

Button

Generates action events when the button is pressed.

Checkbox

Generates item event s when the check box is selected or deselected.

Choice

Generates item event s when the choice is changed.

List

Generates action event s when an item is double clicked; generates item

event when an item is selected or deselected.

Menu Item

Generates action event swhen a menu item is selected; generates item

events when a checkable menu item is selected or deselected.

Scrollbar

Generates adjustment event when the scroll bar is manipulated.

Text components

Generates text events when the user enters a character.

Window

Generated window events when a window is activated, closed, deactivated,

deiconified, iconified, opened, or quit.

118

APPLET CONTROLS

119

120

Networking

Computer on Internet communicate to each other using any one of the

following:
Transmission Control Protocol(TCP)
User Datagram Protocol(UDP)
Every Host in the network is identified by using unique ID - Internet protocol
(IP) addresses
Every host on Internet has a unique IP address
143.89.40.46, 203.184.197.198 203.184.197.196, 203.184.197.197,
127.0.0.
More convenient to refer to using hostname string
cse.ust.hk, tom.com, localhost
One hostname can correspond to multiple internet addresses:
www.yahoo.com:
66.218.70.49; 66.218.70.50; 66.218.71.80; 66.218.71.84;
Domain Naming Service (DNS) maps names to numbers

121

Networking

Socket

A socket is bound to a port number so that the TCP layer can identify the
correct application for data

Ports
Many different services can be running on the host. A port identifies a service
within a host
Many standard port numbers are pre-assigned time of day 13, ftp 21, telnet 23,
smtp 25, http 80
IP address + port number = "phone number for service
protocols : rules that facilitate communications between machines
Examples:
1.HTTP: HyperText Transfer Protocol
2.FTP: File Transfer Protocol
3.SMTP: Simple Message Transfer Protocol
4.TCP: Transmission Control Protocol
5.UDP: User Datagram Protocol, good for, e.g., video delivery)
122
Protocols are standardized and documented. So machines can reliably work
with one another

Networking

Client-Server interaction
Communication between hosts is two-way, but usually the two hosts take
different roles
Server
Server waits for client to make request
Server registered on a known port with the host ("public phone number")
Usually running in endless loop
Listens for incoming client connections
Server offers shared resource (information,database, files, printer, compute
power) to clients

Client
Client "calls" server to start a conversation
Client making calls uses hostname/IP address and port number
Sends request and waits for response
Standard services always running ftp, http, smtp, etc. server running on
123
host using expected port

Networking Socket level

java.net.Socket is an abstraction of a bi-directional communication
Programming
channel between hosts
Send and receive data using streams

OutputStream

InputStream

Client

Server
InputStream

OutputStream

124

Client/Server Communications
The server must be running when a client
starts. The server waits for a connection request
from a client. To establish a server, you need to
create a server socket and attach it to a port,
which is where the server listens for
connections.

Server Host
Server socket on port 8000
SeverSocket server =
new ServerSocket(8000);

Client Host

I/O Stream

A client socket
Socket socket =
server.accept()
After a server
socket is
created, the
server can use
this statement
to listen for
connections.

After the server accepts

the connection,
communication between
server and client is
conducted the same as for
I/O streams.

Client socket
Socket socket =
new Socket(host, 8000)

125

The client issues

this statement
to request a
connection to a
server.

Networking Communication
TCP
- Transmission Control Protocol
Protocols

Reliable - When TCP segments, the smallest unit of TCP transmissions, are
lost or corrupted, the TCP implementation will detect this and retransmit
necessary segments
Connection-oriented - TCP sets up a connection before transmission of any
data
Continuous Stream - TCP provides a communication medium that allows for
an arbitrary number of bytes to be sent and received smoothly

UDP User Datagram Protocol

Unreliable - UDP has no mechanism for detecting errors nor for
retransmission of lost data
Connectionless - UDP does not negotiate a connection before transmission
of data
Message-oriented - UDP allows application to send self-contained messages
within UDP datagrams

126

Networking

Occasionally, you would like to know who is connecting to the server. You
can use the InetAddress class to find the client's host name and IP
address. The InetAddress class models an IP address. You can use the
statement shown below to create an instance of InetAddress for the client
on a socket.
InetAddress inetAddress = socket.getInetAddress();
Next, you can display the client's host name and IP address, as follows:
System.out.println("Client's host name is " +
inetAddress.getHostName());
System.out.println("Client's IP Address is " +
inetAddress.getHostAddress());

127

Networking - Inside Java.net

The
Socket
Server Socket
DatagramSocket and
MulticastSocket

Classes implement client and server sockets for connection-oriented and

connectionless communication.

128

UDP Client

import java.net.*;
import java.io.*;

class UDPClient
{
publicstaticvoid main(String args[]) throws Exception
{
DatagramSocket dsoc=new DatagramSocket(24);
byte buff[]=newbyte[1024];
DatagramPacket dpack=new DatagramPacket(buff,buff.length);
dsoc.receive(dpack);
System.out.println(new String(dpack.getData()));
}
}

129

UDP Server

import java.net.*;
import java.io.*;
import java.util.*;

class UDPServer
{
publicstaticvoid main(String args[]) throws Exception
{
DatagramSocket dsoc=new DatagramSocket(5217);
InetAddress host=InetAddress.getLocalHost();
String str=(new Date()).toString();
byte buf[]=str.getBytes();
dsoc.send(new DatagramPacket(buf,buf.length,host,24));
dsoc.close();
}
}
130

TCP - Simple-Client Example

This client tries to connect to a server (coming soon) and port given on
the command line, then sends some output to the server, and finally
receives some input which is printed on the screen.

TCP
- Simple-Server Example
The server creates a server socket that listen on the port given on the command
line. It then enters infinite loop doing the following: when a connection with a client
is established it reads some input from the client (terminated with a 0 byte), sends
back the message Simon says: plus the input received, and closes the connection.