MC0078 – Java Programming (Book ID: B0831 & B0832) Assignment Set – 1

1. Explain the following major components of Java:

A) Class Loader : The Java Class loader is a part of the Java Runtime Environment that dynamically loads Java classes into the Java Virtual Machine. Usually classes are only loaded on demand. The Java run time system does not need to know about files and file systems because of class loaders. Delegation is an important concept to understand when learning about class loaders.

A software library is a collection of related object code. In the Java language, libraries are typically packaged in Jar files. Libraries can contain objects of different types. The most important type of object contained in a Jar file is a Java class. A class can be thought of as a named unit of code. The class loader is responsible for locating libraries, reading their contents, and loading the classes contained within the libraries. This loading is typically done "on demand", in that it does not occur until the class is actually used by the program. A class with a given name can only be loaded once by a given class loader.

B) Bytecode Verifier:The bytecode verifier traverses the bytecodes, constructs the type state information, and verifies the types of the parameters to all the bytecode instructions.

C) Security Manager:

A security manager is a Java virtual machine (VM) object that implements a security policy. By default, the Java 2® platform software provides a security manager that disallows all access to local system resources apart from read and write access to the directory and its subdirectories where the program is invoked. You can extend the default security manager to implement customized verifications and approvals for applets and applications, but the implementation must include the appropriate access verification code for every checkXXX method you override. If you do not include this code, no access verification check happens, and your code breaches the system security policy.

2. Discuss the following with suitable example programs for each:

A) Data Types in Java:

When declaring a variable, besides its name, you must provide the type of information that the variable will hold. The role of this type is to tell the compiler how much memory will be needed to store the value(s) of that variable. Since your program is not the only one used in the computer, memory has to be effectively managed.

The type of value that a variable will hold is called a data type. As you ay imagine, different variables can be meant to hold different types of values. Each data type uses a Java keyword to be characterized. As a modern language, Java provides even more support for its traditional data types. To do this, a class was created for each data type. This allows you to get more information from a variable declared with the particular data type you want to use.

B) Variables in Java:

As we know, an object stores its state in fields.

int cadence = 0;

int speed = 0;

int gear = 1;

The What Is an Object? discussion introduced you to fields, but you probably have still a few questions, such as: What are the rules and conventions for naming a field? Besides int, what other data types are there? Do fields have to be initialized when they are declared? Are fields assigned a default value if they are not explicitly initialized? We'll explore the answers to such questions in this lesson, but before we do, there are a few technical distinctions you must first become aware of. In the Java programming language, the terms "field" and "variable" are both used; this is a common source of confusion among new developers, since both often seem to refer to the same thing.

The Java programming language defines the following kinds of variables:

Instance Variables (Non-Static Fields) Technically speaking, objects store their individual states in "non-static fields", that is, fields declared without the static keyword. Non-static fields are also known as instance variables because their values are unique to each instance of a class (to each object, in other words); the currentSpeed of one bicycle is independent from the currentSpeed of another.

Class Variables (Static Fields) A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. A field defining the number of gears for a particular kind of bicycle could be marked as static since conceptually the same number of gears will apply to all instances. The code static int numGears = 6; would create such a static field. Additionally, the keyword final could be added to indicate that the number of gears will never change.

Local Variables Similar to how an object stores its state in fields, a method will often store its temporary state in local variables. The syntax for declaring a local variable is similar to declaring a field (for example, int count = 0;). There is no special keyword designating a variable as local; that determination comes entirely from the location in which the variable is declared — which is between the opening and closing braces of a method. As such, local variables are only visible to the methods in which they are declared; they are not accessible from the rest of the class.

Parameters You've already seen examples of parameters, both in the Bicycle class and in the main method of the "Hello World!" application. Recall that the signature for the main method is public static void main(String[] args). Here, the args variable is the parameter to this method. The important thing to remember is that parameters are always classified as "variables" not "fields". This applies to other parameter-accepting constructs as well (such as constructors and exception handlers) that you'll learn about later in the tutorial.

3. Write a program in Java to multiply two matrices.

import java.lang.*;import java.io.*;class Matrix{public static void main(String arg[])throws IOException{DataInputStream dis=new DataInputStream(System.in);System.out.println("Enter The Row Size Of The First Matrix");int r1=Integer.parseInt(dis.readLine());System.out.println("Enter The Column Size Of The First Matrix");int c1=Integer.parseInt(dis.readLine());System.out.println("Enter The Row Size Of The Second Matrix");int r2=Integer.parseInt(dis.readLine());System.out.println("Enter The Column Size Of The Second Matrix");int c2=Integer.parseInt(dis.readLine());int a[][]=new int[r1][c1];int b[][]=new int[r2][c2];int c[][]=new int[r1][c2];int i,j,k;System.out.println("Enter The Elements Into The First Matrix");for(i=0;ifor(j=0;j{a[i][j]=Integer.parseInt(dis.readLine());}System.out.println("Enter The Elements Into The Second Matrix");

for(i=0;ifor(j=0;j{b[i][j]=Integer.parseInt(dis.readLine());} if(c1!=r2)System.out.println("Multiplication Is Not Possible");else{for(i=0;i{for(j=0;j{c[i][j]=0;for(k=0;k{c[i][j]=c[i][j]+a[i][k]*b[k][j];}}}for(i=0;i{for(j=0;j{System.out.println(c[i][j]+" ");}System.out.println(" ");}}}}

4. Describe the theory of Exception Handling with relevant coding examples.

Exceptions in java are any abnormal, unexpected events or extraordinary conditions that may occur at runtime. They could be file not found exception, unable to get connection exception and so on. On such conditions java throws an exception object. Java Exceptions are basically Java objects. No Project can never escape a java error exception.

Java exception handling is used to handle error conditions in a program systematically by taking the necessary action. Exception handlers can be written to catch a specific exception such as Number Format exception, or an entire group of exceptions by using a generic exception handlers. Any exceptions not specifically handled within a Java program are caught by the Java run time environment

An exception is a subclass of the Exception/Error class, both of which are subclasses of the Throwable class. Java exceptions are raised with the throw keyword and handled within a catch block.

A Program Showing How the JVM throws an Exception at runtime

public class DivideException {

public static void main(String[] args) {

division(100,4); // Line 1

division(100,0); // Line 2

System.out.println("Exit main().");

}

public static void division(int totalSum, int totalNumber) {

System.out.println("Computing Division.");

int average = totalSum/totalNumber;

System.out.println("Average : "+ average);

}

}

An ArithmeticException is thrown at runtime when Line 11 is executed because integer division by 0 is an illegal operation. The “Exit main()” message is never reached in the main method

Output

Computing Division.

java.lang.ArithmeticException: / by zero

5. Describe the following in the context of Java threads: A) The Java Thread Model:

Java environment has been built around the multithreading model. In fact all Java class libraries have been designed keeping multithreading in mind. If a thread goes off to sleep for some time, the rest of the program does not get affected by this. Similarly, an animation loop can be fired that will not stop the working of rest of the system.

At a point of time a thread can be in any one of the following states – new, ready, running, inactive and finished. A thread enters the new state as soon as it is created. When it is started (by invoking start() method), it is ready to run. The start() method in turn calls the run() method which makes the thread enter the running state. While running, a thread might get blocked because some resource that it requires is not available, or it could be suspended on purpose for some reason (like put off to sleep by the programmer). In such a case the thread enters the state of being inactive. A thread can also be stopped purposely because its time has expired, then it enters the state of ready to run once again.

A thread that is in running state can be stopped once its job has finished. A thread that is ready to run can also be stopped. A thread that is stopped enters the finished state. A thread that is in inactive state can either be resumed, in which case it enters the ready state again, or it can be stopped in which case it enters the finished state.

B) Thread Priorities:

In multithreading environment, one thread might require the attention of the CPU more quickly than other. In such a case that thread is said to be of high priority. Priority of a thread determines the switching from one thread to another. In other words, priority determines how a thread should behave with respect to the other threads.

The word priority should not be confused with the faster running of a thread. A high priority thread does not run any faster than the low priority thread. A thread can voluntarily leave the control by explicitly stopping, sleeping or blocking on pending I/O or it can pre-empted by the system to do so. In the first case the processor examines all threads and assigns the control to the thread having the highest priority. In the second case, a low priority thread that is not ready to leave the control is simply pre-empted by the higher priority thread no matter what it is doing. This is known as pre-emptive multi-tasking. It is advisable that in case two threads have the same priority, they must explicitly surrender the control to their peers.

C) Thread Synchronization:

Multithreading produces asynchronous behavior among the programs. This means that all threads run as independent units without affecting each other. But sometimes it becomes necessary to synchronize these threads. For example, synchronization must be provided when two threads share the same variable or data structure like an array. In such a case there must be way by which they should not come in each other’s way.

6. Define RMI. Define the architecture of RMI invocation.

RMI is the distributed object system that is built into the core Java environment. You can think of RMI as a built-in facility for Java that allows you to interact with objects that are actually running in Java virtual machines on remote hosts on the network.

Architecture of RMI invocation:

Now that we've seen a complete example of an RMI object in action, let's look at what makes remote objects work, starting with an overview of the underlying RMI architecture. There are three layers that comprise the basic remote-object communication facilities in RMI:

The stub/skeleton layer, which provides the interface that client and server application objects use to interact with each other.

The remote reference layer, which is the middleware between the stub/skeleton layer and the underlying transport protocol. This layer handles the creation and management of remote object references.

The transport protocol layer, which is the binary data protocol that sends remote object requests over the wire.

These layers interact with each other as shown in Figure 3-1. In this figure, the server is the application that provides remotely accessible objects, while the client is any remote application that communicates with these server objects.

In a distributed object system, the distinctions between clients and servers can get pretty blurry at times. Consider the case where one process registers a remote-enabled object with the RMI naming service, and a number of remote processes are accessing it. We might be tempted to call the first process the server and the other processes the clients. But what if one of the clients calls a method on the remote object, passing a reference to an RMI object that's local to the client. Now the server has a reference to and is using an object exported from the client, which turns the tables somewhat. The "server" is really the server for one object and the client of another object, and the "client" is a client and a server, too. For the sake of discussion, I'll refer to a process in a distributed application as a server or client if its role in the overall system is generally limited to one or the other. In peer-to-peer systems, where there is no clear client or server, I'll refer to elements of the system in terms of application-specific roles (e.g., chat participant, chat facilitator).

As you can see in Figure 3-1, a client makes a request of a remote object using a client-side stub; the server object receives this request from a server-side object skeleton. A client initiates a remote method invocation by calling a method on a stub object. The stub maintains an internal reference to the remote object it represents and forwards the method invocation request through the remote reference layer by

marshalling the method arguments into serialized form and asking the remote reference layer to forward the method request and arguments to the appropriate remote object. Marshalling involves converting local objects into portable form so that they can be transmitted to a remote process. Each object is checked as it is marshaled, to determine whether it implements the java.rmi.Remote interface. If it does, its remote reference is used as its marshaled data. If it isn't a Remote object, the argument is serialized into bytes that are sent to the remote host and reconstituted into a copy of the local object. If the argument is neither Remote nor Serializable, the stub throws a java.rmi.MarshalException back to the client.

8. Describe the Web architecture and servlet life cycle.

A servlet life cycle can be defined as the entire process from its creation till the destruction. The following are the paths followed by a servlet

The init() method :The init method is designed to be called only once. It is called when the servlet is first created, and not called again for each user request. So, it is used for one-time initializations, just as with the init method of applets.

The servlet is normally created when a user first invokes a URL corresponding to the servlet, but you can also specify that the servlet be loaded when the server is first started.

When a user invokes a servlet, a single instance of each servlet gets created, with each user request resulting in a new thread that is handed off to doGet or doPost as appropriate. The init() method simply creates or loads some data that will be used throughout the life of the servlet.

The init method definition looks like this:

public void init() throws ServletException {}

The service() method :

The service() method is the main method to perform the actual task. The servlet container (i.e. web server) calls the service() method to handle requests coming from the client( browsers) and to write the formatted response back to the client.

Each time the server receives a request for a servlet, the server spawns a new thread and calls service. The service() method checks the HTTP request type (GET, POST, PUT, DELETE, etc.) and calls doGet, doPost, doPut, doDelete, etc. methods as appropriate.

Here is the signature of this method:

public void service(ServletRequest request,

ServletResponse response)

throws ServletException, IOException{}

The service () method is called by the container and service method invokes doGe, doPost, doPut, doDelete, etc. methods as appropriate. So you have nothing to do with service() method but you override either doGet() or doPost() depending on what type of request you receive from the client.

The doGet() and doPost() are most frequently used methods within each service request. Here are the signature of these two methods.

The doGet() Method

A GET request results from a normal request for a URL or from an HTML form that has no METHOD specified and it should be handled by doGet() method.

public void doGet(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {}

The doPost() Method

A POST request results from an HTML form that specifically lists POST as the METHOD and it should be handled by doPost() method.

public void doPost(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {}

The destroy() method :

The destroy() method is called only once at the end of the life cycle of a servlet. This method gives your servlet a chance to close database connections, halt background threads, write cookie lists or hit counts to disk, and perform other such cleanup activities.

After the destroy() method is called, the servlet object is marked for garbage collection. The destroy method definition looks like this:

public void destroy() {// Finalization code... }

Java Programming (Book ID: B0831 & B0832) Assignment Set – 2

1. Write a program to demonstrate the concept of stream classes in Java.

Consider the following simple example program that demonstrates how the read and write methods can be used :

import java.io.*;

// Displays contents of a file

//(e.g. java Type app.ini)

public class Type

{

public static void main(

String args[]) throws Exception

{

// Open input/output and setup variables

FileReader fr = new FileReader(args[0]);

PrintWriter pw = new PrintWriter(

System.out, true);

char c[] = new char[4096];

int read = 0;

// Read (and print) till end of file

while ((read = fr.read(c)) != -1)

pw.write(c, 0, read);

fr.close();

pw.close();

}

}

The following code fragment from the above program, opens the input and output streams:

FileReader fr = new FileReader(args[0]);

PrintWriter pw = new PrintWriter(System.out, true);

The program reads the input file and displays its contents until it reaches an end-of-file condition (-1), as shown here:

while ((read = fr.read(c)) != -1)

pw.write(c, 0, read);

Notice the "(char cbuf[])" version of the read method. This is used here because in most cases reading a single character at a time can be approximately five times slower than reading chunks of data (array) at a time.

2. Write the steps in creating and running applets in Java along with a sample program to demonstrate the same. Also describe various ways of running Applets.

A Java applet is an applet delivered to the users in the form of Java bytecode. Java applets can run in a Web browser using a Java Virtual Machine (JVM), or in Sun's AppletViewer, a stand-alone tool for testing applets. Java applets were introduced in the first version of the Java language in 1995. Java applets are usually written in the Java programming language but they can also be written in other languages that compile to Java bytecode such as Jython.

Java applets run at a speed that is comparable to (but generally slower than) other compiled languages such as C++, but many times faster than JavaScript. In addition they can use 3D hardware acceleration that is available from Java. This makes applets well suited for non trivial, computation intensive visualizations.

Since Java's bytecode is platform independent, Java applets can be executed by browsers for many platforms, including Microsoft Windows, Unix, Mac OS and Linux. It is also trivial to run a Java applet as an application with very little extra code. This has the advantage of running a Java applet in offline mode without the need for any Internet browser software and also directly from the development IDE.

ExampleThe following example is made simple enough to illustrate the essential use of Java applets through its java.applet package. It also uses classes from the Java Abstract Window Toolkit (AWT) for producing actual output (in this case, the "Hello, world!" message).

import java.applet.Applet;

import java.awt.*;

// Applet code for the "Hello, world!" example.

// This should be saved in a file named as "HelloWorld.java".

public class HelloWorld extends Applet {

// This method is mandatory, but can be empty (i.e., have no actual code).

public void init() { }

// This method is mandatory, but can be empty.(i.e.,have no actual code).

public void stop() { }

// Print a message on the screen (x=20, y=10).

public void paint(Graphics g) {

g.drawString("Hello, world!", 20,10);

// Draws a circle on the screen (x=40, y=30).

g.drawArc(40,30,20,20,0,360);

}

}

Additional simple applets are available at Wikiversity.[19]

For compilation, this code is saved on a plain-ASCII file with the same name as the class and .java extension, i.e. HelloWorld.java. The resulting HelloWorld.class applet should be placed on the web server and is invoked within an HTML page by using an <APPLET> or an <OBJECT> tag. For example:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<HTML>

<HEAD>

<TITLE>HelloWorld_example.html</TITLE>

</HEAD>

<BODY>

<H1>A Java applet example</H1>

<P>Here it is: <APPLET code="HelloWorld.class" WIDTH="200" HEIGHT="40">

This is where HelloWorld.class runs.</APPLET></P>

</BODY>

</HTML>

4. Describe the theory and practical applications of database connectivity in Java.

Java provides database programmers some distinct advantages, such as easy object to relational mapping, database independence and distributed computing. For languages, such as C++ and Smalltalk, there is a need for tools for mapping their objects to relational entities. Java provides an alternative to these tools that frees us from the proprietary interfaces associated with database programming. With the "write once, compile once, run anywhere" power that JDBC offers us, Java's database connectivity allows us to concentrate on the translation of relational data into objects instead of how we can get that data from the database.

A Java database application does not care what its database engine is. No matter how many times the database engine changes, the application itself need never change. In addition, a company can build a class library that maps its business objects to database entities in such a way that applications do not even know whether or not their objects are being stored in a database.

Java affects the way we distribute and maintain application. Currently a Web application allows user to download a bunch of flight information as an HTML page. While viewing the page for a particular flight, suppose someone makes a reservation for a seat on that flight and this process will not be available to the viewers as the page is just a copy of data from the database. To view the change that just occurred, the viewers again have to contact the database to get the latest data. If we reconstruct the same Web application using Java RMI to retrieve the data from a single flight object on the server, any number of users can view the data simultaneously and if there is any reservation or any change taking place, immediately the changes made to the data will be sent back to all the users and hence the users can avail the latest data at any time. Thus JDBC can combine with Java RMI to develop distributed enterprise-scale mission-critical three-tier database applications.

5. Write about the following properties of Beans with suitable code snippets:

A) Simple Properties:

A simple property of a JavaBean is an attribute of the bean that can be viewed

and can be changed by other beans. A simple property can be a read-only, a

write-only, or a read-write property, and the simple properties of a bean are

determined by the set and get methods in a bean’s class, which have the following

syntax:

public void set<Property>(data_type x)

public data_type get<Property>()

If both a set and get method appear that have the same property name and data type, the bean will have a read-write property of the specified name. If only a get method appears, the property is read-only; similarly, if only a set method appears, the property is write-only. For example, suppose that a bean has the following methods: public void setTitle(String t)

public String getTitle()

Then, the bean has a read-write property named title, and the data type of this property is a String. When the data type is a Boolean, an is method can be used in place of a get method. For example, the following two method signatures create a Boolean property named atHome:

public void setAtHome(boolean b)

public boolean isAtHome()

The name of a property is determined by the method signatures for the property. The set or get portion of the method name is removed, and the next letter is decapitalized.

B) Bound Properties:

Bound properties support the PropertyChangeListener (in the API reference documentation) class. Sometimes when a Bean property changes, another object might need to be notified of the change, and react to the change. Whenever a bound property changes, notification of the change is sent to interested listeners. The accessor methods for a bound property are defined in the same way as those for simple properties. However, you also need to provide the event listener registration methods forPropertyChangeListener classes and fire a PropertyChangeEvent (in the API reference documentation) event to the PropertyChangeListener objects by calling their propertyChange methods

The convenience PropertyChangeSupport (in the API reference documentation) class enables your bean to implement these methods. Your bean can inherit changes from the PropertyChangeSupportclass, or use it as an inner class.

In order to listen for property changes, an object must be able to add and remove itself from the listener list on the bean containing the bound property. It must also be able to respond to the event notification method that signals a property change.

The PropertyChangeEvent class encapsulates property change information, and is sent from the property change event source to each object in the property change listener list with the propertyChange method.

C) Constrained Properties:

A bean property is constrained if the bean supports the VetoableChangeListener(in the API reference documentation) and PropertyChangeEvent(in the API reference documentation) classes, and if the set method for this property throws a PropertyVetoException(in the API reference documentation).

Constrained properties are more complicated than bound properties because they also support property change listeners which happen to be vetoers.

The following operations in the setXXX method for the constrained property must be implemented in this order:

Save the old value in case the change is vetoed. Notify listeners of the new proposed value, allowing them to veto the change. If no listener vetoes the change (no exception is thrown), set the property to the new value. The accessor methods for a constrained property are defined in the same way as those for simple properties, with the addition that the setXXX method throws a PropertyVetoException exception. The syntax is as follows:

public void setPropertyName(PropertyType pt)

throws PropertyVetoException {code}

6. Describe the process of creating a table and updating its contents using JDBC.

Creating Tables and updating:

There is currently no possibility to create tables using the SQL Server interface you have used for queries.

In general, you can create (and delete) tables and insert/update/delete table content using JDBC - there is a link below - and check the effect using the SQL Server query interface. By selecting all information from a table (execute "SELECT * FROM T" in the 'pubs' database using the query tool - if T is the table you have just created or updated) you can see whether your commands were successful: if the table

hasn't been created then the system is going to tell you that the object doesn't exist; if it exists you will see its content (might be empty immediately after creation).

You can create tables in the database using JDBC:

stmt.executeUpdate("CREATE TABLE BOOKS " +

"(ISBN VARCHAR(15), AUTHOR VARCHAR(20), TITLE VARCHAR(20), PRICE DECIMAL(3.2), " +

" PRIMARY KEY(ISBN) )");

and you can insert data into this table:

stmt.executeUpdate("INSERT INTO BOOKS " +

" VALUES ('1-234-567', 'Gosling', 'Java', 25.99)");

The suggested attribute type DECIMAL might not be available in all DBMS. If there is a problem, use FLOAT instead.

7. Explain the importance of CORBA and its applications in running client server programs.

CORBA is an open standard rather than a proprietary technology. This is important for a variety of reasons.

First, users can choose an implementation from a variety of CORBA vendors (or choose one of the freeware implementations). You might think that switching from one CORBA product to another would involve a lot of work. However, the amount of work involved is likely to be much less than you might think, particularly if you follow the practical advice in Chapter 25 about how to increase the portability of CORBA-based applications. In contrast, if you use a proprietary middleware system then switching to another proprietary middleware vendor is much more challenging.

Second, the competition between different CORBA vendors helps to keep software prices down.

Finally, many proprietary middleware technologies are designed with the assumption that developers will build all their applications using that particular middleware technology, and so they provide only limited support for integration with other technologies. In contrast, CORBA was designed with the goal of making it easy to integrate with other technologies. Indeed, the CORBA specification explicitly tackles integrations with TMN, SOAP, Microsoft’s (D)COM and DCE (a middleware standard that was popular before CORBA). Furthermore, many parts of J2EE borrow heavily from concepts in CORBA, which makes it relatively easy to integrate J2EE and CORBA. Some vendors sell gateways between CORBA and J2EE that make such integration even easier. Several CORBA vendors sell COM-to-CORBA and/or .NET-to-CORBA gateways. This provides a very pragmatic solution to organizations that wish to write GUI applications in, say, Visual Basic on Windows that act as clients to server applications on a different type of computer, such as UNIX or a mainframe. The Visual Basic GUI can be written as a COM/.NET client

that thinks it is talking to a COM/.NET server, but in fact communicates with a gateway that forwards on requests to a CORBA server.

The on-the-wire protocol infrastructure of CORBA ensures that messages between clients and servers are transmitted in a compact representation. Also, most CORBA implementations marshal data (that is, convert data from programming-language types into a binary buffer that can be transmitted) efficiently. Many other middleware technologies also use a similarly compact format for transmitting data and have efficient marshaling infrastructure. However, there are some notable exceptions, as I now discuss.

SOAP uses XML to represent data that is to be transmitted. The verbosity of XML results in SOAP using much more network bandwidth than CORBA.1 SOAP-based applications also incur considerable CPU overhead involved in formatting programming-language types into XML format and later parsing the XML to extract the embedded programming-languages types.

Some other middleware technologies, such as IBM MQ Series, transmit only binary data, which is efficient. However, this requires that developers write the marshaling code that copies programming-language types into the binary buffers prior to transmission, and the unmarshaling code to extract the programming-language types from a binary buffer. In contrast, a CORBA IDL compiler generates the marshaling and unmarshaling code, so that developers do not need to write (and maintain) such low-level code.

8. Explain the importance, applications and working of Ajax.

IMPORTANCE:

They can use a standard web browser, such as Firefox, Internet Explorer or Safari, as their only user interface.

They don't force the user to wait for the web server every time the user clicks a button. This is what "asynchronous" means. For instance, gmail fetches new email messages in the background ("asynchronously") without forcing the user to wait. This makes an AJAX application respond much more like a "real" application on the user's computer, such as Microsoft Outlook.

The Ajax engine works within the Web browser (through JavaScript and the DOM) to render the Web application and handle any requests that the customer might have of the Web server. The beauty of it is that because the Ajax engine is handling the requests, it can hold most information in the engine itself, while allowing the interaction with the application and the customer to happen as asynchronously and independently of any interaction with the server.

They use standard JavaScript features (including the unofficial XMLHTTPRequest standard, pioneered by Microsoft and adopted by Firefox and other browsers) to fetch data in the background and display different email messages or other data "on the fly" when the user clicks on appropriate parts of the interface.

Usually they manipulate data in XML format. This allows AJAX applications to interact easily with server-side code written in a variety of languages, such as PHP, Perl/CGI, Python and ASP.NET. Using XML isn't absolutely necessary, and in fact many "AJAX" applications don't -- they use the XMLHTTPRequest object to send and receive data "on the fly," but they don't actually bother packaging that data as XML.

Working of Ajax:

Ajax adds a layer to web application communication models. As previously stated, in traditional web applications communication between the browser/client and the web server occurred directly between these two components using HTTP requests. When users/clients request web pages, the server sends all the HTML and CSS code at once. If the user enters information into this page and requests more servers, the entire page must be loaded again. When using Ajax, the page is only loaded once. Any processing or modification caused by additional user input occurs in real time

In addition to HTML and CSS code, Ajax also downloads JavaScript files. These three components make up the Ajax engine. So all requests for data from the server will be sent as JavaScript calls to this engine, which is located as a communication layer between the browser and the server. The Ajax engine or layer processes subsequent requests that may change the appearance or function of the web page. By requesting information from the server asynchronously, Ajax sends page bits to request services from the server as needed.

The engine allows these bits or responses to be displayed without reloading the entire page. This makes web pages and web applications much more responsive since only the necessary information is communicated between clients and servers instead of the entire page. This process imitates the responsiveness of desktop applications. Similarly, Ajax conducts all HTTP requests in the background, preventing user disruption. Users can continue working while the page sections are requested and delivered. With Ajax, the user interface is much more closely connected to application logic.