MCS-024

Re: MCS-024 - Object Oriented Technologies And Java Programming - MCA(2)/024/Assign/09 2/16/2010 1:22:07 PM

Posted On:

Question 2 : a) Explain why Java is platform independent. Also explain advantage of platform independence.

a) When Java Code is compiled a byte code is generated which is independent of the system. This byte code is fed to the JVM (Java Virtual Machine) which is resided in the system. Since every system has its own JVM, it doesn't matter where you compile the source code. The byte code generated by the compiler can be interpreted by any JVM of any machine. Hence it is called Platform independent Language.

Java's bytecodes are desgined to be read and interpreted in exactly same manner on any computer hardware or operating system that supports Java Runtime Environment.

Advantages: One of the key reasons Java technology is useful in a networked environment is that Java makes it possible to create binary executables that will run unchanged on multiple platforms. This is important in a networked environment because networks usually interconnect many different kinds of computers and devices. In a typical enterprise environment, for example, a network might connect Macintoshes in the art department, UNIX workstations in engineering, and PCs running Windows everywhere else. Although this arrangement enables various kinds of computers and devices within the company to share data, it requires a great deal of administration. Such a network presents a system administrator with the task of keeping different platform-specific editions of programs up to date on many different kinds of computers. Programs that can run without change on any networked computer, regardless of the computer's type, make the system administrator's job simpler, especially if those programs can actually be delivered across the network.

In addition, the emerging proliferation of network-enabled embedded devices represents another environment in which Java's platform independence is useful. In the workplace, for example, various kinds of embedded devices, such as printers, scanners, and fax machines, are typically connected to the internal network.

Network-connected embedded devices have also appeared in consumer domains, such as the home and car. In the embedded world, Java's platform independence can also help simplify system administration. Jini technology, which aims to bring plug and play to the network, simplifies the task of administering a dynamic environment of network-connected embedded devices for both consumers at home and systems administrators at work. Once a device is plugged into the network, it can access other devices attached to the network, and other devices can access it.

To achieve this ease of connectivity, Jini-enabled devices exchange objects across the network, a technique that would be impossible without Java's support for platform independence. From the developer's perspective, Java can reduce the cost and time required to develop and deploy applications on multiple platforms. Even though historically, many (or most) applications have been supported on only one platform, often the reason was that the cost involved in supporting multiple platforms wasn't worth the added return. Java can help make multi-platform support affordable for more types of programs.

On the other hand, Java's platform independence can act as a disadvantage as well as an advantage for software developers. If you are developing and selling a software product, Java's support for platform independence can help you to compete in more markets. Instead of developing a product that runs only on Windows, for example, you can write one that runs on Windows, OS/2, Solaris, and Linux. With Java, you can have more potential customers. The trouble is, so can everyone else. Imagine, for example, that you have focused your efforts on writing great software for Solaris. Java makes it easier for others to write software that competes in your chosen market niche. With Java, therefore, you may not only end up with more potential customers, but also with more potential competitors. But perhaps most significantly for developers, the fact that Java code can run unchanged on multiple platforms gives the network a homogeneous execution environment that enables new kinds of distributed systems built around networkmobile objects. APIs such as object serialization, RMI (Remote Method Invocation), and Jini take advantage of this underlying capability to bring objectoriented programming out of the virtual machine and onto the network. (More information on Jini is given in Chapter 4, Network Mobility.)

b) What are different relational operators in Java? Write a Java program to explain the use of relational operators.

The Equality and Relational Operators The equality and relational operators determine if one operand is greater than, less than, equal to, or not equal to another operand. The majority of these operators will probably look familiar to you as well. Keep in mind that you must use "==", not "=", when testing if two primitive values are equal. == equal to != not equal to > greater than >= greater than or equal to < less than 70)&&(stud150)&&(stud1 checked exceptions checked exceptions are also known as compile time exceptions as they are identified during compile time of the program. Exception and all the subclasses of Exception class are checked exceptions

2> Unchecked exceptions Unchecked Exceptions are also known as runtime exceptions as they are identified during the runtime of the program. class RuntimeException and all the subclasses of RuntimeException are unchecked Exceptions Exception subclass constructor Creates an exception subclass. Syntax

public exception_subclass(CWConnectorExceptionObject excption) where exception_subclass is the name of the exception subclass (as shown in Table 142). Parameters excption is an exception object that contains information about the exception. Return values An object that represents a subclass of the CWException class.

b) Differentiate between String and String Buffer classes. Also write a program to append a given string.

b) String and StringBuilder class stores strings. But when you cannot change a String object after creating one. eg: String name = "Prasad";

By saying you cannot change the name object means you cannot change the value in name object internally. When you change the name object value to something else, a new String object is creating in memory and assign the new value. eg: name = "Prasad Reddy";

A new name object is creating in memory and the value "Prasad Reddy" is assinging to the newly created space. But StringBuilder class occupies the same space even if you change the value. If you are doing string concatenation StringBuilder class is far better in performance than String class.

You can use StringBuilder's Append() method to use concatenation. Java provides the StringBuffer and String classes, and the String class is used to manipulate character strings that cannot be changed. Simply stated, objects of type String are read only and immutable. The StringBuffer class is used to represent characters that can be modified. The significant performance difference between these two classes is that StringBuffer is faster than String when performing simple concatenations. In String manipulation code, character strings are routinely concatenated. Using the String class, concatenations are typically performed as follows:

String str = new String ("Stanford "); str += "Lost!!"; If you were to use StringBuffer to perform the same concatenation, you would need code that looks like this:

StringBuffer str = new StringBuffer ("Stanford "); str.append("Lost!!");

Murty BVS

Re: MCS-024 - Object Oriented Technologies And Java Programming - MCA(2)/024/Assign/09 2/16/2010 3:30:17 PM

Posted On:

Question 6 : a) What is multithreading ? Explain how synchronization is achieved in a multithreaded program in Java.

Answer a) :

Multithreaded programs are similar to the single-threaded programs that you have been studying. They differ only in the fact that they support more than one concurrent thread of execution-that is, they are able to simultaneously execute multiple sequences of instructions. Each instruction sequence has its own unique flow of control that is independent of all others. These independently executed instruction sequences are known as threads.

If your computer has only a single CPU, you might be wondering how it can execute more than one thread at the same time. In single-processor systems, only a single thread of execution occurs at a given instant. The CPU quickly switches back and forth between several threads to create the illusion that the threads are executing at the same time. Single-processor systems support logical concurrency, not physical concurrency. Logical concurrency is the characteristic exhibited when multiple threads execute with separate, independent flows of control. On multiprocessor systems, several threads do, in fact, execute at the same time, and physical concurrency is achieved. The important feature of multithreaded programs is that they support logical concurrency, not whether physical concurrency is actually achieved.

Many programming languages support multiprogramming. Multiprogramming is the logically concurrent execution of multiple programs. For example, a program can request that the operating system execute programs A, B, and C by having it spawn a separate process for each program. These programs can run in parallel, depending upon the multiprogramming features supported by the underlying operating system. Multithreading differs from multiprogramming in that multithreading provides concurrency within the context of a single process and multiprogramming provides concurrency between processes. Threads are not complete processes in and of themselves. They are a separate flow of control that occurs within a process.

An executing program is generally associated with a single process. The advantage of multithreading is that concurrency can be used within a process to provide multiple simultaneous services to the user. Multithreading also requires less processing overhead than multiprogramming because concurrent threads are able to share common resources more easily. Multiple executing programs tend to duplicate resources and share data as the result of more time-consuming interprocess communication.

How Java Supports Multithreading Java's multithreading support is centered around the java.lang.Thread class. The Thread class provides the capability to create objects of class Thread, each with its own separate flow of control. The Thread class encapsulates the data and methods associated with separate threads of execution and allows multithreading to be integrated within the object-oriented framework. Java provides two approaches to creating threads. In the first approach, you create a subclass of class Thread and override the run() method to provide an entry point into the thread's execution. When you create an instance of your Thread subclass, you invoke its start() method to cause the thread to execute as an independent sequence of instructions. The start() method is inherited from the Thread class. It initializes the Thread object using your operating system's multithreading capabilities and invokes the run() method. You learn how to create threads using this approach in the next section. The approach to creating threads identified in the previous paragraph is very simple and straightforward. However, it has the drawback of requiring your Thread objects to be under the Thread class in the class hierarchy. In some cases, as you'll see when you study applets in Part VI, "Programming the Web with Applets and Scripts," this requirement can be somewhat limiting. Java's other approach to creating threads does not limit the location of your Thread objects within the class hierarchy. In this approach, your class implements the java.lang.Runnable interface. The Runnable interface consists of a single method, the run() method, which must be overridden by your class. The run() method provides an entry point into your thread's execution. In order to run an object of your class as an independent thread, you pass it as an argument to a constructor of class Thread. You learn how to create threads using this approach later in this chapter in the section titled "Implementing Runnable." Creating Subclasses of Thread In this section, you create your first multithreaded program by creating a subclass of Thread and then creating, initializing, and starting two Thread objects from your class. The threads will execute concurrently and display Java is hot, aromatic, and invigorating. to the console window.

The source code of the ThreadTest1 program.

class ThreadTest1

{ public static void main(String args[]) { MyThread thread1 = new MyThread("thread1: "); MyThread thread2 = new MyThread("thread2: "); thread1.start(); thread2.start(); boolean thread1IsAlive = true; boolean thread2IsAlive = true; do { if ( thread1IsAlive && !thread1.isAlive() ) { thread1IsAlive = false; System.out.println("Thread 1 is dead."); } if (thread2IsAlive && !thread2.isAlive()) { thread2IsAlive = false; System.out.println("Thread 2 is dead."); } } while(thread1IsAlive || thread2IsAlive); }} class MyThread extends Thread { static String message[] = { "Java", "is", "hot,", "aromatic,", "and", "invigorating."}; public MyThread(String id) { super(id); } public void run()

{ String name = getName(); for ( int i=0 ; i < message.length ; ++i ) { randomWait(); System.out.println(name + message[i]); }} void randomWait() { try { sleep((long)(3000*Math.random())); } catch (InterruptedException x) { System.out.println("Interrupted!"); }}}

This program creates two threads of execution, thread1 and thread2, from the MyThread class. It then starts both threads and executes a do statement that waits for the threads to die. The threads display the Java is hot, aromatic, and invigorating. message word by word, while waiting a short, random amount of time between each word. Because both threads share the console window, the program's output identifies which threads were able to write to the console at various times during the program's execution.

Run ThreadTest1 to get an idea of the output that it produces. Each time you run the program you might get a different program display. This is because the program uses a random number generator to determine how long each thread should wait before displaying its output. Look at the following output:

C:\java\jdg\ch08>java ThreadTest1 thread1: Java thread2: Java thread2: is thread2: hot, thread2: aromatic, thread1: is

thread1: hot, thread2: and thread1: aromatic, thread1: and thread2: invigorating. Thread 2 is dead. thread1: invigorating. Thread 1 is dead.

This output shows that thread1 executed first and displayed Java to the console window. It then waited to execute while thread2 displayed Java, is, hot,, and aromatic,. After that, thread2 waited while thread1 continued its execution. thread1 displayed is and then hot,. At this point, thread2 took over again. thread2 displayed and and then went back into waiting. thread1 then displayed aromatic, and and. thread2 finished its execution by displaying invigorating.. Having completed its execution, thread2 died, leaving thread1 as the only executing task. thread1 displayed invigorating. and then completed its execution.

The ThreadTest1 class consists of a single main() method. This method begins by creating thread1 and thread2 as new objects of class MyThread. It then starts both threads using the start() method. At this point, main() enters a do loop that continues until both thread1 and thread2 are no longer alive. The loop monitors the execution of the two threads and displays a message when it has detected the death of each thread. It uses the isAlive() method of the Thread class to tell when a thread has died. The thread1IsAlive and thread2IsAlive variables are used to ensure that a thread's obituary is only displayed once.

The MyThread class extends class Thread. It declares a statically initialized array, named message[], that contains the message to be displayed by each thread. It has a single constructor that invokes the Thread class constructor via super(). It contains two access methods: run() and randomWait(). The run() method is required. It uses the getName() method of class Thread to get the name of the currently executing thread. It then prints each word of the output display message while waiting a random length of time between each print.

The randomWait() method invokes the sleep() method within a try statement. The sleep() method is another method inherited from class Thread. It causes the currently executing task to "go to sleep" or wait until a randomly specified number of milliseconds has transpired. Because the sleep() method throws the InterruptedException when its sleep is interrupted (how grouchy!), the exception is caught and handled by the randomWait() method.

The exception is handled by displaying the fact that an interruption has occurred to the console window. It is not possible for one thread to modify a shared variable while another thread is in the process of using or updating same shared variable. This usually leads to significant errors. Synchronization in respect to multithreading controls the access of multiple threads to shared resources.

b) Explain how files are handled in Java ? Write a program in Java to create a file and copy the content of an already existing file into it.

Answer b) : One of the first things a programmer learns with a new language is how to read and write to files, since the saving and loading of data will be an important feature of most software he or she will eventually develop using that language.

Java offers extensive - yet easy to use - file handling classes that make it a breeze to read and write files. In this tutorial, we'll start by covering the basics of file input and output, as well as covering some associated topics, such as trapping exceptions and I/O errors.

File output Our first example will be a program that writes a string to a file. In order to use the Java file classes, we must import the Java input/output package (java.io) in the following manner

import java.io.*;

Inside the main method of our program, we must declare a FileOutputStream object. For those familiar with C, a FileOutputStream is analogous to a file handle. When we send a stream (or sequence) of data to the FileOutputStream handle, data will be written to disk.

In Java, there exists a large number of extensions to the standard input and output stream classes. This is handy, as the basic input and output streams deal only with the transfer of bytes - not the easiest way for us to write out data. There's a wide variety of streams to choose from : if we were writing data such as bytes, integers, floats, or other "data" orientated types, we might choose the DataOutputStream, whereas for text we'd use the PrintStream class.

In this case, we wish to write a string to the file, and so we create a new PrintStream object that takes as its constructor the existing FileOutputStream. Any data we send from PrintStream will now be passed to the FileOutputStream, and ultimately to disk. We then make a call to the println method, passing it a string, and then close the connection.

/* * * FileOutputDemo * * Demonstration of FileOutputStream and * PrintStream classes * */ import java.io.*; class FileOutputDemo { public static void main(String args[]) { FileOutputStream out; // declare a file output object PrintStream p; // declare a print stream object try { // Create a new file output stream // connected to "myfile.txt" out = new FileOutputStream("myfile.txt"); // Connect print stream to the output stream p = new PrintStream( out ); p.println ("This is written to a file"); p.close(); } catch (Exception e) { System.err.println ("Error writing to file"); }}}

Listing 1.0 - FileOutputDemo.java After running the output example, and seeing that it wrote to our file, let's take a more detailed look at the code. You may be wondering what the purpose of the try { .. } catch block is. Rather than checking for erroneous return values (such as a null pointer when obtaining an output stream as is the case with C's fopen), we catch exceptions.

Exceptions are events that occur in exceptional or unusual circumstances, such as error conditions. A method can throw an exception, to indicate to the calling object that a non-standard circumstance has occurred. Thus, instead of checking each and every file method call, we have one piece of code handling all possible errors! File input File input under Java differs little from file output. We must import the Java IO package, and we create a file input stream inside of a try { .. } catch block as in the previous example. In this example, the file we open is given to us as the first command line parameter. We obtain this by examining the args array of strings. Since an array is an actual object in Java, we can find the length of the array (and hence the number of parameters) through the length attribute.

To do anything useful with file input, we create a DataInputStream which can handle reading in data as well as lines of text. To determine if there is any data left to read, we call the available() method of our input stream. This method returns the number of bytes remaining, which we check to see is not equal to zero. Then we call the DataInputStream's readLine() method and print the result to the screen.

/* * * FileInputDemo * Demonstrates FileInputStream and * DataInputStream */ import java.io.*; class FileInputDemo { public static void main(String args[]) { // args.length is equivalent to argc in C

if (args.length == 1) { try { // Open the file that is the first // command line parameter FileInputStream fstream = new FileInputStream(args[0]); // Convert our input stream to a // DataInputStream DataInputStream in = new DataInputStream(fstream); // Continue to read lines while // there are still some left to read while (in.available() !=0) { // Print file line to screen System.out.println (in.readLine()); } in.close(); } catch (Exception e) { System.err.println("File input error"); }} else System.out.println("Invalid parameters"); } }

Listing 1.1 - FileInputDemo.java import java.io.BufferedReader; import java.io.FileReader; public class File1{ public static void main(String[] args) { try{ BufferedReader ds=new BufferedReader(new FileReader("c://a.txt")); String str=ds.readLine(); System.out.println("File contains : "+str); }catch(Exception e) { System.out.println(e); } } } Output :File contains : Hi from baluja abc import java.io.BufferedWriter; import java.io.FileWriter; public class File2{ public static void main(String[] args) { try{ BufferedWriter bw=new BufferedWriter(new FileWriter("c://b.txt")); bw.write("Auspicious Day abc "); bw.close(); }catch(Exception e) { System.out.println(e); }

} } Output :b.txt:: Auspicious Day

Kulpreet Singh

Re: MCS-024 - Object Oriented Technologies And Java Programming - MCA(2)/024/Assign/09 2/16/2010 3:31:40 PM

Posted On:

Question 7: a) What is Layout Manager? Explain different layout available in Java.

Answer a) :

Layouts tell Java where to put components in containers (JPanel, content pane, etc). Every panel (and other container) has a default layout, but it's better to set the layout explicitly for clarity. Create a new layout object (using one of its constructors) and use the container's setLayout method to set the layout. Each layout has its own way to resize components to fit the layout, and you must become familiar with these.

• FlowLayout - left to right, top to bottom. Good for initial testing. FlowLayout does not respect preferred size information, so it may make variable size elements (eg, a graphics panel) extremely small.

• BorderLayout - north, east, south, west, and center areas. Has various rules for how components are stretched to fit these areas. Both common and useful.

• GridLayout - equal sized grid elements.

• BoxLayout and Boxes - horizontal or vertical sequence of components.

• GridBagLayout - unequal sized grid. Can produce excellent results, but can be difficult to use.

• SpringLayout was added in Java 1.4, but is difficult for humans. It is rumored to be intended for authomatic layout programs.

• CardLayout is good for something like a wizard interface which shows one of several possible layouts (think about a stack of index cards)

• Tabbed panes are something like a card layout with tabs.

• The Null layout (absolute positioning) is possible, but is a bad idea.

• Tabbed panes are something like a card layout with tabs. They are not implemented as a layout, but as a type of panel.

• Non-standard layout managers. Because of deficiencies in the standard Java layout managers, several good, free, alternatives exist.

b) What is socket? Explain basic networking features of Java.

Answer b) :

Normally, a server runs on a specific computer and has a socket that is bound to a specific port number. The server just waits, listening to the socket for a client to make a connection request.

On the client-side: The client knows the hostname of the machine on which the server is running and the port number on which the server is listening. To make a connection request, the client tries to rendezvous with the

server on the server's machine and port. The client also needs to identify itself to the server so it binds to a local port number that it will use during this connection. This is usually assigned by the system.

If everything goes well, the server accepts the connection. Upon acceptance, the server gets a new socket bound to the same local port and also has its remote endpoint set to the address and port of the client. It needs a new socket so that it can continue to listen to the original socket for connection requests while tending to the needs of the connected client. On the client side, if the connection is accepted, a socket is successfully created and the client can use the socket to communicate with the server. The client and server can now communicate by writing to or reading from their sockets.

Definition: A socket is one endpoint of a two-way communication link between two programs running on the network. A socket is bound to a port number so that the TCP layer can identify the application that data is destined to be sent.

Java Network Features: Intro Most people assume that Java is a vehicle written for web browsers, i.e. to 'spice up' web pages. While we know by know that that is not true at all, what is true that Java is a language written with the Internet in mind. Therefore, Java has a lot of network support built in, and you can make use of it in a variety of ways. We will start our 'network explorations' by looking at the classes in the java.applet package, in particular at the

java.applet.AppletContext class: public abstract Applet getApplet(String name); public abstract Enumeration getApplets(); public abstract AudioClip getAudioClip(URL url); public abstract Image getImage(URL url); public abstract void showDocument(URL url); public abstract void showDocument(URL url, String target); public abstract void showStatus(String status);

An AppletContext, usually, provides a hook to the current web browser used. Therefore, using this class we should be able to load images, audio clips, display messages in the status bar of our web browser, and display other web documents in

the web browser. Here, for example is a little applet that displays a message in the browser's status bar. Of course, if you are not using a web browser (but, say, the appletviewer) to look at this applet, nothing may happen (but also no error will occur).

import java.applet.*; import java.awt.*; public class NetExample extends Applet { private AppletContext browser = null; private Button showStatus = new Button("Show Status"); public void init() { Panel panel = new Panel(); panel.setLayout(new GridLayout(1,2)); panel.add(showStatus); setLayout(new BorderLayout()); add("South", panel); browser = getAppletContext(); } public boolean action(Event e, Object o) { if (e.target == showStatus) browser.showStatus("Here is something for your status line ..."); return true; }}

IPv6 (Internet Protocol version 6) J2SETM 1.4 supports IPv6 in TCP and UDP-based applications, including multicast, and will support most end-user applications in use today. See the IPv6 User Guide.

HTTP Digest Authentication The HTTP digest authentication implementation has been updated to support proxies as well as origin servers, and has also been updated to provide all capabilities defined in RFC2617, except for the auth-int mode. A number of system properties have been added which modify the behavior of the digest authentication mechanism. These are identified in the Networking Properties document. Unconnected/Unbound Socket Support Allows more flexible socket creation, binding, and connection. Enables manipulation of socket options before establishing or accepting connections. In addition a timeout can be specified when establishing a connection. New class javax.net.ssl.SSLSocket is a subclass of java.net.Socket that provides security through encryption. The mechanism is called the Java Secure Socket Extension (JSSE), and it provides encryption for data sent via sockets. See the JSSE Reference Guide for further information. Connected UDP Socket Support The DatagramSocket.connect method now establishes the address association at native level. Where supported, this allows an application to have visibility of ICMP port unreachable messages as an indication that the remote application is unavailable.

Uniform Resource Indentifier (URI) Class java.net.URI is new in J2SE 1.4. It allows URI construction and parsing without the presence of a protocol handler, which is not possible with the URL class. The URI class is compliant with RFC 2396 and RFC 2732. FTP Protocol Handler Significant overhaul to make the functionality conform as much as possible to the current standards (RFC 1738 & 959). This enhancement fixes several bugs associated with FTP functionality. For example, passive mode for FTP works in J2SE 1.4. JNDI DNS SP Support in InetAddress This enhancement in class java.net.InetAddress enables applications to configure a pure Java name service provider by using a DNS name service provider through JNDI. See JNDI DNS service provider settings in the Network

Properties document for information on enabling this support. URLEncoder and URLDecoder Improvements Methods URLEncoder.encode(String s, String enc) and URLDecoder.decode(String s, String enc) have been added to enable applications to use other character encoding/decoding schemes.

TCP Out-of-Band Data Two new methods in class java.net.Socket, sendUrgentData() and getOOBInline(), provide limited support for TCP urgent data for support certain legacy applications. Urgent data may be sent on any TCP socket. However, only partial support for receiving urgent data is provided. SOCKS Full V5 (RFC 1928) & V4 TCP support with autonegociation with the proxy of which version to use. See the SOCKS protocol support settings in the Network Properties document for information about using properties to specify the SOCKS proxy server.

NetworkInterface Class java.net.NetworkInterface is new in J2SE 1.4. It allows enumeration of interfaces and addresses. This new class should be useful to applications deployed on multihomed and machines with multiple network interfaces

Reshma biju

Re: MCS-024 - Object Oriented Technologies And Java Programming - MCA(2)/024/Assign/09 2/16/2010 3:32:54 PM

Posted On:

Question 8 : a) Explain how databases are connected to a Java program.

Answer : a) Java Database Connectivity (JDBC) is a programming framework for Java developers writing programs that access information stored in databases, spreadsheets, and flat files. JDBC is commonly used to connect a user program to a "behind the scenes" database, regardless of what database management software is used to control the database. In this way, JDBC is cross-platform [ 1]. This article will provide an introduction and sample code that demonstrates database access from Java programs that use the classes of the JDBC API, which is available for free download from Sun's site [ 3].

A database that another program links to is called a data source. Many data sources, including products produced by Microsoft and Oracle, already use a standard called Open Database Connectivity (ODBC). Many legacy C and Perl programs use ODBC to connect to data sources. ODBC consolidated much of the commonality between database management systems. JDBC builds on this feature, and increases the level of abstraction. JDBC-ODBC bridges have been created to allow Java programs to connect to ODBC-enabled database software [ 1].

This article assumes that readers already have a data source established and are moderately familiar with the Structured Query Language (SQL), the command language for adding records, retrieving records, and other basic database manipulations. See Hoffman's tutorial on SQL if you are a beginner or need some refreshing [ 2]. Using a JDBC driver Regardless of data source location, platform, or driver (Oracle, microsoft, etc.), JDBC makes connecting to a data source less difficult by providing a collection of classes that abstract details of the database interaction. Software engineering with JDBC is also conducive to module reuse. Programs can easily be ported to a different infrastructure for which you have data stored (whatever platform you choose to use in the future) with only a driver substitution.

As long as you stick with the more popular database platforms (Oracle, Informix, Microsoft, MySQL, etc.), there is almost certainly a JDBC driver written to let your programs connect and manipulate data. You can download a specific JDBC driver from the manufacturer of your database management system (DBMS) or from a third party (in the case of less popular open source products) [ 5]. The JDBC driver for your database will come with specific instructions to make the class files of the driver available to the Java Virtual Machine, which your program is going to run. JDBC drivers use Java's built-in DriverManager to open and access a database from within your Java program. To begin connecting to a data source, you first need to instantiate an object of your JDBC driver. This essentially requires only one line of code, a command to the DriverManager, telling the Java Virtual Machine to load the bytecode of your driver into memory, where its methods will be available to your program. The String parameter below is the fully qualified class name of the driver you are using for your platform combination:

Class.forName("org.gjt.mm.mysql.Driver").newInstance(); Connecting to your database To actually manipulate your database, you need to get an object of the Connection class from your driver. At the very least, your driver will need a URL for the database and parameters for access control, which usually involves standard password authentication for a database account. As you may already be aware, the Uniform Resource Locator (URL) standard is good for much more than telling your browser where to find a web page: http://www.vusports.com/index.html The URL for our example driver and database looks like this: jdbc:mysql://db_server:3306/contacts/ Even though these two URLs look different, they are actually the same in form: the protocol for connection, machine host name and optional port number, and the relative path of the resource. Your JDBC driver will come with instructions detailing how to form the URL for your database. It will look similar to our example. You will want to control access to your data, unless security is not an issue. The standard least common denominator for authentication to a database is a pair of strings, an account and a password. The account name and password you give the driver should have meaning within your DBMS, where permissions should have been established to govern access privileges.

b) Explain difference between applets and application programs.

Answer b) :

Applets as previously described, are the small programs while applications are larger programs. Applets don't have the main method while in an application execution starts with the main method. Applets can run in our browser's window or in an appletviewer. To run the applet in an appletviewer will be an advantage for debugging. Applets are designed for the client site programming purpose while the applications don't have such type of criteria. Applet are the powerful tools because it covers half of the java language picture. Java applets are the best way of creating the programs in java. There are a less number of java programmers that have the hands on experience on java applications. This is not the deficiency of java applications but the global utilization of internet.

It doesn't mean that the java applications don't have the place. Both (Applets and the java applications) have the same importance at their own places. Applications are also the platform independent as well as byte oriented just like the applets.

Applets are designed just for handling the client site problems. while the java applications are designed to work with the client as well as server. Applications are designed to exists in a secure area. while the applets are typically used. Applications and applets have much of the similarity such as both have most of the same features and share the same resources. Applets are created by extending the java.applet.Applet class while the java applications start execution from the main method. Applications are not too small to embed into a html page so that the user can view the application in your browser. On the other hand applet have the accessibility criteria of the resources. The key feature is that while they have so many differences but both can perform the same purpose. Review of Java Applets: You have previously learned about the java applets. To create an applet just create a class that extends the java.applet.Applet class and inherit all the features available in the parent class. The following programs make all the things clear.

import java.awt.*; import java.applet.*; class Myclass extends Applet { public void init() {

/* All the variables, methods and images initialize here will be called only once because this method is called only once when the applet is first initializes */

} public void start() {

/* The components needed to be initialize more than once in your applet are written here or if the reader switches back and forth in the applets. This method can be called more than once.*/

} public void stop() {

/* This method is the counterpart to start(). The code, used to stop the

execution is written here*/

} public void destroy() {

/* This method contains the code that result in to release the resources to the applet before it is finished. This method is called only once. */

} public void paint(Graphics g) {

/* Write the code in this method to draw, write, or color things on the applet pane are */

}}

In the above applet you have seen that there are five methods. In which two ( init() and destroy ) are called only once while remaining three (start() , stop() , and paint() ) can be called any number of times as per the requirements. The major difference between the two (applet and application) is that java applications are designed to work under the homogenous and more secure areas.

On contrary to that, java applets are designed to run the heterogeneous and probably unsecured environment. Internet has imposed several restrictions on it. Applets are not capable of reading and writing the user's file system. This means that the applet neither can access nor place anything locally. To illustrate this lets take an example.. Many Window based C applications uses the .INF file as the initialization file to store the information about the application and any user preferences in 16-bit Windows or the Registry in 32-bit Windows. While in case of current applet it is not possible. One more thing to point here is that applets are unable to use the native methods, run any program on the user system or load shared libraries. The major security concern here is that the local shared libraries and the native methods may results in the loophole in the java security model. Applets are not capable of communicating the server than one from which they are originating. There are the cases in which an encryption key is used for the verification purpose for a particular applet to a server. But accessing a remote server is not possible. The conclusion is that the java applets provides a wide variety of formats for program execution and a very tight security model on the open environment as

on the Internet. Introduction to Java Application : Java applications have the majority of differences with the java applets. If we talk at the source code level, then we don't extend any class of the standard java library that means we are not restricted to use the already defined method or to override them for the execution of the program. Instead we make set of classes that contains the various parts of the program and attach the main method with these classes for the execution of the code written in these classes. The following program illustrate the structure of the java application.

public class MyClass { /* Various methods and variable used by the class MyClass are written here */ class myClass { /* This contains the body of the class myClass */ } public static void main(String args[]) { /* The application starts it's actual execution from this place. **/ }}

The main method here is nothing but the system method used to invoke the application. The code that results an action should locate in the main method. Therefore this method is more than the other method in any java application. If we don't specify the main method in our application, then on running the application will through an exception like this one: In the class MyClass: void main(String args[]) is undefined But at higher level major concern is that in a typical java application security model, an application can access the user's file system and can use native methods. On properly configuring the user's environment and the java application it will allow access to all kind of stuff from the Internet.

In most of the cases it is seen that the java application seems like a typical C/C++ application. Now we are going to create plenty of applications to exemplify some of the methods and features of a specific Java application. All of them are console based Java applications because here we are not going to cover the AWT.

Java Applications : An Example Lets create an application that executes at the command prompt. Lets create a new file named

ClassA.java. public class ClassA{ //write the variables for Class String Name;

int AccNumber; float Bal; //This method display the information on the screen. void display(){ System.out.println("Name: " + Name); System.out.println("Account Number: " + AccNumber); System.out.println("Balance: " + Bal); } public static void main(String args[]) { //Create an instance of ClassA ClassA a = new ClassA(); //Assigning values to the variables in class ClassA a.Name = "Vinod"; a.AccNumber = 467256282; a.Bal =635; //Draw the top border for (int i = 0; i < 20; i++) System.out.print("--"); //Title System.out.println(" PARTICULARS"); //Call method to display the information a.display(); //Draw bottom border for (int i = 0; i < 20; i++) System.out.print("--"); //Ending remark System.out.println("End of display"); } }

If the file ClassA.java and the javac.exe are in the same directory then compile the program just by giving the following command.

c) Explain the use of finalize() methods of Java with an example.

Answer c) : Since objects are dynamically allocated by using the new operator, you might be wondering how such objects are destroyed and their memory released for later deallocation. In some languages, such as C++, dynamically allocated objects must be manually released by use of a delete operator.

Java takes a different approach; it handles deallocation for you automatically. The technique that accomplishes this is called garbage collection. It works like this: when no references to an object to an object exist, that object is assumed to be no longer needed, and the memory occupied by the object can be reclaimed. There is no explicit need to destroy objects as in C++. Garbage collection only occurs sporadically (if at all) during the execution of your program. It will not occur simply because one or more objects exist that are no longer used. Furthermore, different java run-time implementations will take varying approaches to garbage collection, but for the most part, you should not have to think about it while writing your programs The finalize () Method Sometimes an object will need to perform some action when it is destroyed. For example, if an object is holding some non-java resource such as a file handle or window character font, then you might want to make sure these resources are freed before an object is destroyed. To handle such situations, java provides a mechanism called finalization. By using finalization, you can define specific actions that will occur when an object is just about to be reclaimed by the garbage collector. To add a finalizer to a class, you simply define the finalize() method. The java run time calls that method whenever it is about to recycle an object of that class. Inside the finalize() method you will specify those actions that must be performed before an object is destroyed. The garbage collector runs periodically, checking for objects that are no longer referenced by any running state or indirectly through other referenced objects. Right before an asset is freed, the java run time calls the finalize() method on the object. The finalize() method has this general form:

protected void finalize() { // finalization code here }

Here, the keyword protected is a specifier that prevents access to finalize() by

code defined outside its class.

d) Write a program in Java to show the use of checkbox and choice list components.

Answer d) : Example :- 2 Checkbox demo

package buttons; import java.applet.*; import java.awt.event.*; import java.awt.*; /* < applet code="buttons.CheckBoxDemo" width="500" height="500" > * < /applet > */ public class CheckBoxDemo extends Applet implements ItemListener { String msg=""; Checkbox win98,winNt,solaris,mac; public void init() { win98=new Checkbox("windows 98/xp",null,true); winNt=new Checkbox("windowsNt/2000"); solaris=new Checkbox("solaris"); mac=new Checkbox("macos"); add(win98); add(winNt); add(solaris); add(mac); win98.addItemListener(this); winNt.addItemListener(this);

solaris.addItemListener(this); mac.addItemListener(this); } public void itemStateChanged(ItemEvent e) { repaint(); } public void paint(Graphics g) { msg="current state :"; g.drawString(msg, 6, 80); msg="windows 98/xp :"+win98.getState(); g.drawString(msg, 6, 100); msg="windows Nt/2000 :"+winNt.getState(); g.drawString(msg, 6, 120); msg="solaris :"+solaris.getState(); g.drawString(msg, 6, 140); msg="macos :"+mac.getState(); g.drawString(msg, 6, 160); } } :- Choice demo

package buttons; import java.applet.*; import java.awt.event.*; import java.awt.*; public class ChoiceDemo extends Applet implements ItemListener { Choice os,browser; String msg="";

public void init() { os=new Choice(); browser=new Choice(); os.add("window 98/xp"); os.add("window Nt/2000"); os.add("solaris"); os.add("macos"); browser.add("netscape3.x"); browser.add("netscape4.x"); browser.add("netscape5.x"); browser.add("netscape6.x"); browser.add("internet explorer 4.0"); browser.add("internet explorer 5.0"); browser.add("internet explorer 6.0"); browser.add("lynx 2.4"); browser.select("netscape4.x"); add(os); add(browser); os.addItemListener(this); browser.addItemListener(this); } public void itemStateChanged(ItemEvent e) { repaint(); } public void paint(Graphics g) { msg="current os : "; msg+=os.getSelectedItem();

g.drawString(msg, 6, 120); msg="current browser : "; msg+=browser.getSelectedItem(); g.drawString(msg, 6, 140); } }

e) Explain the use of GET and POST methods in servlet programming.

Answer e) : sending simple GET requests from Java is extremely easy (be it an application or a servlet), but sending multipart forms, like when you upload files, is painful. The former can be done in one method call that does all the underground work. The latter requires explicitly creating an HTTP request, which may include generating multipart boundaries while being careful with the exact amount and selection of newlines (e.g., println() would not always do the right job).

This article provides a simple solution that will relieve the pain of sending form data (like POST requests) from Java in most real-world scenarios. The intention is to make POST requests as simple as GET requests, even when sending multiple files of varying type (archives, XML, HTML, plain text, etc.).

GET and POST Requests The two main methods for sending form data to a Web server are GET and POST. This section demonstrates how each method works in three scenarios. (Do not try to reproduce these at home. The URLs and e-mail addresses are fake.) Example 1. GET Request The following form uses the GET method:

< form method="get" action="hi.iq/register.jsp" > Name: < input type="text" name="name" value="J.Doe" > email: < input type="text" name="email" [Email address not allowed in post] > < input type="submit" > < /form > Example 2. POST Request

Now, let's replace 'GET' with 'POST' in the form HTML tag:

< form method="post" action="hi.iq/register.jsp" > Name: < input type="text" name="name" value="J.Doe" > email: < input type="text" name="email" [Email address not allowed in post] > < input type="submit" > < /form >

Kulpreet Singh

MCS-024 - Object Oriented Technologies and Java Programming - Question 1(a) 5:23:34 PM

Posted On: 2/23/2010

Object-oriented programming (OOP''') is a programming paradigm that uses "objects" and their interactions to design applications and computer programs.

Object Oriented vs Structured Programming

Structured programming can be seen as a subset or sub discipline of procedural programming, one of the major programming paradigms. It is most famous for removing or reducing reliance on the GOTO statement [1]. The rise of the Object Oriented concept brought us debugging comfort as well as expandability as the programs were getting larger and larger and it became difficult to debug. There were functions to reduce the size of the programs and improve

readability but it was never enough. Object-oriented programming (OOP) is a programming language model organized around “objects” rather than “actions” and data rather than logic. Historically, a program has been viewed as a logical procedure that takes input data, processes it, and produces output data. The programming challenge was seen as how to write the logic, not how to define the data. Object-oriented programming takes the view that what we really care about are the objects we want to manipulate rather than the logic required to manipulate them [2]. Object Oriented Programming has many benefits over Structured programming. Some of them are reusability, extensibility, reliability and maintainability. OOP also helps to reduce large problems to smaller, more manageable problems. In terms of extensibility and reusability, for instance: “Encapsulation allows the internal implementation of a class to be modified without requiring changes to its services (i.e. methods). It also allows new classes to be added to a system, without major modifications to the system. Inheritance allows the class hierarchy to be further refined, and combined with polymorphism, the superclass does not have to “know” about the new class, i.e. modifications do not have to be made at the superclass” [3].

Another important discussion would be; do we really need classes? Can we not just use functions instead? Considerable amount of people think that functions are faster and require less code. On the other hand, someone would argue that classes are more modular. I do not have any strict opinion on this subject. But, I think it really depends on what you would like to achieve. For instance, I cannot think of any reason why you would want to use classes to perform a very simple task such as checking if the user fills out the name – surname field on the form. “One of the frequently claimed benefits of the OOP is that it is natural (therefore more understandable), and is assumed to be cognitively similar to the way human beings perceive and understand the real-world (Meyer, (1988); Rosson & Alpert

(1988); Rosson & Alpert(1990). Martin & Odell (1992, p.31) for example, states “The way of thinking is more natural for most people than the techniques of structured analysis and design. After all, the world consists of objects.” Mcfadden & Hoffer(1994, p.) similarly note “The notation and approach of the object oriented data model builds on these paradigms that people constantly use to cope with complexity.” This claim, therefore assumes that it is more natural for developers to decompose a problem into objects, at least as compared to the traditional structured languages. In other words, it should be natural for developers and users to map the problem into objects and into classification hierarchies.”

Kulpreet Singh

MCS-024 - Object Oriented Technologies and Java Programming - Question 8(a) 5:23:34 PM

Question 8 :(a) Explain how databases are connected to a Java program. Java Database Connectivity (JDBC) is a programming framework for Java developers writing programs that access information stored in databases, spreadsheets, and flat files. JDBC is commonly used to connect a user program to a "behind the scenes" database, regardless of what database management software is used to control the database. In this way, JDBC is cross-platform [ 1]. This article will provide an introduction and sample code that demonstrates database access from Java programs that use the classes of the JDBC API, which is available for free download from Sun's site [ 3].

Posted On: 2/23/2010

A database that another program links to is called a data source. Many data sources, including products produced by Microsoft and Oracle, already use a standard called Open Database Connectivity (ODBC). Many legacy C and Perl programs use ODBC to connect to data sources. ODBC consolidated much of the commonality between database management systems. JDBC builds on this feature, and increases the level of abstraction. JDBC-ODBC bridges have been created to allow Java programs to connect to ODBC-enabled database software [ 1]. This article assumes that readers already have a data source established and are moderately familiar with the Structured Query Language (SQL), the command language for adding records, retrieving records, and other basic database manipulations. See Hoffman's tutorial on SQL if you are a beginner or need some refreshing [ 2]. Using a JDBC driver Regardless of data source location, platform, or driver (Oracle, Microsoft, etc.), JDBC makes connecting to a data source less difficult by providing a collection of classes that abstract details of the database interaction. Software engineering with JDBC is also conducive to module reuse. Programs can easily be ported to a different infrastructure for which you have data stored (whatever platform you choose to use in the future) with only a driver substitution. As long as you stick with the more popular database platforms (Oracle, Informix, Microsoft, MySQL, etc.), there is almost certainly a JDBC driver written to let your programs connect and manipulate data. You can download a specific JDBC driver from the manufacturer of your database management system (DBMS) or from a third party (in the case of less popular open source products) [ 5]. The JDBC driver for your database will come with specific instructions to make the class files of the driver available to the Java Virtual Machine, which your program is going to run. JDBC drivers use Java's built-in DriverManager to open and access a database from within your Java program. To begin connecting to a data source, you first need to instantiate an object of your

JDBC driver. This essentially requires only one line of code, a command to the DriverManager, telling the Java Virtual Machine to load the bytecode of your driver into memory, where its methods will be available to your program. The String parameter below is the fully qualified class name of the driver you are using for your platform combination: Class.forName("org.gjt.mm.mysql.Driver").newInstance(); Connecting to your database To actually manipulate your database, you need to get an object of the Connection class from your driver. At the very least, your driver will need a URL for the database and parameters for access control, which usually involves standard password authentication for a database account. As you may already be aware, the Uniform Resource Locator (URL) standard is good for much more than telling your browser where to find a web page:

http://www.vusports.com/index.html The URL for our example driver and database looks like this: jdbc:mysql://db_server:3306/contacts/ Even though these two URLs look different, they are actually the same in form: the protocol for connection, machine host name and optional port number, and the relative path of the resource. Your JDBC driver will come with instructions detailing how to form the URL for your database. It will look similar to our example. You will want to control access to your data, unless security is not an issue. The standard least common denominator for authentication to a database is a pair of strings, an account and a password. The account name and password you give the driver should have meaning within your DBMS, where permissions should have been established to govern access privileges.

Kulpreet Singh

MCS-024 - Object Oriented Technologies and Java Programming - Question 8(c) 5:23:34 PM

c) Explain the use of finalize() methods of Java with an example. answer: Since objects are dynamically allocated by using the new operator, you might be wondering how such objects are destroyed and their memory released for later reallocation. In some languages, such as C++, dynamically allocated objects must be manually released by use of a delete operator. Java takes a different approach; it handles deallocation for you automatically. The technique that accomplishes this is called garbage collection. It works like this: when no references to an object to an object exist, that object is assumed to be no longer needed, and the memory occupied by the object can be reclaimed. There is no explicit need to destroy objects as in C++. Garbage collection only occurs sporadically (if at all) during the execution of your program. It will not occur simply because one or more objects exist that are no longer used. Furthermore, different java run-time implementations will take varying approaches to garbage collection, but for the most part, you should not have to think about it while writing your programs The finalize () Method Sometimes an object will need to perform some action when it is destroyed. For example, if an object is holding some non-java resource such as a file handle or window character font, then you might want to make sure these

Posted On: 2/23/2010

resources are freed before an object is destroyed. To handle such situations, java provides a mechanism called finalization. By using finalization, you can define specific actions that will occur when an object is just about to be reclaimed by the garbage collector. To add a finalizer to a class, you simply define the finalize() method. The java run time calls that method whenever it is about to recycle an object of that class. Inside the finalize() method you will specify those actions that must be performed before an object is destroyed. The garbage collector runs periodically, checking for objects that are no longer referenced by any running state or indirectly through other referenced objects. Right before an asset is freed, the java run time calls the finalize() method on the object. The finalize() method has this general form: protected void finalize() { // finalization code here } Here, the keyword protected is a specifier that prevents access to finalize() by code defined outside its class.