Unit - 4

IO Streams and Applet

4.1 IO Stream (java.io.package): Introduction

Stream:

Stream – A sequence of data.
Input Stream: reads data from source.
Output Stream: writes data to destination.

4.2 Byte Stream and Character Stream

Byte Stream Classes:

Input Stream Class:

The Input Stream class provides methods to read bytes from a file, console or memory. It is an abstract class

The Input Stream class contains various methods to read the data from an input stream. These methods are overridden by the classes that inherit the Input Stream class.

However, the methods are given in the following table.

Output Stream Class

The Output Stream class provides various methods to write bytes to the output streams. The methods are given in the following table.

Character Stream

Reader Class

The Reader class methods are given in the following table.

Writer Class

Writer class is used to write 16-bit Unicode characters to the output stream. 

The subclasses of the Writer class are used to write the characters onto the

Output stream. The subclasses of the Writer class are given in the below table.

To write the characters to the output stream, the Write class provides various methods given in the following table.

4.3 Files and Random Access Files

The File class is an abstract representation of file and directory pathname. A pathname can be either absolute or relative.

The File class have several methods for working with directories and files such as creating new directories or files, deleting and renaming directories or files, listing the contents of a directory etc.

Fields

Constructors

Useful Methods

File Example 1

Import java.io.*;  

Public class FileDemo {  

Public static void main(String[] args) {  

Try {  

File file = new File("javaFile123.txt");  

If (file.createNewFile()) {  

System.out.println("New File is created!");  

} else {  

System.out.println("File already exists.");  

}  

} catch (IOException e) {  

e.printStackTrace();  

}  

}  

}  

Output:

New File is created!

File Example 2

Import java.io.*;  

Public class FileDemo2 {  

Public static void main(String[] args) {  

String path = "";  

Boolean bool = false;  

Try {  

// createing  new files  

File file  = new File("testFile1.txt");  

File.createNewFile();  

System.out.println(file);  

// createing new canonical from file object  

File file2 = file.getCanonicalFile();  

// returns true if the file exists  

System.out.println(file2);  

Bool = file2.exists();  

// returns absolute pathname  

Path = file2.getAbsolutePath();  

System.out.println(bool);  

// if file exists  

If (bool) {  

// prints  

System.out.print(path + " Exists? " + bool);  

}  

} catch (Exception e) {  

// if any error occurs  

e.printStackTrace();  

}  

}  

}  

Output:

TestFile1.txt

/home/Work/Project/File/testFile1.txt

True

/home/Work/Project/File/testFile1.txt Exists? true

Random Access File

This class is used for reading and writing to random access file. A random access file behaves like a large array of bytes. There is a cursor implied to the array called file pointer, by moving the cursor we do the read write operations. If end-of-file is reached before the desired number of byte has been read than EOF Exception is thrown. It is a type of IO Exception.

Constructor

Method

Example:

Import java.io.IOException;  

Import java.io.RandomAccessFile;  

Public class RandomAccessFileExample {  

Static final String FILEPATH ="myFile.TXT";  

Public static void main(String[] args) {  

Try {  

System.out.println(new String(readFromFile(FILEPATH, 0, 18)));  

WriteToFile(FILEPATH, "I love my country and my people", 31);  

} catch (IOException e) {  

e.printStackTrace();  

}  

}  

Private static byte[] readFromFile(String filePath, int position, int size)  

Throws IOException {  

RandomAccessFile file = new RandomAccessFile(filePath, "r");  

File.seek(position);  

Byte[] bytes = new byte[size];  

File.read(bytes);  

File.close();  

Return bytes;  

}  

Private static void writeToFile(String filePath, String data, int position)  

Throws IOException {  

RandomAccessFile file = new RandomAccessFile(filePath, "rw");  

File.seek(position);  

File.write(data.getBytes());  

File.close();  

}  

}  

The myFile.TXT contains text "This class is used for reading and writing to random access file."

After running the program it will contains

This class is used for reading I love my country and my people.

4.4 Serialization

Serialization in Java is a mechanism of writing the state of an object into a byte-stream. It is mainly used in Hibernate, RMI, JPA, EJB and JMS technologies.

The reverse operation of serialization is called deserialization where byte-stream is converted into an object.

The serialization and deserialization process is platform-independent, it means you can serialize an object on one platform and deserialize it on a different platform.

For serializing the object, we call the writeObject() method of Object Output Stream class, and for deserialization we call the readObject() method of Object Input Stream class.

Java.io.Serializable interface

Serializable is a marker interface (has no data member and method). It is used to "mark" Java classes so that the objects of these classes may get a certain capability. The Cloneable and Remote are also marker interfaces.

The Serializable interface must be implemented by the class whose object needs to be persisted.

The String class and all the wrapper classes implement the java.io.Serializable interface by default.

Object Output Stream class:

The Object Output Stream class is used to write primitive data types, and Java objects to an Output Stream.

Only objects that support the java.io.Serializable interface can be written to streams.             

Constructor

Important Methods

Object Input Stream class

An Object Input Stream deserializes objects and primitive data written using an Object Output Stream.

Constructor

Methods are

4.5 Collection Frame Work (java.util), Introduction

The Collection in Java is a framework that provides an architecture to store and manipulate the group of objects.

Java Collections can achieve all the operations that you perform on a data such as searching, sorting, insertion, manipulation, and deletion.

Java Collection means a single unit of objects. Java Collection framework provides many interfaces (Set, List, Queue, Deque) and classes (Array List, Vector, LinkedList, Priority Queue, HashSet, Linked Hash Set, Tree Set).

Introduction

A Collection represents a single unit of objects, i.e., a group.

Framework in Java

• It provides readymade architecture.
• It represents a set of classes and interfaces.
• It is optional.

What is Collection framework

The Collection framework represents a unified architecture for storing and manipulating a group of objects. It has:

1. Interfaces and its implementations, i.e., classes
2. Algorithm

Hierarchy of Collection Framework

Let us see the hierarchy of Collection framework. The java.util package contains all the classes and interfaces for the Collection framework.

Methods of Collection interface

There are many methods declared in the Collection interface. They are as follows:

4.6 Util Packages Interfaces

The java.util.Interfaces contains the collections framework, legacy collection classes, event model, date and time facilities, internationalization, and miscellaneous utility classes (a string tokenizer, a random-number generator, and a bit array)

1. Collection<E>:  This is the root interface in the collection hierarchy.
2. Comparator<T>: It is a comparison function, which imposes a total ordering on some collection of objects
3. Set<E>:   This is a collection that contains no duplicate elements.
4. Sorted Map<K, V>:  This is a Map that further provides a total ordering on its keys
5. Sorted Set<E>: This is a Set that further provides a total ordering on its elements.
6. RandomAccess(): This is the Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.
7. Map. Entry<K, V>: This is a map entry (key-value pair).
8. Queue<E>: This is a collection designed for holding elements prior to processing.
9. Observer: This is a class can implement the Observer interface when it wants to be informed of changes in observable objects.
10. Event Listener: This is a tagging interface that all event listener interfaces must extend.
11. Map<K, V>: This is an object that maps keys to values.
12. Deque<E>: This is a linear collection that supports element insertion and removal at both ends.
13. List<E>: This is an ordered collection (also known as a sequence).
14. List Iterator<E>: This is an iterator for lists that allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator's current position in the list.

4.7 List, Set, Map etc.

Set Interface in Java is present in java.util package.

It extends the Collection interface.

It represents the unordered set of elements which doesn't allow us to store the duplicate items. We can store at most one null value in Set. Set is implemented by HashSet, Linked Hash Set, and TreeSet.

Set can be instantiated as:

Set<data-type> s1 = new HashSet<data-type>();  

Set<data-type> s2 = new LinkedHashSet<data-type>();  

Set<data-type> s3 = new TreeSet<data-type>();

HashSet

HashSet class implements Set Interface. It represents the collection that uses a hash table for storage. Hashing is used to store the elements in the HashSet. It contains unique items.

Consider the following example.

Import java.util.*;  

Public class TestJavaCollection7{  

Public static void main(String args[]){  

//Creating HashSet and adding elements  

HashSet<String> set=new HashSet<String>();  

Set.add("Ravi");  

Set.add("Vijay");  

Set.add("Ravi");  

Set.add("Ajay");  

//Traversing elements  

Iterator<String> itr=set.iterator();  

While(itr.hasNext()){  

System.out.println(itr.next());  

}  

}  

}  

Output:

Vijay

Ravi

Ajay

Linked Hash Set

Linked Hash Set class represents the LinkedList implementation of Set Interface. It extends the HashSet class and implements Set interface. Like HashSet, It also contains unique elements. It maintains the insertion order and permits null elements.

Consider the following example

Import java.util.*;  

Public class TestJavaCollection8{  

Public static void main(String args[]){  

LinkedHashSet<String> set=new LinkedHashSet<String>();  

Set.add("Ravi");  

Set.add("Vijay");  

Set.add("Ravi");  

Set.add("Ajay");  

Iterator<String> itr=set.iterator();  

While(itr.hasNext()){  

System.out.println(itr.next());  

}  

}  

}  

Output:

Ravi

Vijay

Ajay

TreeSet

Java TreeSet class implements the Set interface that uses a tree for storage. Like HashSet, TreeSet also contains unique elements. However, the access and retrieval time of TreeSet is quite fast. The elements in TreeSet stored in ascending order.

Consider the following example:

Import java.util.*;  

Public class TestJavaCollection9{  

Public static void main(String args[]){  

//Creating and adding elements  

TreeSet<String> set=new TreeSet<String>();  

Set.add("Ravi");  

Set.add("Vijay");  

Set.add("Ravi");  

Set.add("Ajay");  

//traversing elements  

Iterator<String> itr=set.iterator();  

While(itr.hasNext()){  

System.out.println(itr.next());  

}  

}  

}  

Output:

Ajay

Ravi

Vijay

Map Interface

A map contains values on the basis of key, i.e. key and value pair. Each key and value pair is known as an entry. A Map contains unique keys.

A Map is useful if you have to search, update or delete elements on the basis of a key.

Java Map Hierarchy

There are two interfaces for implementing Map in java: Map and Sorted Map, and three classes: HashMap, Linked Hash Map, and Tree Map. The hierarchy of Java Map is given below:

A Map doesn't allow duplicate keys, but you can have duplicate values. HashMap and Linked Hash Map allow null keys and values, but Tree Map doesn't allow any null key or value.

A Map can't be traversed, so you need to convert it into Set using keySet() or entrySet() method.

Useful methods of Map interface

Map Example

Import java.util.*;  

Class MapExample2{  

Public static void main(String args[]){  

Map<Integer,String> map=new HashMap<Integer,String>();  

Map.put(100,"Amit");  

Map.put(101,"Vijay");  

Map.put(102,"Rahul");  

//Elements can traverse in any order  

For(Map.Entry m:map.entrySet()){  

System.out.println(m.getKey()+" "+m.getValue());  

}  

}  

}  

Output:

102 Rahul

100 Amit

101 Vijay

Map Example: comparingByKey()

Import java.util.*;  

Class MapExample3{  

Public static void main(String args[]){  

Map<Integer,String> map=new HashMap<Integer,String>();          

Map.put(100,"Amit");    

Map.put(101,"Vijay");    

Map.put(102,"Rahul");   

//Returns a Set view of the mappings contained in this map        

Map.entrySet()  

//Returns a sequential Stream with this collection as its source  

.stream()  

//Sorted according to the provided Comparator  

.sorted(Map.Entry.comparingByKey())  

//Performs an action for each element of this stream  

.forEach(System.out::println);  

}  

}  

Output:

100=Amit

101=Vijay

102=Rahul

Map Example: comparingByKey() in Descending Order

Import java.util.*;  

Class MapExample4{  

Public static void main(String args[]){  

Map<Integer,String> map=new HashMap<Integer,String>();                map.put(100,"Amit");    

Map.put(101,"Vijay");    

Map.put(102,"Rahul");    

//Returns a Set view of the mappings contained in this map    

Map.entrySet()  

//Returns a sequential Stream with this collection as its source  

.stream()  

//Sorted according to the provided Comparator  

.sorted(Map.Entry.comparingByKey(Comparator.reverseOrder()))  

//Performs an action for each element of this stream  

.forEach(System.out::println);  

}  

}  

Output:

102=Rahul

101=Vijay

100=Amit

4.8 List Interfaces and Its Classes

Declaration:

Public interface List<E> extends Collection<E>

Java List Methods:

Example:

1. Creating a List of type String using ArrayList  

List<String> list=new ArrayList<String>();  

2.    Creating a List of type Integer using ArrayList  

List<Integer> list=new ArrayList<Integer>();

3.    Creating a List of type Book using ArrayList  

List<Book> list=new ArrayList<Book>();  

4.    Creating a List of type String using LinkedList  

List<String> list=new LinkedList<String>();  

List Example

Let's see a simple example of List where we are using the Array List class as the implementation.

Import java.util.*;  

Public class ListExample1{  

Public static void main(String args[]){  

//Creating a List  

List<String> list=new ArrayList<String>();  

//Adding elements in the List  

List.add("Mango");  

List.add("Apple");  

List.add("Banana");  

List.add("Grapes");  

//Iterating the List element using for-each loop  

For(String fruit:list)  

System.out.println(fruit);  

}  

}  

Output:

Mango

Apple

Banana

Grapes

How to convert Array to List

We can convert the Array to List by traversing the array and adding the element in list one by one using list.add() method. Let's see a simple example to convert array elements into List.

Import java.util.*;  

Public class ArrayToListExample{  

Public static void main(String args[]){  

//Creating Array  

String[] array={"Java","Python","PHP","C++"};  

System.out.println("Printing Array: "+Arrays.toString(array));  

//Converting Array to List  

List<String> list=new ArrayList<String>();  

For(String lang:array){  

List.add(lang);  

}  

System.out.println("Printing List: "+list);  

}  

}  

Output:

Printing Array: [Java, Python, PHP, C++]

Printing List: [Java, Python, PHP, C++]

How to convert List to Array

We can convert the List to Array by calling the list.toArray() method. Let's see a simple example to convert list elements into array.

Import java.util.*;  

Public class ListToArrayExample{  

Public static void main(String args[]){  

List<String> fruitList = new ArrayList<>();    

FruitList.add("Mango");    

FruitList.add("Banana");    

FruitList.add("Apple");    

FruitList.add("Strawberry");    

//Converting ArrayList to Array  

String[] array = fruitList.toArray(new String[fruitList.size()]);    

System.out.println("Printing Array: "+Arrays.toString(array));  

System.out.println("Printing List: "+fruitList);  

}  

}  

Output:

Printing Array: [Mango, Banana, Apple, Strawberry]

Printing List: [Mango, Banana, Apple, Strawberry]

Difference between List, Set, and Map interface:

The List, Set and Map interfaces are significant members of the Java

1. Ordering: -

1. List: - represents an ordered sequence in Java whose elements are accessible by index.
2. Set: - represents a distinct collection of elements in Java which can be either ordered or unordered, depending on the               implementation.

Example:  a) HashSet implementation is unordered

b) TreeSet implementation is ordered by natural order or provided comparator.

3.  Map: - represents the mapping of the key to values in Java. The ordering in Map is also implementation-specific

Example: Tree Map class is ordered while the HashMap class is not.

B.      Duplicates:

1. List: List can have duplicate elements
2. Set: A set contain only distinct elements
3. Map: Map doesn’t permit duplicate keys, i.e., each key can map to at most one value.

C.     Null Values:

1. List: It allows any number of null values
2. Set: a set contains at most one null element.
3. Map: Map typically allows null as a key and value, but some implementations prohibit null keys and values.

D.     Implementing Classes:

1. List: The most popular implementing classes of the List interface are Array List and LinkedList
2. Set: set interfaces included HashSet, TreeSet,  Linked Hash Set
3. Map: Map interfaces offers Tree Map, Linked Hash Map, Tree Map

E.      When to use List, Map and Set:

1. List:  List can be used when the insertion order of an elements need to be maintained.
2. Set:   We can use set if we need to maintain a collection that contain no duplicates.
3. Map: when data is key-value pairs and need fast retrieval   of value based on some key.

Getter And Setter classes in java

Getter method:

        A method which is used to retrieve/get the value of a variable or return the value of the private member variable is called getter method in Java.

        This method is also known as accessor method. For every private variable, we should create a getter method.

        Depending on the access level giving to the variable, we can set the access modifier of its getter method.

        If we declare instance variables as private, we will have to add public getter methods for each one.

        The signature of a getter method in Java is as follows:

Public returnType getPropertyName()

        If the returnType is boolean, the getter method should defined

Public boolean isPropertyName()

4.9 Setter Interfaces and its classes

        A method which is used for updating or setting the value of a variable is called setter method in Java. This method is also known as mutator method.

        we can modify the value of a variable.

        The signature of setter method in Java is as follows:

Public void setPropertyName(dataType propertyValue)

Examples:

1. If the variable is the type of int, you will declare like this:

Private int number;

Then appropriate getter and setter will be 

Public getNumber(); {  }

Public void setNumber(int number);

Similarly,
 

2. If the variable is a type of boolean then

Private boolean rich;

Public getRich() { }

Public setRich() { }

4.10 Applet: Introduction

An applet is a Java program that can be embedded into a web page. It runs inside the web browser and works at client side. An applet is embedded in an HTML page using the APPLET or OBJECT tag and hosted on a web server.

Important points:

1. All applets are sub-classes (either directly or indirectly) of java.applet.Applet class.
2. Applets are not stand-alone programs. Instead, they run within either a web browser or an applet viewer. JDK provides a standard applet viewer tool called applet viewer.
3. In general, execution of an applet does not begin at main() method.
4. Output of an applet window is not performed by System.out.println(). Rather it is handled with various AWT methods, such as drawString().

4.11 Life Cycle of an Applet

The life cycle of a Java Applet has five main steps. 

1.  Initialize the Applet
2. Start the Applet
3. Paint Applet
4. Stop the Applet
5. Destroy the Applet

1. Initialize the Applet

In this step, the Applet is initialized public void init() is the method used to initialize  an Applet. It is only invoked once

2. Start the Applet:   

In this step the Applet is start with the help of public void start()

Method.The start()method is  invoked after calling the init() method.

3. Paint Applet:

Public void paint(Graphics g) method is used to paint the Applet.

The method provides graphics class object that can be used to draw shapes as oval, rectangle, arc etc.

4. Stop Applet:

The Applet is stooped with the help of public void stop()method.

The method is invoked when the applet is stopped of the browser is minimized.

5. Destroy Applet:

This is the Final step in the Applet life cycle. The Applet initalized is destroyed in this step. It is only invoked once and the method used to invoke, is public void destory()         

4.12 Abstract Window Toolkit (AWT)

AWT Hierarchy

4.13 Introduction to GUI, GUI with an Applet

Introduction to GUI

GUI stands for Graphical User Interface. We interact with the screen in two ways one is console-based and the second one is a graphical user interface.

In console based we interact with help of text command eg. Command prompt whereas in GUI we interact with the help of graphical components which is also known as visual indicators eg. Calculator.

For graphical user interface there are two types of application programming interface (API’S) and they are AWT (abstract windowing toolkit) and swing.

Creating Hello World applet:

Let’s begin with the HelloWorld applet:

/ A Hello World Applet

// Save file as HelloWorld.java

Import java.applet.Applet;

Import java.awt.Graphics;

// HelloWorld class extends Applet

Public class HelloWorld extends Applet 

{

// Overriding paint() method

@Override

Public void paint(Graphics g) 

{

g.drawString("Hello World", 20, 20);

}

}

How to run  

1. The java program begins with two import statements. The first import statement imports the Applet class from applet package. Every AWT-based applet that you create must be a subclass (either directly or indirectly) of Applet class. The second statement import the Graphics class from AWT package.

2. The next line in the program declares the class HelloWorld. This class must be declared as public because it will be accessed by code that is outside the program. Inside HelloWorld, paint() is declared. This method is defined by the AWT and must be overridden by the applet.

3. Inside paint() is a call to drawString( ), which is a member of the Graphics class. This method outputs a string beginning at the specified X, Y location. It has the following general form:

Void drawString(String message, int x, int y)

Here, message is the string to be output beginning at x, y. In a Java window, the upper-left corner is location 0,0. The call to drawString( ) in the applet causes the message “Hello World” to be displayed beginning at location 20,20.

The applet does not have a main() method. Unlike Java programs, applets do not begin execution at main(). In fact, most applets don’t even have a main( ) method. Instead, an applet begins execution when the name of its class is passed to an applet viewer or to a network browser.

Running the HelloWorld Applet:

After you enter the source code for HelloWorld.java, compile in the same way that you have been compiling java programs (using javac command). However, running HelloWorld with the java command will generate an error because it is not an application.

There are two standard ways in which you can run an applet:

1. Executing the applet within a Java-compatible web browser.

To execute an applet in a web browser we have to write a short HTML text file that contains a tag that loads the applet. We can use APPLET or OBJECT tag for this purpose. Using APPLET, here is the HTML file that executes HelloWorld:

<applet code="HelloWorld" width=200 height=60>

</applet>

The APPLET tag contains several other options. After you create this html file, you can use it to execute the applet.

Using an applet viewer, such as the standard tool, applet-viewer. An applet viewer executes your applet in a window. This is generally the fastest and easiest way to test your applet.

To execute HelloWorld with an applet viewer, you may also execute the HTML file. For example, HTML file is   RunHelloWorld.html, then the following command line will run HelloWorld:

Applet viewer RunHelloWorld.html

4.14 Description of Components and Containers, Component/Container Hierarchy

Components

All the elements like the button, text fields, scroll bars, etc. are called components. In Java AWT, there are classes for each component as shown in above diagram. In order to place every component in a particular position on a screen, we need to add them to a container.

Container

The Container is a component in AWT that can contain another components like buttons, text fields, labels etc. The classes that extends Container class are known as container such as Frame, Dialog and Panel.

i.e Container itself is a components, therefore we can add a container inside container

There are four types of containers in Java AWT:

1. Window
2. Panel
3. Frame
4. Dialog

Window

The window is the container that have no borders and menu bars. You must use frame, dialog or another window for creating a window. We need to create an instance of Window class to create this container.

Panel

The Panel is the container that doesn't contain title bar, border or menu bar. It is generic container for holding the components. It can have other components like button, text field etc. An instance of Panel class creates a container, in which we can add components.

Frame

The Frame is the container that contain title bar and border and can have menu bars. It can have other components like button, text field, scrollbar etc. Frame is most widely used container while developing an AWT application.

Methods of Component Class

Hierarchy of components

4.15 Understanding different Components/Container classes and their constructors

4.16 Event Handling, Different mechanisms of Event Handling

Event handling is elemental to Java programming because it is used to make event driven programs eg Applets, GUI based windows application, Web Application.

Two Event Handling Mechanisms in Java

1. Original Version of Java (1.0)
2. Modern Versions of Java, beginning with Java version 1.1

Event handling mechanisms have been changed quite between the original version of Java (1.0) and all following versions of Java, beginning with version 1.1. 

The modern technique to handling events is based on the delegation event model 

What is an Event? 

Change in the state of an object is known as event i.e. event describes the change in state of source. 

What is Event Handling? 

Event Handling is the mechanism that controls the event and decides what should happen if an event occurs. This mechanism has the code which is known as event handler that is executed when an event occurs. Java Uses the Delegation Event Model to handle the events. This model defines the standard mechanism to generate and handle the events. 

The Delegation Event Model has the following key participants namely: 

• Source - The source is an object on which event occurs. 
• Source is responsible for delivering information of the occurred event to its handler. Java provides classes for source object. 
• Listener - It is also known as event handler. Listener is responsible for generating the response to an event. From java execution point of view, the listener is also an object. The listener waits until it receives an event. Once the event is received , the listener process the event and then returns. 

Delegation Event Model

Writing event driven program is a two step method 

• Implement the suitable interface in the listener so that it can receive the type of event desired. 
• Implement code to register and unregister (if necessary) the listener as a recipient for the event notifications

4.17 Listener Interfaces

Event and Listener (Java 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.

Java Event classes and Listener interfaces

We can put the event handling code into one of the following places:

1. Within class
2. Other class
3. Anonymous class

Following steps are required to perform event handling:

1. Register the component with the Listener

• Button:  public void addActionListener(ActionListener a){}
• Menu Item:  public void addActionListener(ActionListener a){}
• Text Field:  public void addActionListener(ActionListener a){}         

Public void addTextListener(TextListener a){}

• Text Area:  public void addTextListener(TextListener a){}
• Checkbox: public void addItemListener(ItemListener a){}
• Choice:  public void addItemListener(ItemListener a){}
• List: public void addActionListener(ActionListener a){}                    

Public void addItemListener(ItemListener a){}

Java event handling by implementing ActionListener

Import java.awt.*;  

Import java.awt.event.*;  

Class AEvent extends Frame implements ActionListener{  

TextField tf;  

AEvent(){  

//create components  

Tf=new TextField();  

Tf.setBounds(60,50,170,20);  

Button b=new Button("click me");  

b.setBounds(100,120,80,30);  

//register listener  

b.addActionListener(this);//passing current instance  

//add components and set size, layout and visibility  

Add(b);add(tf);  

SetSize(300,300);  

SetLayout(null);  

SetVisible(true);  

}  

Public void actionPerformed(ActionEvent e){  

Tf.setText("Welcome");  

}  

Public static void main(String args[]){  

New AEvent();  

}  

}

8.2M

119

SQL CREATE TABLE

Public void setBounds(int xaxis, int yaxis, int width, int height); have been used in the above example that sets the position of the component it may be button, text field etc.

4.18 Java Adapter Classes

1. Java adapter classes provide the default implementation of listener interfaces.
2. The adapter classes are found in java.awt.event, java.awt.dnd and javax.swing.event packages.

Java.awt.event Adapter classes

Java.awt.dnd Adapter classes

Javax.swing.event Adapter classes

References:

1. Programming in Java. Second Edition. Oxford Higher Education. (Sachin Malhotra/Saura V Choudhary)

2. CORE JAVA For Beginners. (Rashmi Kanta Das), Vikas Publication

3. JAVA Complete Reference (9th Edition) Herbait Schelidt.