Java Documentation

Java supports three types of comments. The first two are the // and the /* */. The third type is called a documentation comment. It begins with the character sequence /** and it ends with */.

Documentation comments allow you to embed information about your program into the program itself. You can then use the javadoc utility program to extract the information and put it into an HTML file.

Documentation comments make it convenient to document your programs.

The javadoc Tags:

The javadoc utility recognizes the following tags:

Tag     Description  Example

@author       Identifies the author of a class.  @author description

@deprecated          Specifies that a class or member is deprecated.        @deprecated description

{@docRoot} Specifies the path to the root directory of the current documentation Directory Path

@exception Identifies an exception thrown by a method.            @exception exception-name explanation

{@inheritDoc}         Inherits a comment from the immediate superclass.          Inherits a comment from the immediate surperclass.

{@link}          Inserts an in-line link to another topic.            {@link name text}

{@linkplain} Inserts an in-line link to another topic, but the link is displayed in a plain-text font.            Inserts an in-line link to another topic.

@param       Documents a method's parameter.      @param parameter-name explanation

@return        Documents a method's return value.   @return explanation

@see  Specifies a link to another topic.            @see anchor

@serial          Documents a default serializable field.            @serial description

@serialData Documents the data written by the writeObject( ) or writeExternal( ) methods            @serialData description

@serialField Documents an ObjectStreamField component.        @serialField name type description

@since          States the release when a specific change was introduced.          @since release

@throws      Same as @exception.        The @throws tag has the same meaning as the @exception tag.

{@value}       Displays the value of a constant, which must be a static field.      Displays the value of a constant, which must be a static field.

@version      Specifies the version of a class.  @version info

Documentation Comment:

After the beginning /**, the first line or lines become the main description of your class, variable, or method.

After that, you can include one or more of the various @ tags. Each @ tag must start at the beginning of a new line or follow an asterisk (*) that is at the start of a line.

Multiple tags of the same type should be grouped together. For example, if you have three @see tags, put them one after the other.

Here is an example of a documentation comment for a class:

/**

* This class draws a bar chart.

* @author Zara Ali

* @version 1.2

*/

What javadoc Outputs?

The javadoc program takes as input your Java program's source file and outputs several HTML files that contain the program's documentation.

Information about each class will be in its own HTML file. Java utility javadoc will also output an index and a hierarchy tree. Other HTML files can be generated.

Since different implementations of javadoc may work differently, you will need to check the instructions that accompany your Java development system for details specific to your version.

Example:

Following is a sample program that uses documentation comments. Notice the way each comment immediately precedes the item that it describes.

After being processed by javadoc, the documentation about the SquareNum class will be found in SquareNum.html.

import java.io.*;

/**

* This class demonstrates documentation comments.

* @author Ayan Amhed

* @version 1.2

*/

public class SquareNum {

   /**

   * This method returns the square of num.

   * This is a multiline description. You can use

   * as many lines as you like.

   * @param num The value to be squared.

   * @return num squared.

   */

   public double square(double num) {

      return num * num;

   }

   /**

   * This method inputs a number from the user.

   * @return The value input as a double.

   * @exception IOException On input error.

   * @see IOException

   */

   public double getNumber() throws IOException {

      InputStreamReader isr = new InputStreamReader(System.in);

      BufferedReader inData = new BufferedReader(isr);

      String str;

      str = inData.readLine();

      return (new Double(str)).doubleValue();

   }

   /**

   * This method demonstrates square().

   * @param args Unused.

   * @return Nothing.

   * @exception IOException On input error.

   * @see IOException

   */

   public static void main(String args[]) throws IOException

   {

      SquareNum ob = new SquareNum();

      double val;

      System.out.println("Enter value to be squared: ");

      val = ob.getNumber();

      val = ob.square(val);

      System.out.println("Squared value is " + val);

   }

}

Now process above SquareNum.java file using javadoc utility as follows:

$ javadoc SquareNum.java

Loading source file SquareNum.java...

Constructing Javadoc information...

Standard Doclet version 1.5.0_13

Building tree for all the packages and classes...

Generating SquareNum.html...

SquareNum.java:39: warning - @return tag cannot be used\

                      in method with void return type.

Generating package-frame.html...

Generating package-summary.html...

Generating package-tree.html...

Generating constant-values.html...

Building index for all the packages and classes...

Generating overview-tree.html...

Generating index-all.html...

Generating deprecated-list.html...

Building index for all classes...

Generating allclasses-frame.html...

Generating allclasses-noframe.html...

Generating index.html...

Generating help-doc.html...

Generating stylesheet.css...

1 warning

$

You can check all the generated documentation here: SquareNum.

________________________________________

THREADING:

Java provides built-in support for multithreaded programming. A multithreaded program contains two or more parts that can run concurrently. Each part of such a program is called a thread, and each thread defines a separate path of execution.
A multithreading is a specialized form of multitasking. Multitasking threads require less overhead than multitasking processes.
I need to define another term related to threads: process: A process consists of the memory space allocated by the operating system that can contain one or more threads. A thread cannot exist on its own; it must be a part of a process. A process remains running until all of the non-daemon threads are done executing.
Multithreading enables you to write very efficient programs that make maximum use of the CPU, because idle time can be kept to a minimum.
Life Cycle of a Thread:
A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. Following diagram shows complete life cycle of a thread.

Above mentioned stages are explained here:
• New: A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread.
• Runnable: After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.
• Waiting: Sometimes a thread transitions to the waiting state while the thread waits for another thread to perform a task.A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.
• Timed waiting: A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.
• Terminated: A runnable thread enters the terminated state when it completes its task or otherwise terminates.
Thread Priorities:
Every Java thread has a priority that helps the operating system determine the order in which threads are scheduled.
Java priorities are in the range between MIN_PRIORITY (a constant of 1) and MAX_PRIORITY (a constant of 10). By default, every thread is given priority NORM_PRIORITY (a constant of 5).
Threads with higher priority are more important to a program and should be allocated processor time before lower-priority threads. However, thread priorities cannot guarantee the order in which threads execute and very much platform dependentant.
Creating a Thread:
Java defines two ways in which this can be accomplished:
• You can implement the Runnable interface.
• You can extend the Thread class, itself.
Create Thread by Implementing Runnable:
The easiest way to create a thread is to create a class that implements the Runnable interface.
To implement Runnable, a class need only implement a single method called run( ), which is declared like this:
public void run( )
You will define the code that constitutes the new thread inside run() method. It is important to understand that run() can call other methods, use other classes, and declare variables, just like the main thread can.
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 will use is shown here:
Thread(Runnable threadOb, String threadName);
Here threadOb is an instance of a class that implements the Runnable interface and 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. The start( ) method is shown here:
void start( );

Example:
Here is an example that creates a new thread and starts it running:
// Create a new thread.
class NewThread implements Runnable {
   Thread t;
   NewThread() {
      // Create a new, second thread
      t = new Thread(this, "Demo Thread");
      System.out.println("Child thread: " + t);
      t.start(); // Start the thread
   }
 
   // This is the entry point for the second thread.
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
            // Let the thread sleep for a while.
            Thread.sleep(500);
         }
     } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
     }
     System.out.println("Exiting child thread.");
   }
}

class ThreadDemo {
   public static void main(String args[]) {
      new NewThread(); // create a new thread
      try {
         for(int i = 5; i > 0; i--) {
           System.out.println("Main Thread: " + i);
           Thread.sleep(1000);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}
This would produce following result:
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.
Create Thread by Extending Thread:
The second way to create a thread is to create a new class that extends Thread, and then to create an instance of that class.
The extending class must override the run( ) method, which is the entry point for the new thread. It must also call start( ) to begin execution of the new thread.
Example:
Here is the preceding program rewritten to extend Thread:
// Create a second thread by extending Thread
class NewThread extends Thread {
   NewThread() {
      // Create a new, second thread
      super("Demo Thread");
      System.out.println("Child thread: " + this);
      start(); // Start the thread
   }

   // This is the entry point for the second thread.
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
// Let the thread sleep for a while.
            Thread.sleep(500);
         }
      } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
      }
      System.out.println("Exiting child thread.");
   }
}

class ExtendThread {
   public static void main(String args[]) {
      new NewThread(); // create a new thread
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Main Thread: " + i);
            Thread.sleep(1000);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

This would produce following result:
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.
Thread Methods:
Following is the list of important medthods available in the Thread class.
SN Methods with Description
1 public void start()
Starts the thread in a separate path of execution, then invokes the run() method on this Thread object.
2 public void run()
If this Thread object was instantiated using a separate Runnable target, the run() method is invoked on that Runnable object.
3 public final void setName(String name)
Changes the name of the Thread object. There is also a getName() method for retrieving the name.
4 public final void setPriority(int priority)
Sets the priority of this Thread object. The possible values are between 1 and 10.
5 public final void setDaemon(boolean on)
A parameter of true denotes this Thread as a daemon thread.
6 public final void join(long millisec)
The current thread invokes this method on a second thread, causing the current thread to block until the second thread terminates or the specified number of milliseconds passes.
7 public void interrupt()
Interrupts this thread, causing it to continue execution if it was blocked for any reason.
8 public final boolean isAlive()
Returns true if the thread is alive, which is any time after the thread has been started but before it runs to completion.
The previous methods are invoked on a particular Thread object. The following methods in the Thread class are static. Invoking one of the static methods performs the operation on the currently running thread
SN Methods with Description
1 public static void yield()
Causes the currently running thread to yield to any other threads of the same priority that are waiting to be scheduled
2 public static void sleep(long millisec)
Causes the currently running thread to block for at least the specified number of milliseconds
3 public static boolean holdsLock(Object x)
Returns true if the current thread holds the lock on the given Object.
4 public static Thread currentThread()
Returns a reference to the currently running thread, which is the thread that invokes this method.
5 public static void dumpStack()
Prints the stack trace for the currently running thread, which is useful when debugging a multithreaded application.
Example:
The following ThreadClassDemo program demonstrates some of these methods of the Thread class:
// File Name : DisplayMessage.java
// Create a thread to implement Runnable
public class DisplayMessage implements Runnable
{
   private String message;
   public DisplayMessage(String message)
   {
      this.message = message;
   }
   public void run()
   {
      while(true)
      {
         System.out.println(message);
      }
   }
}

// File Name : GuessANumber.java
// Create a thread to extentd Thread
public class GuessANumber extends Thread
{
   private int number;
   public GuessANumber(int number)
   {
      this.number = number;
   }
   public void run()
   {
      int counter = 0;
      int guess = 0;
      do
      {
          guess = (int) (Math.random() * 100 + 1);
          System.out.println(this.getName()
                       + " guesses " + guess);
          counter++;
      }while(guess != number);
      System.out.println("** Correct! " + this.getName()
                       + " in " + counter + " guesses.**");
   }
}

// File Name : ThreadClassDemo.java
public class ThreadClassDemo
{
   public static void main(String [] args)
   {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
     
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(hello);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try
      {
         thread3.join();
      }catch(InterruptedException e)
      {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
     
 thread4.start();
      System.out.println("main() is ending...");
   }
}
This would produce following result. You can try this example again and again and you would get different result every time.
Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Thread-2 guesses 27
Hello
** Correct! Thread-2 in 102 guesses.**
Hello
Starting thread4...
Hello
Hello
..........remaining result produced.
Major Thread Concepts:
While doing Multithreading programming, you would need to have following concepts very handy:
• Thread Synchronization
• Interthread Communication
• Thread Deadlock
• Thread Control: Suspend, Stop and Resume
Using Multithreading:
The key to utilizing multithreading support effectively is to think concurrently rather than serially. For example, when you have two subsystems within a program that can execute concurrently, make them individual threads.
With the careful use of multithreading, you can create very efficient programs. A word of caution is in order, however: If you create too many threads, you can actually degrade the performance of your program rather than enhance it.
Remember, some overhead is associated with context switching. If you create too many threads, more CPU time will be spent changing contexts than executing your program!

JAVA-STRINGS:

Strings, which are widely used in Java programming, are a sequence of characters. In the Java programming language, strings are objects.

The Java platform provides the String class to create and manipulate strings.

Creating Strings:

The most direct way to create a string is to write:

String greeting = "Hello world!";

Whenever it encounters a string literal in your code, the compiler creates a String object with its valuein this case, "Hello world!'.

As with any other object, you can create String objects by using the new keyword and a constructor. The String class has eleven constructors that allow you to provide the initial value of the string using different sources, such as an array of characters:

public class StringDemo{

   public static void main(String args[]){

      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.'};

      String helloString = new String(helloArray); 

      System.out.println( helloString );

   }

}

This would produce following result:

hello

Note: The String class is immutable, so that once it is created a String object cannot be changed. If there is a necessity to make alot of modifications to Strings of characters then you should use String Buffer & String Builder Classes.

String Length:

Methods used to obtain information about an object are known as accessor methods. One accessor method that you can use with strings is the length() method, which returns the number of characters contained in the string object.

After the following two lines of code have been executed, len equals 17:

public class StringDemo{

   public static void main(String args[]){

      String palindrome = "Dot saw I was Tod";

      int len = palindrome.length();

      System.out.println( "String Length is : " + len );

   }

}

This would produce following result:

String Length is : 17

Concatenating Strings:

The String class includes a method for concatenating two strings:

string1.concat(string2);

This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method with string literals, as in:

"My name is ".concat("Zara");

Strings are more commonly concatenated with the + operator, as in:

"Hello," + " world" + "!"

which results in:

"Hello, world!"

Let us look at the followinge example:

public class StringDemo{

   public static void main(String args[]){

      String string1 = "saw I was ";

      System.out.println("Dot " + string1 + "Tod");

   }

}

This would produce following result:

Dot saw I was Tod

Creating Format Strings:

You have printf() and format() methods to print output with formatted numbers. The String class has an equivalent class method, format(), that returns a String object rather than a PrintStream object.

Using String's static format() method allows you to create a formatted string that you can reuse, as opposed to a one-time print statement. For example, instead of:

System.out.printf("The value of the float variable is " +

                  "%f, while the value of the integer " +

                  "variable is %d, and the string " +

                  "is %s", floatVar, intVar, stringVar);

you can write:

String fs;

fs = String.format("The value of the float variable is " +

                   "%f, while the value of the integer " +

                   "variable is %d, and the string " +

                   "is %s", floatVar, intVar, stringVar);

System.out.println(fs);

String Methods:

Here is the list methods supported by String class:

SN       Methods with Description

1          char charAt(int index)

Returns the character at the specified index.

2          int compareTo(Object o)

Compares this String to another Object.

3          int compareTo(String anotherString)

Compares two strings lexicographically.

4          int compareToIgnoreCase(String str)

Compares two strings lexicographically, ignoring case differences.

5          String concat(String str)

Concatenates the specified string to the end of this string.

6          boolean contentEquals(StringBuffer sb)

Returns true if and only if this String represents the same sequence of characters as the specified StringBuffer.

7          static String copyValueOf(char[] data)

Returns a String that represents the character sequence in the array specified.

8          static String copyValueOf(char[] data, int offset, int count)

Returns a String that represents the character sequence in the array specified.

9          boolean endsWith(String suffix)

Tests if this string ends with the specified suffix.

10       boolean equals(Object anObject)

Compares this string to the specified object.

11       boolean equalsIgnoreCase(String anotherString)

Compares this String to another String, ignoring case considerations.

12       byte getBytes()

Encodes this String into a sequence of bytes using the platform's default charset, storing the result into a new byte array.

13       byte[] getBytes(String charsetName

Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte array.

14       void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Copies characters from this string into the destination character array.

15       int hashCode()

Returns a hash code for this string.

16       int indexOf(int ch)

Returns the index within this string of the first occurrence of the specified character.

17       int indexOf(int ch, int fromIndex)

Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.

18       int indexOf(String str)

Returns the index within this string of the first occurrence of the specified substring.

19       int indexOf(String str, int fromIndex)

Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.

20       String intern()

Returns a canonical representation for the string object.

21       int lastIndexOf(int ch)

Returns the index within this string of the last occurrence of the specified character.

22       int lastIndexOf(int ch, int fromIndex)

Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.

23       int lastIndexOf(String str)

Returns the index within this string of the rightmost occurrence of the specified substring.

24       int lastIndexOf(String str, int fromIndex)

Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.

25       int length()

Returns the length of this string.

26       boolean matches(String regex)

Tells whether or not this string matches the given regular expression.

27       boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

Tests if two string regions are equal.

28       boolean regionMatches(int toffset, String other, int ooffset, int len)

Tests if two string regions are equal.

29       String replace(char oldChar, char newChar)

Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

30       String replaceAll(String regex, String replacement

Replaces each substring of this string that matches the given regular expression with the given replacement.

31       String replaceFirst(String regex, String replacement)

Replaces the first substring of this string that matches the given regular expression with the given replacement.

32       String[] split(String regex)

Splits this string around matches of the given regular expression.

33       String[] split(String regex, int limit)

Splits this string around matches of the given regular expression.

34       boolean startsWith(String prefix)

Tests if this string starts with the specified prefix.

35       boolean startsWith(String prefix, int toffset)

Tests if this string starts with the specified prefix beginning a specified index.

36       CharSequence subSequence(int beginIndex, int endIndex)

Returns a new character sequence that is a subsequence of this sequence.

37       String substring(int beginIndex)

Returns a new string that is a substring of this string.

38       String substring(int beginIndex, int endIndex)

Returns a new string that is a substring of this string.

39       char[] toCharArray()

Converts this string to a new character array.

40       String toLowerCase()

Converts all of the characters in this String to lower case using the rules of the default locale.

41       String toLowerCase(Locale locale)

Converts all of the characters in this String to lower case using the rules of the given Locale.

42       String toString()

This object (which is already a string!) is itself returned.

43       String toUpperCase()

Converts all of the characters in this String to upper case using the rules of the default locale.

44       String toUpperCase(Locale locale)

Converts all of the characters in this String to upper case using the rules of the given Locale.

45       String trim()

Returns a copy of the string, with leading and trailing whitespace omitted.

46       static String valueOf(primitive data type x)

Returns the string representation of the passed data type argument.

SERIALIZATION:

Java provides a mechanism, called object serialization where an object can be represented as a sequence of bytes that includes the object's data as well as information about the object's type and the types of data stored in the object.

After a serialized object has been written into a file, it can be read from the file and deserialized that is, the type information and bytes that represent the object and its data can be used to recreate the object in memory.

Most impressive is that the entire process is JVM independent, meaning an object can be serialized on one platform and deserialized on an entirely different platform.

Classes ObjectInputStream and ObjectOutputStream are high-level streams that contain the methods for serializing and deserializing an object.

The ObjectOutputStream class contains many write methods for writing various data types, but one method in particular stands out:

public final void writeObject(Object x) throws IOException

The above method serializes an Object and sends it to the output stream. Similarly, the ObjectInputStream class contains the following method for deserializing an object:

public final Object readObject() throws IOException,                                  ClassNotFoundException

This method retrieves the next Object out of the stream and deserializes it. The return value is Object, so you will need to cast it to its appropriate data type.

To demonstrate how serialization works in Java, I am going to use the Employee class that we discussed early on in the book. Suppose that we have the following Employee class, which implements the Serializable interface:

public class Employee implements java.io.Serializable {    public String name;    public String address;    public int transient SSN;    public int number;    public void mailCheck()    {       System.out.println("Mailing a check to " + name                            + " " + address);    } }

Notice that for a class to be serialized successfully, two conditions must be met:

• The class must implement the java.io.Serializable interface.
• All of the fields in the class must be serializable. If a field is not serializable, it must be marked transient.

If you are curious to know if a Java Satandard Class is serializable or not, check the documentation for the class. The test is simple: If the class implements java.io.Serializable, then it is serializable; otherwise, it's not.

Serializing an Object:

The ObjectOutputStream class is used to serialize an Object. The following SerializeDemo program instantiates an Employee object and serializes it to a file.

When the program is done executing, a file named employee.ser is created. The program does not generate any output, but study the code and try to determine what the program is doing.

Note: When serializing an object to a file, the standard convention in Java is to give the file a .ser extension.

import java.io.*; public class SerializeDemo {    public static void main(String [] args)    {       Employee e = new Employee();       e.name = "Reyan Ali";       e.address = "Phokka Kuan, Ambehta Peer";       e.SSN = 11122333;       e.number = 101;       try       {          FileOutputStream fileOut =          new FileOutputStream("employee.ser");          ObjectOutputStream out =                             new ObjectOutputStream(fileOut);          out.writeObject(e);          out.close();           fileOut.close();       }catch(IOException i)       {           i.printStackTrace();       }    } }

Deserializing an Object:

The following DeserializeDemo program deserializes the Employee object created in the SerializeDemo program. Study the program and try to determine its output:

import java.io.*;    public class DeserializeDemo    {       public static void main(String [] args)       {          Employee e = null;          try          {             FileInputStream fileIn =                           new FileInputStream("employee.ser");             ObjectInputStream in = new ObjectInputStream(fileIn);             e = (Employee) in.readObject();             in.close();             fileIn.close();         }catch(IOException i)         {             i.printStackTrace();             return;         }catch(ClassNotFoundException c)         {             System.out.println(.Employee class not found.);             c.printStackTrace();             return;         }         System.out.println("Deserialized Employee...");         System.out.println("Name: " + e.name);         System.out.println("Address: " + e.address);         System.out.println("SSN: " + e.SSN);         System.out.println("Number: " + e.number);     } }

This would produce following result:

Deserialized Employee... Name: Reyan Ali Address:Phokka Kuan, Ambehta Peer SSN: 0 Number:101

Here are following important points to be noted:

• The try/catch block tries to catch a ClassNotFoundException, which is declared by the readObject() method. For a JVM to be able to deserialize an object, it must be able to find the bytecode for the class. If the JVM can't find a class during the deserialization of an object, it throws a ClassNotFoundException.
• Notice that the return value of readObject() is cast to an Employee reference.
• The value of the SSN field was 11122333 when the object was serialized, but because the field is transient, this value was not sent to the output stream. The SSN field of the deserialized Employee object is 0.

Java-EMAIL:

To send an email using your Java Application is simple enough but to start with you should have JavaMail API and Java Activation Framework (JAF) installed on your machine.

• You can download latest version of JavaMail (Version 1.2) from Java's standard website.
• You can download latest version of JAF (Version 1.1.1) from Java's standard website.

Download and unzip these files, in the newly created top level directories you will find a number of jar files for both the applications. You need to add mail.jar and activation.jar files in your CLASSPATH.

Send a Simple Email:

Here is an example to send a simple email from your machine. Here it is assumed that your localhost is connected to the internet and capable enough to send an email.

// File Name SendEmail.java import java.util.*; import javax.mail.*; import javax.mail.internet.*; import javax.activation.*; public class SendEmail {    public static void main(String [] args)    {             // Recipient's email ID needs to be mentioned.       String to = "abcd@gmail.com";       // Sender's email ID needs to be mentioned       String from = "web@gmail.com";       // Assuming you are sending email from localhost       String host = "localhost";       // Get system properties       Properties properties = System.getProperties();       // Setup mail server       properties.setProperty("mail.smtp.host", host);       // Get the default Session object.       Session session = Session.getDefaultInstance(properties);       try{          // Create a default MimeMessage object.          MimeMessage message = new MimeMessage(session);          // Set From: header field of the header.          message.setFrom(new InternetAddress(from));          // Set To: header field of the header.          message.addRecipient(Message.RecipientType.TO,                                   new InternetAddress(to));          // Set Subject: header field          message.setSubject("This is the Subject Line!");          // Now set the actual message          message.setText("This is actual message");          // Send message          Transport.send(message);          System.out.println("Sent message successfully....");       }catch (MessagingException mex) {          mex.printStackTrace();       }    } }

Compile and run this program to send a simple email:

$ java SendEmail Sent message successfully....

If you want to send an email to multiple recipients then following methods would be used to specify multiple email IDs:

void addRecipients(Message.RecipientType type,                     Address[] addresses) throws MessagingException

Here is the description of the parameters:

• type: This would be set to TO, CC or BCC. Here CC represents Carbon Copy and BCC represents Black Carbon Copy. Example Message.RecipientType.TO
• addresses: This is the array of email ID. You would need to use InternetAddress() method while specifying email IDs

Send an HTML Email:

Here is an example to send an HTML email from your machine. Here it is assumed that your localhost is connected to the internet and capable enough to send an email.

This example is very similar to previous one, except here we are using setContent() method to set content whose second argument is "text/html" to specify that the HTML content is included in the message.

Using this example, you can send as big as HTML content you like.

// File Name SendHTMLEmail.java import java.util.*; import javax.mail.*; import javax.mail.internet.*; import javax.activation.*; public class SendHTMLEmail {    public static void main(String [] args)    {             // Recipient's email ID needs to be mentioned.       String to = "abcd@gmail.com";       // Sender's email ID needs to be mentioned       String from = "web@gmail.com";       // Assuming you are sending email from localhost       String host = "localhost";       // Get system properties       Properties properties = System.getProperties();       // Setup mail server       properties.setProperty("mail.smtp.host", host);       // Get the default Session object.       Session session = Session.getDefaultInstance(properties);       try{          // Create a default MimeMessage object.          MimeMessage message = new MimeMessage(session);          // Set From: header field of the header.          message.setFrom(new InternetAddress(from));          // Set To: header field of the header.          message.addRecipient(Message.RecipientType.TO,                                   new InternetAddress(to));          // Set Subject: header field          message.setSubject("This is the Subject Line!");          // Send the actual HTML message, as big as you like          message.setContent("<h1>This is actual message</h1>",                             "text/html" );          // Send message          Transport.send(message);          System.out.println("Sent message successfully....");       }catch (MessagingException mex) {          mex.printStackTrace();       }    } }

Compile and run this program to send an HTML email:

$ java SendHTMLEmail Sent message successfully....

Send Attachment in Email:

Here is an example to send an email with attachment from your machine. Here it is assumed that your localhost is connected to the internet and capable enough to send an email.

// File Name SendFileEmail.java import java.util.*; import javax.mail.*; import javax.mail.internet.*; import javax.activation.*; public class SendFileEmail {    public static void main(String [] args)    {             // Recipient's email ID needs to be mentioned.       String to = "abcd@gmail.com";       // Sender's email ID needs to be mentioned       String from = "web@gmail.com";       // Assuming you are sending email from localhost       String host = "localhost";       // Get system properties       Properties properties = System.getProperties();       // Setup mail server       properties.setProperty("mail.smtp.host", host);       // Get the default Session object.       Session session = Session.getDefaultInstance(properties);       try{          // Create a default MimeMessage object.          MimeMessage message = new MimeMessage(session);          // Set From: header field of the header.          message.setFrom(new InternetAddress(from));          // Set To: header field of the header.          message.addRecipient(Message.RecipientType.TO,                                   new InternetAddress(to));          // Set Subject: header field          message.setSubject("This is the Subject Line!");          // Create the message part          BodyPart messageBodyPart = new MimeBodyPart();          // Fill the message          messageBodyPart.setText("This is message body");                   // Create a multipar message          Multipart multipart = new MimeMultipart();          // Set text message part          multipart.addBodyPart(messageBodyPart);          // Part two is attachment          messageBodyPart = new MimeBodyPart();          String filename = "file.txt";          DataSource source = new FileDataSource(filename);          messageBodyPart.setDataHandler(new DataHandler(source));          messageBodyPart.setFileName(filename);          multipart.addBodyPart(messageBodyPart);          // Send the complete message parts          message.setContent(multipart );          // Send message          Transport.send(message);          System.out.println("Sent message successfully....");       }catch (MessagingException mex) {          mex.printStackTrace();       }    } }

Compile and run this program to send an HTML email:

$ java SendFileEmail Sent message successfully....

User Authentication Part:

If it is required to provide user ID and Password to the email server for authentication purpose then you can set these properties as follows:

props.setProperty("mail.user", "myuser");  props.setProperty("mail.password", "mypwd");

Rest of the email sending mechanism would remain as explained above.