1

MC0078-Spring Drive Assignment 2-2012

1.With the help of a simple program demonstrate the compilation and execution of Java Programs. ANS: A program is a set of instructions. In order to execute a program, the operating system needs to understand the language. The only language an operating system understands is in terms of 0s and 1s i.e. the binary language. Programs written in language such as C and C++ are converted to binary code during the compilation process. However, that binary code can be understood only by the operating system for which the program is compiled. This makes the program or application operating system dependent. In Java, the program is compiled into bytecode (.class file) that run on the Java Virtual Machine, which can interpret and run the program on any operating system. This makes Java programs platformindependent. At the command prompt, type javac <filename>.java When the code is compiled and error-free, the program can be executed using the command: java <filename>

Chadhary satish satish2114@yahoo.in

2 2.write a complete program for each of the following: A.decision making statements B.looping statements ANS: A.decision making statements There are two types of decision making statements in Java. They are: 1.if statements 2.switch statements 1.The if Statement: An if statement consists of a Boolean expression followed by one or more statements. Syntax: The syntax of an if statement is: if(Boolean_expression) { //Statements will execute if the Boolean expression is true } If the boolean expression evaluates to true then the block of code inside the if statement will be executed. If not the first set of code after the end of the if statement(after the closing curly brace) will be executed.

Example: public class Test { public static void main(String args[]){ int x = 10; if( x < 20 ){ System.out.print("This is if statement"); } } } This would produce following result: This is if statement The if...else Statement: An if statement can be followed by an optional else statement, which executes when the Boolean expression is false. Syntax:

Chadhary satish satish2114@yahoo.in

3 The syntax of a if...else is: if(Boolean_expression){ //Executes when the Boolean expression is true }else{ //Executes when the Boolean expression is false } Example: public class Test { public static void main(String args[]){ int x = 30; if( x < 20 ){ System.out.print("This is if statement"); }else{ System.out.print("This is else statement"); } } } This would produce following result: 2.The switch Statement: A switch statement allows a variable to be tested for equality against a list of values. Each value is called a case, and the variable being switched on is checked for each case. Syntax: The syntax of enhanced for loop is: switch(expression){ case value : //Statements break; //optional case value : //Statements break; //optional //You can have any number of case statements. default : //Optional //Statements } The following rules apply to a switch statement: The variable used in a switch statement can only be a byte, short, int, or char.

Chadhary satish satish2114@yahoo.in

4 You can have any number of case statements within a switch. Each case is followed by the value to be compared to and a colon. The value for a case must be the same data type as the variable in the switch, and it must be a constant or a literal. When the variable being switched on is equal to a case, the statements following that case will execute until a break statement is reached. When a break statement is reached, the switch terminates, and the flow of control jumps to the next line following the switch statement. Not every case needs to contain a break. If no break appears, the flow of control will fall through to subsequent cases until a break is reached. A switch statement can have an optional default case, which must appear at the end of the switch. The default case can be used for performing a task when none of the cases is true. No break is needed in the default case. Example: public class Test { public static void main(String args[]){ char grade = args[0].charAt(0); switch(grade) { case 'A' : System.out.println("Excellent!"); break;

case 'B' : case 'C' : System.out.println("Well done"); break; case 'D' : System.out.println("You passed"); case 'F' : System.out.println("Better try again"); break; default : System.out.println("Invalid grade"); Chadhary satish satish2114@yahoo.in

5 } System.out.println("Your grade is " + grade); } } Compile and run above program using various command line arguments. This would produce following result: $ java Test a Invalid grade Your grade is a a $ java Test A Excellent! Your grade is a A $ java Test C Well done Your grade is a C $ B.looping statements There may be a situation when we need to execute a block of code several number of times, and is often referred to as a loop. Java has very flexible three looping mechanisms. You can use one of the following three loops: 1.while Loop 2.do...while Loop 3.for Loop As of java 5 the enhanced for loop was introduced. This is mainly used for Arrays. 1.The while Loop: A while loop is a control structure that allows you to repeat a task a certain number of times. Syntax: The syntax of a while loop is: while(Boolean_expression) { //Statements } When executing, if the boolean_expression result is true then the actions inside the loop will be executed. This will continue as long as the expression result is true. Here key point of the while loop is that the loop might not ever run. When the expression is tested and the result is false, the loop body will be skipped and the first statement after the while loop will be Chadhary satish satish2114@yahoo.in

6 executed. Example: public class Test { public static void main(String args[]){ int x= 10; while( x < 20 ){ System.out.print("value of x : " + x ); x++; System.out.print("\n"); } } } 2.do...while Loop: A do...while loop is similar to a while loop, except that a do...while loop is guaranteed to execute at least one time. Syntax: The syntax of a do...while loop is: do { //Statements }while(Boolean_expression); Notice that the Boolean expression appears at the end of the loop, so the statements in the loop execute once before the Boolean is tested. If the Boolean expression is true, the flow of control jumps back up to do, and the statements in the loop execute again. This process repeats until the Boolean expression is false. 3. The for Loop: A for loop is a repetition control structure that allows you to efficiently write a loop that needs to execute a specific number of times. A for loop is useful when you know how many times a task is to be repeated. Syntax: The syntax of a for loop is:

for(initialization; Boolean_expression; update) { Chadhary satish satish2114@yahoo.in

7 //Statements } Here is the flow of control in a for loop: 1. The initialization step is executed first, and only once. This step allows you to declare and initialize any loop control variables. You are not required to put a statement here, as long as a semicolon appears. 2. Next, the Boolean expression is evaluated. If it is true, the body of the loop is executed. If it is false, the body of the loop does not execute and flow of control jumps to the next statement past the for loop. 3. After the body of the for loop executes, the flow of control jumps back up to the update statement. This statement allows you to update any loop control variables. This statement can be left blank, as long as a semicolon appears after the Boolean expression. 4. The Boolean expression is now evaluated again. If it is true, the loop executes and the process repeats itself (body of loop, then update step,then Boolean expression). After the Boolean expression is false, the for loop terminates.

Chadhary satish satish2114@yahoo.in

8 3. Write a program to demonstrate the concept of various possible exceptions arising in a Java Program and the ways to handle them. ANS: Common Exceptions Java has several predefined exceptions. The most common exceptions that you may encounter are described below. Arithmetic Exception This exception is thrown when an exceptional arithmetic condition has occurred. For example, a division by zero generates such an exception. NullPointer Exception This exception is thrown when an application attempts to use null where an object is required. An object that has not been allocated memory holds a null value. The situations in which an exception is thrown include: - Using an object without allocating memory for it. - Calling the methods of a null object. - Accessing or modifying the attributes of a null object. ArrayIndexOutOfBounds Exception The exception ArrayIndexOutOfBounds Exception is thrown when an attempt is made to access an array element beyond the index of the array. For example, if you try to access the eleventh element of an array thats has only ten elements, the exception will be thrown. Exception Handling Techniques When an unexpected error occurs in a method, Java creates an object of the appropriate exception class. After creating the exception objects, Java passes it to the program, by an action called throwing an exception. The exception object contains information about the type of error and the state of the

program when the exception occurred. You need to handle the exception using exception-handler and process the exception. You can implement exception-handling in your program by using following keywords: try catch finally The try Block You need to guard the statements that may throw an exception in the try block. The following skeletal code illustrates the use of the try block try { // statement that may cause an exception }

Chadhary satish satish2114@yahoo.in

9 The try block governs the statements that are enclosed within it and defines the scope of the exception handlers associated with it. In other words, if an exception occurs within try block, the appropriate exception-handler that is associated with the try block handles the exception. A try block must have at least one catch block that follow it immediately. Nested try Statements The try statement can be nested. That is, a try statement can be inside the block of another try. Each time a try statement is entered, the context of that exception is pushed on the stack. If an inner try statement does not have a catch handler for a particular exception, the stack is unwound and the next try statements catch handlers are inspected for a match. This continues until one of the catch statements succeeds, or until all of the nested try statements are exhausted. If no catch statement matches, then the Java run-time system will handle the exception. Here is an example that uses nested try statements: // An example of nested try statements. class NestTry { public static void main(String args[ ]) { try { int a = args.length; /* If no command-line args are present, the following statement will generate a divide-by-zero exception. */ int b = 42 / a; System.out.println("a = " + a); try { // nested try block /* If one command-line arg is used, then a divide-by-zero exception will be generated by the following code. */ if(a==1) a = a/(a-a); // division by zero /* If two command-line args are used,

then generate an out-of-bounds exception. */ if(a==2) { int c[ ] = { 1 }; c[42] = 99; // generate an out-of-bounds exception } } catch(ArrayIndexOutOfBoundsException e) { } } catch(ArithmeticException e) { System.out.println("Divide by 0: " + e); } } }

Chadhary satish satish2114@yahoo.in

10 As you can see, this program nests one try block within another. The program works as follows. When you execute the program with no command-line arguments, a divide-by zero exception is generated by the outer try block. Execution of the program by one command-line argument generates a divide-byzero exception from within the nested try block. Since the inner block does not catch this exception, it is passed on to the outer try block, where it is handled. If you execute the program with two commandline arguments, an array boundary exception is generated from within the inner try block. Here are sample runs that illustrate each case: C:\>java NestTry Divide by 0: java.lang.ArithmeticException: / by zero C:\>java NestTry One a=1 Divide by 0: java.lang.ArithmeticException: / by zero C:\>java NestTry One Two a=2 Array index out-of-bounds: java.lang.ArrayIndexOutOfBoundsException: 42 Nesting of try statements can occur in less obvious ways when method calls are involved. For example, you can enclose a call to a method within a try block. Inside that method is another try statement. In this case, the try within the method is still nested inside the outer try block, which calls the method. Here is the previous program recoded so that the nested try block is moved inside the method nesttry( ): /* Try statements can be implicitly nested via calls to methods. */ class MethNestTry { static void nesttry(int a) { try { // nested try block /* If one command-line arg is used, then a divide-by-zero exception will be generated by the following code. */ if(a==1) a = a/(a-a); // division by zero /* If two command-line args are used, then generate an out-of-bounds exception. */ if(a==2) { int c[ ] = { 1 }; c[42] = 99; // generate an out-of-bounds exception } } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index out-of-bounds: " + e); } } public static void main(String args[ ]) { Chadhary satish satish2114@yahoo.in

11 try { int a = args.length; /* If no command-line args are present, the following statement will generate a divide-by-zero exception. */ int b = 42 / a; System.out.println("a = " + a); nesttry(a); } catch(ArithmeticException e) { System.out.println("Divide by 0: " + e); } } } The output of this program is identical to that of the preceding example. The catch Block You associate an exception-handler with the try block by providing one or more catch handlers immediately after try block. The following skeletal code illustrates the use of the catch block. try { //statements that may cause an exception } catch () { // error handling code } The catch statement takes an object of an exception class as a parameter. If an exception is thrown, the statements in the catch block are executed. The scope of the catch block is restricted to the statements in the preceding try block only. The finally Block When an exception is raised, the rest of the statements in the try block are ignored. Sometimes, it is necessary to process certain statements irrespective of whether an exception is raised or not. The finally block is used for this purpose.

try { openFile(); writeFile(); //may cause an exception } Chadhary satish satish2114@yahoo.in

12 catch () { //process the exception } In the above example, the file has to be closed irrespective of whether an exception is raised or not. You can place the code to close the file in both the try and catch blocks. To avoid duplication of code, you can place the code in the finally block. The code in the finally block is executed regardless of whether an exception is thrown or not. The finally block follows the catch blocks. You have only one finally block for an exception-handler. However, it is not mandatory to have a finally block. finally { closeFile (); }

Chadhary satish satish2114@yahoo.in

13 4. Write a program to show the various ways of creating and running threads in Java. ANS: Creating a Thread In the most general sense, you create a thread by instantiating an object of type Thread. Java defines two ways in which this can be accomplished: You can implement the Runnable interface. You can extend the Thread class, itself. The following two sections look at each method, in turn. Implementing Runnable The easiest way to create a thread is to create a class that implements the Runnable interface. Runnable abstracts a unit of executable code. You can construct a thread on any object that implements Runnable. To implement Runnable, a class need only implement a single method called run( ), which is declared like this: public void run( ) Inside run( ), you will define the code that constitutes the new thread. It is important to understand that run( ) can call other methods, use other classes, and declare variables, just like the main thread can. The only difference is that run( ) establishes the entry point for another, concurrent thread of execution within your program. This thread will end when run( ) returns. After you create a class that implements Runnable, you will instantiate an object of type Thread from within that class. Thread defines several constructors. The one that we willuse is shown here: Thread(Runnable threadOb, String threadName) In this constructor, threadOb is an instance of a class that implements the Runnable interface. This defines where execution of the thread will begin. The name of the new thread is specified by

threadName. After the new thread is created, it will not start running until you call its start( ) method, which is declared within Thread. In essence, start( ) executes a call to run( ). The start() method is shown here: void start( ) Here is an example that creates a new thread and starts it running: Inside NewThreads constructor, a new Thread object is created by the following statement: t = new Thread(this, "Demo Thread"); Passing this as the first argument indicates that you want the new thread to call the run() method on this object. Next, start( ) is called, which starts the thread of execution beginning at the run( ) method. This causes the child threads for loop to begin. After calling start( ), NewThreads constructor returns to main( ). When the main thread resumes, it enters its for loop. Both threads continue running, sharing the CPU, until their loops finish. The output produced by this program is as follows: Chadhary satish satish2114@yahoo.in

14 Child thread: Thread[Demo Thread,5,main] Main Thread: 5 Child Thread: 5 Child Thread: 4 Main Thread: 4 Child Thread: 3 Child Thread: 2 Main Thread: 3 Child Thread: 1 Exiting child thread. Main Thread: 2 Main Thread: 1 Main thread exiting. As mentioned earlier, in a multithreaded program, the main thread must be the last thread to finish running. If the main thread finishes before a child thread has completed, then the Java run-time system may "hang." The preceding program ensures that the main thread finishes last, because the main thread sleeps for 1,000 milliseconds between iterations, but the child thread sleeps for only 500 milliseconds. This causes the child thread to terminate earlier than the main thread. Shortly, you will see a better way to ensure that the main thread finishes last. 5. Write a simple program in Java to display a string message using Servlets. List out the steps involved in Compiling and Running Servlets. ANS: Servlet Life Cycle Now that you have seen the basic structure of a servlet, lets review the process by which a server invokes a servlet. This process can be broken down into the nine steps as follows: 1. The server loads the servlet when it is first requested by the client or if configured to do so, at server start-up. The servlet may be loaded from either a local or a remote location using the standard Java class loading facility. This step is equivalent to the following code:

Class c=Class.forName(com.sourcestream.MyServlet); It should be noted that when referring to servlets, the term load often refers to the process of both loading and instantiating the servlet. 2. The server creates one or more instances of the servlet class. Depending on implementation. The server may create a single instance that services all requests through multiple threads or create a pool of instances from which one chosen to service each new request. This step is equivalent to the following

Chadhary satish satish2114@yahoo.in

15

Java code: Servlet s=(Servlet) c.newInstance (); where c is the same Class object created in previous step. 3. The server constructs a ServerConfig object that provides initialization information to the servlet. 4. The server calls the servlets init () method, passing the object constructed in step 3 as a parameter. The init () method is guaranteed to finish execution prior to the servlet processing the first request. If the server has created multiple servlet instances (step 2), the init () method is called one time for each instance. 5. The server constructs a ServletRequest or HttpServletRequest object from the data included in the clients request. It also con

Chadhary satish satish2114@yahoo.in

16 6. Write a program in Java to demonstrate the complete life cycle of a Servlet. ANS: Servlet Life Cycle Now that you have seen the basic structure of a servlet, lets review the process by which a server invokes a servlet. This process can be broken down into the nine steps as follows: 1. The server loads the servlet when it is first requested by the client or if configured to do so, at server start-up. The servlet may be loaded from either a local or a remote location using the standard Java class loading facility. This step is equivalent to the following code: Class c=Class.forName(com.sourcestream.MyServlet); It should be noted that when referring to servlets, the term load often refers to the process of both loading and instantiating the servlet. 2. The server creates one or more instances of the servlet class. Depending on implementation. The server may create a single instance that services all requests through multiple threads or create a pool

of instances from which one chosen to service each new request. This step is equivalent to the following Java code: Servlet s=(Servlet) c.newInstance (); where c is the same Class object created in previous step. 3. The server constructs a ServerConfig object that provides initialization information to the servlet. 4. The server calls the servlets init () method, passing the object constructed in step 3 as a parameter. The init () method is guaranteed to finish execution prior to the servlet processing the first request. If the server has created multiple servlet instances (step 2), the init () method is called one time for each instance. 5. The server constructs a ServletRequest or HttpServletRequest object from the data included in the clients request. It also constructs a ServletResponse or HttpServletResponse object that provides methods for customizing the servers response. The type of object passed in these two parameters depends on whether the servlet extends the GenericServlet class or the HttpServlet class, respectively. 6. The server calls the servlets service() method passing the objects constructed in step 5 as parameters. When concurrent requests arrive, multiple service() methods can run in separate threads. 7. The service () method processes the client request by evaluating the ServletRequest or HttpServletRequest object and responds using ServletResponse or HttpServletResponse object. 8. If the server receives another request for this servlet, the process begins again at step 5. 9. When instructed to unload the servlet, perhaps by the server administrator or programmatically by Chadhary satish satish2114@yahoo.in

17 the servlet itself, the server calls the servlets destroy() method. The servlet is then eligible for garbage collection. The above mentioned nine steps illustrate the entire lifecycle of a servlet. The following figure shows the flow of the servlet lifecycle. structs a ServletResponse or HttpServletResponse object that provides methods for customizing the servers response. The type of object passed in these two parameters depends on whether the servlet extends the GenericServlet class or the HttpServlet class, respectively. 6. The server calls the servlets service() method passing the objects constructed in step 5 as parameters. When concurrent requests arrive, multiple service() methods can run in separate threads. 7. The service () method processes the client request by evaluating the ServletRequest or HttpServletRequest object and responds using ServletResponse or HttpServletResponse object. 8. If the server receives another request for this servlet, the process begins again at step 5. 9. When instructed to unload the servlet, perhaps by the server administrator or programmatically by the servlet itself, the server calls the servlets destroy() method. The servlet is then eligible for garbage collection. The above mentioned nine steps illustrate the entire lifecycle of a servlet. The following figure shows the flow of the servlet lifecycle.

Chadhary satish satish2114@yahoo.in

18 A Simple Servlet To become familiar with the key servlet concepts, we will begin by building and testing a simple servlet. The basic steps are the following: 1. Create and compile the servlet source code. 2. Start the servletrunner utility. 3. Start a Web browser and request the servlet. The following sections examine each of these steps in detail. Create and Compile the Servlet Source Code To begin, create a file named HelloServlet.java that contains the following program: import java.io.*; import javax.servlet.*;

public class HelloServlet extends GenericServlet { public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter pw = response.getWriter(); pw.println("<B>Hello!"); pw.close(); } } First, note that this program imports the javax.servlet package, which contains the classes and interfaces required to build servlets. You will learn more about these classes and interfaces later in this chapter. Next, the program defines HelloServlet as a subclass of GenericServlet. The GenericServlet class provides functionality that makes it easy to handle requests and responses. Inside HelloServlet, the service( ) method (which is inherited from GenericServlet) is overridden. This method handles requests from a client. Notice that the first argument is a ServletRequest object. This enables a servlet to read data that is provided via the client request. The second argument is an ServletResponse object. This enables a servlet to formulate a response for the client. The call to setContentType( ) establishes the MIME type of the HTTP response. In this program, the MIME type is text/html, which indicates that the browser should interpret the content as HTML source code. Next, the getWriter( ) method obtains a PrintWriter. Anything written to this stream is sent to the client as part of the HTTP response. Then, println( ) is used to write some simple HTML source code as the HTTP response. Compile this source code and place the HelloServlet.class file in the directory named c:\\Jsdk2.0\\examples. This ensures that it can be located by the servletrunner utility. Chadhary satish satish2114@yahoo.in

19 Start the servletrunner Utility Open a command prompt window and type servletrunner to start that utility. This tool listens on port 8080 for incoming client requests. Start a Web Browser and Request the Servlet Start a Web browser and enter the URL shown here: http://localhost:8080/servlet/HelloServlet Alternatively, you may enter the URL shown here: http://127.0.0.1:8080/servlet/HelloServlet This can be done because 127.0.0.1 is defined as the IP address of the local machine. You should observe the output of the servlet in the browser display area. It should contain the string Hello! in bold type. Note The examples in this chapter assume that the servletrunner and the Web browser execute on the same machine. However, these two applications can be installed on different machines. In that case, the URLs must be changed to identify the machine on which servletrunner is executing.

Chadhary satish satish2114@yahoo.in