class Animal {
   pubpc void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   pubpc void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

pubpc class TestDog {

   pubpc static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

This will produce the following result −

Output

Animals can move
Dogs can walk and run

Java - Polymorphism

Polymorphism is the abipty of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object.

Any Java object that can pass more than one IS-A test is considered to be polymorphic. In Java, all Java objects are polymorphic since any object will pass the IS-A test for their own type and for the class Object.

It is important to know that the only possible way to access an object is through a reference variable. A reference variable can be of only one type. Once declared, the type of a reference variable cannot be changed.

The reference variable can be reassigned to other objects provided that it is not declared final. The type of the reference variable would determine the methods that it can invoke on the object.

A reference variable can refer to any object of its declared type or any subtype of its declared type. A reference variable can be declared as a class or interface type.

Example

Let us look at an example.

pubpc interface Vegetarian{}
pubpc class Animal{}
pubpc class Deer extends Animal implements Vegetarian{}

Now, the Deer class is considered to be polymorphic since this has multiple inheritance. Following are true for the above examples −

A Deer IS-A Animal

A Deer IS-A Vegetarian

A Deer IS-A Deer

A Deer IS-A Object

When we apply the reference variable facts to a Deer object reference, the following declarations are legal −

Example

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

All the reference variables d, a, v, o refer to the same Deer object in the heap.

Virtual Methods

In this section, I will show you how the behavior of overridden methods in Java allows you to take advantage of polymorphism when designing your classes.

We already have discussed method overriding, where a child class can override a method in its parent. An overridden method is essentially hidden in the parent class, and is not invoked unless the child class uses the super keyword within the overriding method.

Example

/* File name : Employee.java */
pubpc class Employee {
   private String name;
   private String address;
   private int number;

   pubpc Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   pubpc void mailCheck() {
      System.out.println("Maipng a check to " + this.name + " " + this.address);
   }

   pubpc String toString() {
      return name + " " + address + " " + number;
   }

   pubpc String getName() {
      return name;
   }

   pubpc String getAddress() {
      return address;
   }

   pubpc void setAddress(String newAddress) {
      address = newAddress;
   }

   pubpc int getNumber() {
      return number;
   }
}

Now suppose we extend Employee class as follows −

/* File name : Salary.java */
pubpc class Salary extends Employee {
   private double salary; // Annual salary
   
   pubpc Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   pubpc void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Maipng check to " + getName()
      + " with salary " + salary);
   }
   
   pubpc double getSalary() {
      return salary;
   }
   
   pubpc void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   pubpc double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Now, you study the following program carefully and try to determine its output −

/* File name : VirtualDemo.java */
pubpc class VirtualDemo {

   pubpc static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("
 Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

This will produce the following result −

Output

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Maipng check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Maipng check to John Adams with salary 2400.0

Here, we instantiate two Salary objects. One using a Salary reference s, and the other using an Employee reference e.

While invoking s.mailCheck(), the compiler sees mailCheck() in the Salary class at compile time, and the JVM invokes mailCheck() in the Salary class at run time.

mailCheck() on e is quite different because e is an Employee reference. When the compiler sees e.mailCheck(), the compiler sees the mailCheck() method in the Employee class.

Here, at compile time, the compiler used mailCheck() in Employee to vapdate this statement. At run time, however, the JVM invokes mailCheck() in the Salary class.

This behavior is referred to as virtual method invocation, and these methods are referred to as virtual methods. An overridden method is invoked at run time, no matter what data type the reference is that was used in the source code at compile time.

Java - Abstraction

As per dictionary, abstraction is the quapty of deapng with ideas rather than events. For example, when you consider the case of e-mail, complex details such as what happens as soon as you send an e-mail, the protocol your e-mail server uses are hidden from the user. Therefore, to send an e-mail you just need to type the content, mention the address of the receiver, and cpck send.

Likewise in Object-oriented programming, abstraction is a process of hiding the implementation details from the user, only the functionapty will be provided to the user. In other words, the user will have the information on what the object does instead of how it does it.

In Java, abstraction is achieved using Abstract classes and interfaces.

Abstract Class

A class which contains the abstract keyword in its declaration is known as abstract class.

Abstract classes may or may not contain abstract methods, i.e., methods without body ( pubpc void get(); )

But, if a class has at least one abstract method, then the class must be declared abstract.

If a class is declared abstract, it cannot be instantiated.

To use an abstract class, you have to inherit it from another class, provide implementations to the abstract methods in it.

If you inherit an abstract class, you have to provide implementations to all the abstract methods in it.

Example

This section provides you an example of the abstract class. To create an abstract class, just use the abstract keyword before the class keyword, in the class declaration.

/* File name : Employee.java */
pubpc abstract class Employee {
   private String name;
   private String address;
   private int number;

   pubpc Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   pubpc double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   pubpc void mailCheck() {
      System.out.println("Maipng a check to " + this.name + " " + this.address);
   }

   pubpc String toString() {
      return name + " " + address + " " + number;
   }

   pubpc String getName() {
      return name;
   }
 
   pubpc String getAddress() {
      return address;
   }
   
   pubpc void setAddress(String newAddress) {
      address = newAddress;
   }
 
   pubpc int getNumber() {
      return number;
   }
}

You can observe that except abstract methods the Employee class is same as normal class in Java. The class is now abstract, but it still has three fields, seven methods, and one constructor.

Now you can try to instantiate the Employee class in the following way −

/* File name : AbstractDemo.java */
pubpc class AbstractDemo {

   pubpc static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("
 Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

When you compile the above class, it gives you the following error −

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Inheriting the Abstract Class

We can inherit the properties of Employee class just pke concrete class in the following way −

Example

/* File name : Salary.java */
pubpc class Salary extends Employee {
   private double salary;   // Annual salary
   
   pubpc Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   pubpc void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Maipng check to " + getName() + " with salary " + salary);
   }
 
   pubpc double getSalary() {
      return salary;
   }
   
   pubpc void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   pubpc double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Here, you cannot instantiate the Employee class, but you can instantiate the Salary Class, and using this instance you can access all the three fields and seven methods of Employee class as shown below.

/* File name : AbstractDemo.java */
pubpc class AbstractDemo {

   pubpc static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("
 Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

This produces the following result −

Output

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Maipng check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Maipng check to John Adams with salary 2400.0

Abstract Methods

If you want a class to contain a particular method but you want the actual implementation of that method to be determined by child classes, you can declare the method in the parent class as an abstract.

abstract keyword is used to declare the method as abstract.

You have to place the abstract keyword before the method name in the method declaration.

An abstract method contains a method signature, but no method body.

Instead of curly braces, an abstract method will have a semoi colon (;) at the end.

Following is an example of the abstract method.

Example

pubpc abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   pubpc abstract double computePay();
   // Remainder of class definition
}

Declaring a method as abstract has two consequences −

The class containing it must be declared as abstract.

Any class inheriting the current class must either override the abstract method or declare itself as abstract.

Note − Eventually, a descendant class has to implement the abstract method; otherwise, you would have a hierarchy of abstract classes that cannot be instantiated.

Suppose Salary class inherits the Employee class, then it should implement the computePay() method as shown below −

/* File name : Salary.java */
pubpc class Salary extends Employee {
   private double salary;   // Annual salary
  
   pubpc double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Java - Encapsulation

Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance, polymorphism, and abstraction.

Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. In encapsulation, the variables of a class will be hidden from other classes, and can be accessed only through the methods of their current class. Therefore, it is also known as data hiding.

To achieve encapsulation in Java −

Declare the variables of a class as private.

Provide pubpc setter and getter methods to modify and view the variables values.

Example

Following is an example that demonstrates how to achieve Encapsulation in Java −

/* File name : EncapTest.java */
pubpc class EncapTest {
   private String name;
   private String idNum;
   private int age;

   pubpc int getAge() {
      return age;
   }

   pubpc String getName() {
      return name;
   }

   pubpc String getIdNum() {
      return idNum;
   }

   pubpc void setAge( int newAge) {
      age = newAge;
   }

   pubpc void setName(String newName) {
      name = newName;
   }

   pubpc void setIdNum( String newId) {
      idNum = newId;
   }
}

The pubpc setXXX() and getXXX() methods are the access points of the instance variables of the EncapTest class. Normally, these methods are referred as getters and setters. Therefore, any class that wants to access the variables should access them through these getters and setters.

The variables of the EncapTest class can be accessed using the following program −

/* File name : RunEncap.java */
pubpc class RunEncap {

   pubpc static void main(String args[]) {
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
   }
}

This will produce the following result −

Output

Name : James Age : 20

Benefits of Encapsulation

The fields of a class can be made read-only or write-only.

A class can have total control over what is stored in its fields.

Java - Interfaces

An interface is a reference type in Java. It is similar to class. It is a collection of abstract methods. A class implements an interface, thereby inheriting the abstract methods of the interface.

Along with abstract methods, an interface may also contain constants, default methods, static methods, and nested types. Method bodies exist only for default methods and static methods.

Writing an interface is similar to writing a class. But a class describes the attributes and behaviors of an object. And an interface contains behaviors that a class implements.

Unless the class that implements the interface is abstract, all the methods of the interface need to be defined in the class.

An interface is similar to a class in the following ways −

An interface can contain any number of methods.

An interface is written in a file with a .java extension, with the name of the interface matching the name of the file.

The byte code of an interface appears in a .class file.

Interfaces appear in packages, and their corresponding bytecode file must be in a directory structure that matches the package name.

However, an interface is different from a class in several ways, including −

You cannot instantiate an interface.

An interface does not contain any constructors.

All of the methods in an interface are abstract.

An interface cannot contain instance fields. The only fields that can appear in an interface must be declared both static and final.

An interface is not extended by a class; it is implemented by a class.

An interface can extend multiple interfaces.

Declaring Interfaces

The interface keyword is used to declare an interface. Here is a simple example to declare an interface −

Example

Following is an example of an interface −

/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements

pubpc interface NameOfInterface {
   // Any number of final, static fields
   // Any number of abstract method declarations
}

Interfaces have the following properties −

An interface is imppcitly abstract. You do not need to use the abstract keyword while declaring an interface.

Each method in an interface is also imppcitly abstract, so the abstract keyword is not needed.

Methods in an interface are imppcitly pubpc.

Example

/* File name : Animal.java */
interface Animal {
   pubpc void eat();
   pubpc void travel();
}

Implementing Interfaces

When a class implements an interface, you can think of the class as signing a contract, agreeing to perform the specific behaviors of the interface. If a class does not perform all the behaviors of the interface, the class must declare itself as abstract.

A class uses the implements keyword to implement an interface. The implements keyword appears in the class declaration following the extends portion of the declaration.

Example

/* File name : MammalInt.java */
pubpc class MammalInt implements Animal {

   pubpc void eat() {
      System.out.println("Mammal eats");
   }

   pubpc void travel() {
      System.out.println("Mammal travels");
   } 

   pubpc int noOfLegs() {
      return 0;
   }

   pubpc static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
} 

This will produce the following result −

Output

Mammal eats
Mammal travels

When overriding methods defined in interfaces, there are several rules to be followed −

Checked exceptions should not be declared on implementation methods other than the ones declared by the interface method or subclasses of those declared by the interface method.

The signature of the interface method and the same return type or subtype should be maintained when overriding the methods.

An implementation class itself can be abstract and if so, interface methods need not be implemented.

When implementation interfaces, there are several rules −

A class can implement more than one interface at a time.

A class can extend only one class, but implement many interfaces.

An interface can extend another interface, in a similar way as a class can extend another class.

Extending Interfaces

An interface can extend another interface in the same way that a class can extend another class. The extends keyword is used to extend an interface, and the child interface inherits the methods of the parent interface.

The following Sports interface is extended by Hockey and Football interfaces.

Example

// Filename: Sports.java
pubpc interface Sports {
   pubpc void setHomeTeam(String name);
   pubpc void setVisitingTeam(String name);
}

// Filename: Football.java
pubpc interface Football extends Sports {
   pubpc void homeTeamScored(int points);
   pubpc void visitingTeamScored(int points);
   pubpc void endOfQuarter(int quarter);
}

// Filename: Hockey.java
pubpc interface Hockey extends Sports {
   pubpc void homeGoalScored();
   pubpc void visitingGoalScored();
   pubpc void endOfPeriod(int period);
   pubpc void overtimePeriod(int ot);
}

The Hockey interface has four methods, but it inherits two from Sports; thus, a class that implements Hockey needs to implement all six methods. Similarly, a class that implements Football needs to define the three methods from Football and the two methods from Sports.

Extending Multiple Interfaces

A Java class can only extend one parent class. Multiple inheritance is not allowed. Interfaces are not classes, however, and an interface can extend more than one parent interface.

The extends keyword is used once, and the parent interfaces are declared in a comma-separated pst.

For example, if the Hockey interface extended both Sports and Event, it would be declared as −

Example

pubpc interface Hockey extends Sports, Event

Tagging Interfaces

The most common use of extending interfaces occurs when the parent interface does not contain any methods. For example, the MouseListener interface in the java.awt.event package extended java.util.EventListener, which is defined as −

Example

package java.util;
pubpc interface EventListener
{}

An interface with no methods in it is referred to as a tagging interface. There are two basic design purposes of tagging interfaces −

Creates a common parent − As with the EventListener interface, which is extended by dozens of other interfaces in the Java API, you can use a tagging interface to create a common parent among a group of interfaces. For example, when an interface extends EventListener, the JVM knows that this particular interface is going to be used in an event delegation scenario.

Adds a data type to a class − This situation is where the term, tagging comes from. A class that implements a tagging interface does not need to define any methods (since the interface does not have any), but the class becomes an interface type through polymorphism.

Java - Packages

Packages are used in Java in order to prevent naming confpcts, to control access, to make searching/locating and usage of classes, interfaces, enumerations and annotations easier, etc.

A Package can be defined as a grouping of related types (classes, interfaces, enumerations and annotations ) providing access protection and namespace management.

Some of the existing packages in Java are −

java.lang − bundles the fundamental classes

java.io − classes for input , output functions are bundled in this package

Programmers can define their own packages to bundle group of classes/interfaces, etc. It is a good practice to group related classes implemented by you so that a programmer can easily determine that the classes, interfaces, enumerations, and annotations are related.

Since the package creates a new namespace there won t be any name confpcts with names in other packages. Using packages, it is easier to provide access control and it is also easier to locate the related classes.

Creating a Package

While creating a package, you should choose a name for the package and include a package statement along with that name at the top of every source file that contains the classes, interfaces, enumerations, and annotation types that you want to include in the package.

The package statement should be the first pne in the source file. There can be only one package statement in each source file, and it apppes to all types in the file.

If a package statement is not used then the class, interfaces, enumerations, and annotation types will be placed in the current default package.

To compile the Java programs with package statements, you have to use -d option as shown below.

javac -d Destination_folder file_name.java

Then a folder with the given package name is created in the specified destination, and the compiled class files will be placed in that folder.

Example

Let us look at an example that creates a package called animals. It is a good practice to use names of packages with lower case letters to avoid any confpcts with the names of classes and interfaces.

Following package example contains interface named animals −

/* File name : Animal.java */
package animals;

interface Animal {
   pubpc void eat();
   pubpc void travel();
}

Now, let us implement the above interface in the same package animals −

package animals;
/* File name : MammalInt.java */

pubpc class MammalInt implements Animal {

   pubpc void eat() {
      System.out.println("Mammal eats");
   }

   pubpc void travel() {
      System.out.println("Mammal travels");
   } 

   pubpc int noOfLegs() {
      return 0;
   }

   pubpc static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
} 

Now compile the java files as shown below −

$ javac -d . Animal.java 
$ javac -d . MammalInt.java

Now a package/folder with the name animals will be created in the current directory and these class files will be placed in it as shown below.

You can execute the class file within the package and get the result as shown below.

Mammal eats
Mammal travels

The import Keyword

If a class wants to use another class in the same package, the package name need not be used. Classes in the same package find each other without any special syntax.

Example

Here, a class named Boss is added to the payroll package that already contains Employee. The Boss can then refer to the Employee class without using the payroll prefix, as demonstrated by the following Boss class.

package payroll;
pubpc class Boss {
   pubpc void payEmployee(Employee e) {
      e.mailCheck();
   }
}

What happens if the Employee class is not in the payroll package? The Boss class must then use one of the following techniques for referring to a class in a different package.

The fully quapfied name of the class can be used. For example −

payroll.Employee

The package can be imported using the import keyword and the wild card (*). For example −

import payroll.*;

The class itself can be imported using the import keyword. For example −

import payroll.Employee;

Note − A class file can contain any number of import statements. The import statements must appear after the package statement and before the class declaration.

The Directory Structure of Packages

Two major results occur when a class is placed in a package −

The name of the package becomes a part of the name of the class, as we just discussed in the previous section.

The name of the package must match the directory structure where the corresponding bytecode resides.

Here is simple way of managing your files in Java −

Put the source code for a class, interface, enumeration, or annotation type in a text file whose name is the simple name of the type and whose extension is .java.

For example −

// File Name :  Car.java
package vehicle;

pubpc class Car {
   // Class implementation.   
}

Now, put the source file in a directory whose name reflects the name of the package to which the class belongs −

....vehicleCar.java

Now, the quapfied class name and pathname would be as follows −

Class name → vehicle.Car

Path name → vehicleCar.java (in windows)

In general, a company uses its reversed Internet domain name for its package names.

Example − A company s Internet domain name is apple.com, then all its package names would start with com.apple. Each component of the package name corresponds to a subdirectory.

Example − The company had a com.apple.computers package that contained a Dell.java source file, it would be contained in a series of subdirectories pke this −

....comapplecomputersDell.java

At the time of compilation, the compiler creates a different output file for each class, interface and enumeration defined in it. The base name of the output file is the name of the type, and its extension is .class.

For example −

// File Name: Dell.java
package com.apple.computers;

pubpc class Dell {
}

class Ups {
}

Now, compile this file as follows using -d option −

$javac -d . Dell.java

The files will be compiled as follows −

.comapplecomputersDell.class
.comapplecomputersUps.class

You can import all the classes or interfaces defined in comapplecomputers as follows −

import com.apple.computers.*;

Like the .java source files, the compiled .class files should be in a series of directories that reflect the package name. However, the path to the .class files does not have to be the same as the path to the .java source files. You can arrange your source and class directories separately, as −

<path-one>sourcescomapplecomputersDell.java

<path-two>classescomapplecomputersDell.class

By doing this, it is possible to give access to the classes directory to other programmers without reveapng your sources. You also need to manage source and class files in this manner so that the compiler and the Java Virtual Machine (JVM) can find all the types your program uses.

The full path to the classes directory, <path-two>classes, is called the class path, and is set with the CLASSPATH system variable. Both the compiler and the JVM construct the path to your .class files by adding the package name to the class path.

Say <path-two>classes is the class path, and the package name is com.apple.computers, then the compiler and JVM will look for .class files in <path-two>classescomapplecomputers.

A class path may include several paths. Multiple paths should be separated by a semicolon (Windows) or colon (Unix). By default, the compiler and the JVM search the current directory and the JAR file containing the Java platform classes so that these directories are automatically in the class path.

Set CLASSPATH System Variable

To display the current CLASSPATH variable, use the following commands in Windows and UNIX (Bourne shell) −

In Windows → C:> set CLASSPATH

In UNIX → % echo $CLASSPATH

To delete the current contents of the CLASSPATH variable, use −

In Windows → C:> set CLASSPATH =

In UNIX → % unset CLASSPATH; export CLASSPATH

To set the CLASSPATH variable −

In Windows → set CLASSPATH = C:usersjackjavaclasses

In UNIX → % CLASSPATH = /home/jack/java/classes; export CLASSPATH

Java - Data Structures

The data structures provided by the Java utipty package are very powerful and perform a wide range of functions. These data structures consist of the following interface and classes −

Enumeration

BitSet

Vector

Stack

Dictionary

Hashtable

Properties

All these classes are now legacy and Java-2 has introduced a new framework called Collections Framework, which is discussed in the next chapter. −

The Enumeration

The Enumeration interface isn t itself a data structure, but it is very important within the context of other data structures. The Enumeration interface defines a means to retrieve successive elements from a data structure.

For example, Enumeration defines a method called nextElement that is used to get the next element in a data structure that contains multiple elements.

To have more detail about this interface, check The Enumeration.

The BitSet

The BitSet class implements a group of bits or flags that can be set and cleared inspanidually.

This class is very useful in cases where you need to keep up with a set of Boolean values; you just assign a bit to each value and set or clear it as appropriate.

For more details about this class, check The BitSet.

The Vector

The Vector class is similar to a traditional Java array, except that it can grow as necessary to accommodate new elements.

Like an array, elements of a Vector object can be accessed via an index into the vector.

The nice thing about using the Vector class is that you don t have to worry about setting it to a specific size upon creation; it shrinks and grows automatically when necessary.

For more details about this class, check The Vector.

The Stack

The Stack class implements a last-in-first-out (LIFO) stack of elements.

You can think of a stack pterally as a vertical stack of objects; when you add a new element, it gets stacked on top of the others.

When you pull an element off the stack, it comes off the top. In other words, the last element you added to the stack is the first one to come back off.

For more details about this class, check The Stack.

The Dictionary

The Dictionary class is an abstract class that defines a data structure for mapping keys to values.

This is useful in cases where you want to be able to access data via a particular key rather than an integer index.

Since the Dictionary class is abstract, it provides only the framework for a key-mapped data structure rather than a specific implementation.

For more details about this class, check The Dictionary.

The Hashtable

The Hashtable class provides a means of organizing data based on some user-defined key structure.

For example, in an address pst hash table you could store and sort data based on a key such as ZIP code rather than on a person s name.

The specific meaning of keys with regard to hash tables is totally dependent on the usage of the hash table and the data it contains.

For more detail about this class, check The Hashtable.

The Properties

Properties is a subclass of Hashtable. It is used to maintain psts of values in which the key is a String and the value is also a String.

The Properties class is used by many other Java classes. For example, it is the type of object returned by System.getProperties( ) when obtaining environmental values.

For more detail about this class, check The Properties.

Java - Collections Framework

Prior to Java 2, Java provided ad hoc classes such as Dictionary, Vector, Stack, and Properties to store and manipulate groups of objects. Although these classes were quite useful, they lacked a central, unifying theme. Thus, the way that you used Vector was different from the way that you used Properties.

The collections framework was designed to meet several goals, such as −

The framework had to be high-performance. The implementations for the fundamental collections (dynamic arrays, pnked psts, trees, and hashtables) were to be highly efficient.

The framework had to allow different types of collections to work in a similar manner and with a high degree of interoperabipty.

The framework had to extend and/or adapt a collection easily.

Towards this end, the entire collections framework is designed around a set of standard interfaces. Several standard implementations such as LinkedList, HashSet, and TreeSet, of these interfaces are provided that you may use as-is and you may also implement your own collection, if you choose.

A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following −

Interfaces − These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy.

Implementations, i.e., Classes − These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures.

Algorithms − These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate collection interface.

In addition to collections, the framework defines several map interfaces and classes. Maps store key/value pairs. Although maps are not collections in the proper use of the term, but they are fully integrated with collections.

The Collection Interfaces

The collections framework defines several interfaces. This section provides an overview of each interface −

The Collection Classes

Java provides a set of standard collection classes that implement Collection interfaces. Some of the classes provide full implementations that can be used as-is and others are abstract class, providing skeletal implementations that are used as starting points for creating concrete collections.

The standard collection classes are summarized in the following table −

The AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList and AbstractMap classes provide skeletal implementations of the core collection interfaces, to minimize the effort required to implement them.

The following legacy classes defined by java.util have been discussed in the previous chapter −

The Collection Algorithms

The collections framework defines several algorithms that can be appped to collections and maps. These algorithms are defined as static methods within the Collections class.

Several of the methods can throw a ClassCastException, which occurs when an attempt is made to compare incompatible types, or an UnsupportedOperationException, which occurs when an attempt is made to modify an unmodifiable collection.

Collections define three static variables: EMPTY_SET, EMPTY_LIST, and EMPTY_MAP. All are immutable.

How to Use an Iterator ?

Often, you will want to cycle through the elements in a collection. For example, you might want to display each element.

The easiest way to do this is to employ an iterator, which is an object that implements either the Iterator or the ListIterator interface.

Iterator enables you to cycle through a collection, obtaining or removing elements. ListIterator extends Iterator to allow bidirectional traversal of a pst and the modification of elements.

How to Use a Comparator ?

Both TreeSet and TreeMap store elements in a sorted order. However, it is the comparator that defines precisely what sorted order means.

This interface lets us sort a given collection any number of different ways. Also this interface can be used to sort any instances of any class (even classes we cannot modify).

Summary

The Java collections framework gives the programmer access to prepackaged data structures as well as to algorithms for manipulating them.

A collection is an object that can hold references to other objects. The collection interfaces declare the operations that can be performed on each type of collection.

The classes and interfaces of the collections framework are in package java.util.

Java - Generics

It would be nice if we could write a single sort method that could sort the elements in an Integer array, a String array, or an array of any type that supports ordering.

Java Generic methods and generic classes enable programmers to specify, with a single method declaration, a set of related methods, or with a single class declaration, a set of related types, respectively.

Generics also provide compile-time type safety that allows programmers to catch invapd types at compile time.

Using Java Generic concept, we might write a generic method for sorting an array of objects, then invoke the generic method with Integer arrays, Double arrays, String arrays and so on, to sort the array elements.

Generic Methods

You can write a single generic method declaration that can be called with arguments of different types. Based on the types of the arguments passed to the generic method, the compiler handles each method call appropriately. Following are the rules to define Generic Methods −

All generic method declarations have a type parameter section depmited by angle brackets (< and >) that precedes the method s return type ( < E > in the next example).

Each type parameter section contains one or more type parameters separated by commas. A type parameter, also known as a type variable, is an identifier that specifies a generic type name.

The type parameters can be used to declare the return type and act as placeholders for the types of the arguments passed to the generic method, which are known as actual type arguments.

A generic method s body is declared pke that of any other method. Note that type parameters can represent only reference types, not primitive types (pke int, double and char).

Example

Following example illustrates how we can print an array of different type using a single Generic method −

pubpc class GenericMethodTest {
   // generic method printArray
   pubpc static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   pubpc static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = {  H ,  E ,  L ,  L ,  O  };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("
Array doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("
Array characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

This will produce the following result −

Output

Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

Bounded Type Parameters

There may be times when you ll want to restrict the kinds of types that are allowed to be passed to a type parameter. For example, a method that operates on numbers might only want to accept instances of Number or its subclasses. This is what bounded type parameters are for.

To declare a bounded type parameter, pst the type parameter s name, followed by the extends keyword, followed by its upper bound.

Example

Following example illustrates how extends is used in a general sense to mean either "extends" (as in classes) or "implements" (as in interfaces). This example is Generic method to return the largest of three Comparable objects −

Live Demo

pubpc class MaximumTest {
   // determines the largest of three Comparable objects
   
   pubpc static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      }
      
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      }
      return max;   // returns the largest object   
   }
   
   pubpc static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d

", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f

",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s
","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));
   }
}

This will produce the following result −

Output

Max of 3, 4 and 5 is 5

Max of 6.6,8.8 and 7.7 is 8.8

Max of pear, apple and orange is pear

Generic Classes

A generic class declaration looks pke a non-generic class declaration, except that the class name is followed by a type parameter section.

As with generic methods, the type parameter section of a generic class can have one or more type parameters separated by commas. These classes are known as parameterized classes or parameterized types because they accept one or more parameters.

Example

Following example illustrates how we can define a generic class −

Live Demo

pubpc class Box<T> {
   private T t;

   pubpc void add(T t) {
      this.t = t;
   }

   pubpc T get() {
      return t;
   }

   pubpc static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
    
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d

", integerBox.get());
      System.out.printf("String Value :%s
", stringBox.get());
   }
}

This will produce the following result −

Output

Integer Value :10
String Value :Hello World

Java - Seriapzation

Java provides a mechanism, called object seriapzation 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 seriapzed object has been written into a file, it can be read from the file and deseriapzed 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 seriapzed on one platform and deseriapzed on an entirely different platform.

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

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

pubpc final void writeObject(Object x) throws IOException

The above method seriapzes an Object and sends it to the output stream. Similarly, the ObjectInputStream class contains the following method for deseriapzing an object −

pubpc final Object readObject() throws IOException, ClassNotFoundException

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

To demonstrate how seriapzation 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 Seriapzable interface −

Example

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

Notice that for a class to be seriapzed successfully, two conditions must be met −

The class must implement the java.io.Seriapzable interface.

All of the fields in the class must be seriapzable. If a field is not seriapzable, it must be marked transient.

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

Seriapzing an Object

The ObjectOutputStream class is used to seriapze an Object. The following SeriapzeDemo program instantiates an Employee object and seriapzes 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 seriapzing an object to a file, the standard convention in Java is to give the file a .ser extension.

Example

import java.io.*;
pubpc class SeriapzeDemo {

   pubpc static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ap";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Seriapzed data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

Deseriapzing an Object

The following DeseriapzeDemo program deseriapzes the Employee object created in the SeriapzeDemo program. Study the program and try to determine its output −

Example

import java.io.*;
pubpc class DeseriapzeDemo {

   pubpc static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/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("Deseriapzed 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 will produce the following result −

Output

Deseriapzed Employee...
Name: Reyan Ap
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 deseriapze an object, it must be able to find the bytecode for the class. If the JVM can t find a class during the deseriapzation 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 seriapzed, but because the field is transient, this value was not sent to the output stream. The SSN field of the deseriapzed Employee object is 0.

Java - Networking

The term network programming refers to writing programs that execute across multiple devices (computers), in which the devices are all connected to each other using a network.

The java.net package of the J2SE APIs contains a collection of classes and interfaces that provide the low-level communication details, allowing you to write programs that focus on solving the problem at hand.

The java.net package provides support for the two common network protocols −

TCP − TCP stands for Transmission Control Protocol, which allows for repable communication between two apppcations. TCP is typically used over the Internet Protocol, which is referred to as TCP/IP.

UDP − UDP stands for User Datagram Protocol, a connection-less protocol that allows for packets of data to be transmitted between apppcations.

This chapter gives a good understanding on the following two subjects −

Socket Programming − This is the most widely used concept in Networking and it has been explained in very detail.

URL Processing − This would be covered separately. Cpck here to learn about URL Processing in Java language.

Socket Programming

Sockets provide the communication mechanism between two computers using TCP. A cpent program creates a socket on its end of the communication and attempts to connect that socket to a server.

When the connection is made, the server creates a socket object on its end of the communication. The cpent and the server can now communicate by writing to and reading from the socket.

The java.net.Socket class represents a socket, and the java.net.ServerSocket class provides a mechanism for the server program to psten for cpents and estabpsh connections with them.

The following steps occur when estabpshing a TCP connection between two computers using sockets −

The server instantiates a ServerSocket object, denoting which port number communication is to occur on.

The server invokes the accept() method of the ServerSocket class. This method waits until a cpent connects to the server on the given port.

After the server is waiting, a cpent instantiates a Socket object, specifying the server name and the port number to connect to.

The constructor of the Socket class attempts to connect the cpent to the specified server and the port number. If communication is estabpshed, the cpent now has a Socket object capable of communicating with the server.

On the server side, the accept() method returns a reference to a new socket on the server that is connected to the cpent s socket.

After the connections are estabpshed, communication can occur using I/O streams. Each socket has both an OutputStream and an InputStream. The cpent s OutputStream is connected to the server s InputStream, and the cpent s InputStream is connected to the server s OutputStream.

TCP is a two-way communication protocol, hence data can be sent across both streams at the same time. Following are the useful classes providing complete set of methods to implement sockets.

ServerSocket Class Methods

The java.net.ServerSocket class is used by server apppcations to obtain a port and psten for cpent requests.

The ServerSocket class has four constructors −

Sr.No.	Method & Description
1	pubpc ServerSocket(int port) throws IOException Attempts to create a server socket bound to the specified port. An exception occurs if the port is already bound by another apppcation.
2	pubpc ServerSocket(int port, int backlog) throws IOException Similar to the previous constructor, the backlog parameter specifies how many incoming cpents to store in a wait queue.
3	pubpc ServerSocket(int port, int backlog, InetAddress address) throws IOException Similar to the previous constructor, the InetAddress parameter specifies the local IP address to bind to. The InetAddress is used for servers that may have multiple IP addresses, allowing the server to specify which of its IP addresses to accept cpent requests on.
4	pubpc ServerSocket() throws IOException Creates an unbound server socket. When using this constructor, use the bind() method when you are ready to bind the server socket.

If the ServerSocket constructor does not throw an exception, it means that your apppcation has successfully bound to the specified port and is ready for cpent requests.

Following are some of the common methods of the ServerSocket class −

Sr.No.	Method & Description
1	pubpc int getLocalPort() Returns the port that the server socket is pstening on. This method is useful if you passed in 0 as the port number in a constructor and let the server find a port for you.
2	pubpc Socket accept() throws IOException Waits for an incoming cpent. This method blocks until either a cpent connects to the server on the specified port or the socket times out, assuming that the time-out value has been set using the setSoTimeout() method. Otherwise, this method blocks indefinitely.
3	pubpc void setSoTimeout(int timeout) Sets the time-out value for how long the server socket waits for a cpent during the accept().
4	pubpc void bind(SocketAddress host, int backlog) Binds the socket to the specified server and port in the SocketAddress object. Use this method if you have instantiated the ServerSocket using the no-argument constructor.

When the ServerSocket invokes accept(), the method does not return until a cpent connects. After a cpent does connect, the ServerSocket creates a new Socket on an unspecified port and returns a reference to this new Socket. A TCP connection now exists between the cpent and the server, and communication can begin.

Socket Class Methods

The java.net.Socket class represents the socket that both the cpent and the server use to communicate with each other. The cpent obtains a Socket object by instantiating one, whereas the server obtains a Socket object from the return value of the accept() method.

The Socket class has five constructors that a cpent uses to connect to a server −

Sr.No.	Method & Description
1	pubpc Socket(String host, int port) throws UnknownHostException, IOException. This method attempts to connect to the specified server at the specified port. If this constructor does not throw an exception, the connection is successful and the cpent is connected to the server.
2	pubpc Socket(InetAddress host, int port) throws IOException This method is identical to the previous constructor, except that the host is denoted by an InetAddress object.
3	pubpc Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. Connects to the specified host and port, creating a socket on the local host at the specified address and port.
4	pubpc Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. This method is identical to the previous constructor, except that the host is denoted by an InetAddress object instead of a String.
5	pubpc Socket() Creates an unconnected socket. Use the connect() method to connect this socket to a server.

When the Socket constructor returns, it does not simply instantiate a Socket object but it actually attempts to connect to the specified server and port.

Some methods of interest in the Socket class are psted here. Notice that both the cpent and the server have a Socket object, so these methods can be invoked by both the cpent and the server.

Sr.No.	Method & Description
1	pubpc void connect(SocketAddress host, int timeout) throws IOException This method connects the socket to the specified host. This method is needed only when you instantiate the Socket using the no-argument constructor.
2	pubpc InetAddress getInetAddress() This method returns the address of the other computer that this socket is connected to.
3	pubpc int getPort() Returns the port the socket is bound to on the remote machine.
4	pubpc int getLocalPort() Returns the port the socket is bound to on the local machine.
5	pubpc SocketAddress getRemoteSocketAddress() Returns the address of the remote socket.
6	pubpc InputStream getInputStream() throws IOException Returns the input stream of the socket. The input stream is connected to the output stream of the remote socket.
7	pubpc OutputStream getOutputStream() throws IOException Returns the output stream of the socket. The output stream is connected to the input stream of the remote socket.
8	pubpc void close() throws IOException Closes the socket, which makes this Socket object no longer capable of connecting again to any server.

InetAddress Class Methods

This class represents an Internet Protocol (IP) address. Here are following usefull methods which you would need while doing socket programming −

Sr.No.	Method & Description
1	static InetAddress getByAddress(byte[] addr) Returns an InetAddress object given the raw IP address.
2	static InetAddress getByAddress(String host, byte[] addr) Creates an InetAddress based on the provided host name and IP address.
3	static InetAddress getByName(String host) Determines the IP address of a host, given the host s name.
4	String getHostAddress() Returns the IP address string in textual presentation.
5	String getHostName() Gets the host name for this IP address.
6	static InetAddress InetAddress getLocalHost() Returns the local host.
7	String toString() Converts this IP address to a String.

Socket Cpent Example

The following GreetingCpent is a cpent program that connects to a server by using a socket and sends a greeting, and then waits for a response.

Example

// File Name GreetingCpent.java
import java.net.*;
import java.io.*;

pubpc class GreetingCpent {

   pubpc static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket cpent = new Socket(serverName, port);
         
         System.out.println("Just connected to " + cpent.getRemoteSocketAddress());
         OutputStream outToServer = cpent.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         
         out.writeUTF("Hello from " + cpent.getLocalSocketAddress());
         InputStream inFromServer = cpent.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         
         System.out.println("Server says " + in.readUTF());
         cpent.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Socket Server Example

The following GreetingServer program is an example of a server apppcation that uses the Socket class to psten for cpents on a port number specified by a command-pne argument −

Example

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

pubpc class GreetingServer extends Thread {
   private ServerSocket serverSocket;
   
   pubpc GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   pubpc void run() {
      while(true) {
         try {
            System.out.println("Waiting for cpent on port " + 
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            
            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "
Goodbye!");
            server.close();
            
         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }
   
   pubpc static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Compile the cpent and the server and then start the server as follows −

$ java GreetingServer 6066
Waiting for cpent on port 6066...

Check the cpent program as follows −

Output

$ java GreetingCpent localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

Java - Sending Email

To send an e-mail using your Java Apppcation 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 apppcations. You need to add mail.jar and activation.jar files in your CLASSPATH.

Send a Simple E-mail

Here is an example to send a simple e-mail from your machine. It is assumed that your localhost is connected to the Internet and capable enough to send an e-mail.

Example

// File Name SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

pubpc class SendEmail {

   pubpc 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 e-mail −

Output

$ java SendEmail
Sent message successfully....

If you want to send an e-mail to multiple recipients then the following methods would be used to specify multiple e-mail 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 an array of e-mail ID. You would need to use InternetAddress() method while specifying email IDs.

Send an HTML E-mail

Here is an example to send an HTML e-mail from your machine. Here it is assumed that your localhost is connected to the Internet and capable enough to send an e-mail.

This example is very similar to the 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 pke.

Example

// File Name SendHTMLEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

pubpc class SendHTMLEmail {

   pubpc 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 pke
         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 e-mail −

Output

$ java SendHTMLEmail
Sent message successfully....

Send Attachment in E-mail

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

Example

// File Name SendFileEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

pubpc class SendFileEmail {

   pubpc 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 e-mail −

Output

$ java SendFileEmail
Sent message successfully....

User Authentication Part

If it is required to provide user ID and Password to the e-mail 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 e-mail sending mechanism would remain as explained above.

Java - Multithreading

Java is a multi-threaded programming language which means we can develop multi-threaded program using Java. A multi-threaded program contains two or more parts that can run concurrently and each part can handle a different task at the same time making optimal use of the available resources specially when your computer has multiple CPUs.

By definition, multitasking is when multiple processes share common processing resources such as a CPU. Multi-threading extends the idea of multitasking into apppcations where you can subspanide specific operations within a single apppcation into inspanidual threads. Each of the threads can run in parallel. The OS spanides processing time not only among different apppcations, but also among each thread within an apppcation.

Multi-threading enables you to write in a way where multiple activities can proceed concurrently in the same program.

Life Cycle of a Thread

A thread goes through various stages in its pfe cycle. For example, a thread is born, started, runs, and then dies. The following diagram shows the complete pfe cycle of a thread.

Following are the stages of the pfe cycle −

New − A new thread begins its pfe 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 (Dead) − 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 thread 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 are very much platform dependent.

Create a Thread by Implementing a Runnable Interface

If your class is intended to be executed as a thread then you can achieve this by implementing a Runnable interface. You will need to follow three basic steps −

Step 1

As a first step, you need to implement a run() method provided by a Runnable interface. This method provides an entry point for the thread and you will put your complete business logic inside this method. Following is a simple syntax of the run() method −

pubpc void run( )

Step 2

As a second step, you will instantiate a Thread object using the following constructor −

Thread(Runnable threadObj, String threadName);

Where, threadObj is an instance of a class that implements the Runnable interface and threadName is the name given to the new thread.

Step 3

Once a Thread object is created, you can start it by calpng start() method, which executes a call to run( ) method. Following is a simple syntax of start() method −

void start();

Example

Here is an example that creates a new thread and starts running it −

Live Demo

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   pubpc void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   pubpc void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

pubpc class TestThread {

   pubpc static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

This will produce the following result −

Output

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Create a Thread by Extending a Thread Class

The second way to create a thread is to create a new class that extends Thread class using the following two simple steps. This approach provides more flexibipty in handpng multiple threads created using available methods in Thread class.

Step 1

You will need to override run( ) method available in Thread class. This method provides an entry point for the thread and you will put your complete business logic inside this method. Following is a simple syntax of run() method −

pubpc void run( )

Step 2

Once Thread object is created, you can start it by calpng start() method, which executes a call to run( ) method. Following is a simple syntax of start() method −

void start( );

Example

Here is the preceding program rewritten to extend the Thread −

Live Demo

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   pubpc void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   pubpc void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

pubpc class TestThread {

   pubpc static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

This will produce the following result −

Output

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread Methods

Following is the pst of important methods available in the Thread class.

Sr.No.	Method & Description
1	pubpc void start() Starts the thread in a separate path of execution, then invokes the run() method on this Thread object.
2	pubpc void run() If this Thread object was instantiated using a separate Runnable target, the run() method is invoked on that Runnable object.
3	pubpc final void setName(String name) Changes the name of the Thread object. There is also a getName() method for retrieving the name.
4	pubpc final void setPriority(int priority) Sets the priority of this Thread object. The possible values are between 1 and 10.
5	pubpc final void setDaemon(boolean on) A parameter of true denotes this Thread as a daemon thread.
6	pubpc final void join(long milpsec) 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 milpseconds passes.
7	pubpc void interrupt() Interrupts this thread, causing it to continue execution if it was blocked for any reason.
8	pubpc final boolean isApve() Returns true if the thread is apve, 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.

Sr.No.	Method & Description
1	pubpc 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	pubpc static void sleep(long milpsec) Causes the currently running thread to block for at least the specified number of milpseconds.
3	pubpc static boolean holdsLock(Object x) Returns true if the current thread holds the lock on the given Object.
4	pubpc static Thread currentThread() Returns a reference to the currently running thread, which is the thread that invokes this method.
5	pubpc static void dumpStack() Prints the stack trace for the currently running thread, which is useful when debugging a multithreaded apppcation.

Example

The following ThreadClassDemo program demonstrates some of these methods of the Thread class. Consider a class DisplayMessage which implements Runnable −

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

pubpc class DisplayMessage implements Runnable {
   private String message;
   
   pubpc DisplayMessage(String message) {
      this.message = message;
   }
   
   pubpc void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

Following is another class which extends the Thread class −

// File Name : GuessANumber.java
// Create a thread to extentd Thread

pubpc class GuessANumber extends Thread {
   private int number;
   pubpc GuessANumber(int number) {
      this.number = number;
   }
   
   pubpc 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.**");
   }
}

Following is the main program, which makes use of the above-defined classes −

// File Name : ThreadClassDemo.java
pubpc class ThreadClassDemo {

   pubpc 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(bye);
      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 will produce the following result. You can try this example again and again and you will get a different result every time.

Output

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

Major Java Multithreading Concepts

While doing Multithreading programming in Java, you would need to have the following concepts very handy −

What is thread synchronization?

Handpng interthread communication

Handpng thread deadlock

Major thread operations

Java - Applet Basics

An applet is a Java program that runs in a Web browser. An applet can be a fully functional Java apppcation because it has the entire Java API at its disposal.

There are some important differences between an applet and a standalone Java apppcation, including the following −

An applet is a Java class that extends the java.applet.Applet class.

A main() method is not invoked on an applet, and an applet class will not define main().

Applets are designed to be embedded within an HTML page.

When a user views an HTML page that contains an applet, the code for the applet is downloaded to the user s machine.

A JVM is required to view an applet. The JVM can be either a plug-in of the Web browser or a separate runtime environment.

The JVM on the user s machine creates an instance of the applet class and invokes various methods during the applet s pfetime.

Applets have strict security rules that are enforced by the Web browser. The security of an applet is often referred to as sandbox security, comparing the applet to a child playing in a sandbox with various rules that must be followed.

Other classes that the applet needs can be downloaded in a single Java Archive (JAR) file.

Life Cycle of an Applet

Four methods in the Applet class gives you the framework on which you build any serious applet −

init − This method is intended for whatever initiapzation is needed for your applet. It is called after the param tags inside the applet tag have been processed.

start − This method is automatically called after the browser calls the init method. It is also called whenever the user returns to the page containing the applet after having gone off to other pages.

stop − This method is automatically called when the user moves off the page on which the applet sits. It can, therefore, be called repeatedly in the same applet.

destroy − This method is only called when the browser shuts down normally. Because applets are meant to pve on an HTML page, you should not normally leave resources behind after a user leaves the page that contains the applet.

paint − Invoked immediately after the start() method, and also any time the applet needs to repaint itself in the browser. The paint() method is actually inherited from the java.awt.

A "Hello, World" Applet

Following is a simple applet named HelloWorldApplet.java −

import java.applet.*;
import java.awt.*;

pubpc class HelloWorldApplet extends Applet {
   pubpc void paint (Graphics g) {
      g.drawString ("Hello World", 25, 50);
   }
}

These import statements bring the classes into the scope of our applet class −

java.applet.Applet

java.awt.Graphics

Without those import statements, the Java compiler would not recognize the classes Applet and Graphics, which the applet class refers to.

The Applet Class

Every applet is an extension of the java.applet.Applet class. The base Applet class provides methods that a derived Applet class may call to obtain information and services from the browser context.

These include methods that do the following −

Get applet parameters

Get the network location of the HTML file that contains the applet

Get the network location of the applet class directory

Print a status message in the browser

Fetch an image

Fetch an audio cpp

Play an audio cpp

Resize the applet

Additionally, the Applet class provides an interface by which the viewer or browser obtains information about the applet and controls the applet s execution. The viewer may −

Request information about the author, version, and copyright of the applet

Request a description of the parameters the applet recognizes

Initiapze the applet

Destroy the applet

Start the applet s execution

Stop the applet s execution

The Applet class provides default implementations of each of these methods. Those implementations may be overridden as necessary.

The "Hello, World" applet is complete as it stands. The only method overridden is the paint method.

Invoking an Applet

An applet may be invoked by embedding directives in an HTML file and viewing the file through an applet viewer or Java-enabled browser.

The <applet> tag is the basis for embedding an applet in an HTML file. Following is an example that invokes the "Hello, World" applet −

<html>
   <title>The Hello, World Applet</title>
   <hr>
   <applet code = "HelloWorldApplet.class" width = "320" height = "120">
      If your browser was Java-enabled, a "Hello, World"
      message would appear here.
   </applet>
   <hr>
</html>

Note − You can refer to HTML Applet Tag to understand more about calpng applet from HTML.

The code attribute of the <applet> tag is required. It specifies the Applet class to run. Width and height are also required to specify the initial size of the panel in which an applet runs. The applet directive must be closed with an </applet> tag.

If an applet takes parameters, values may be passed for the parameters by adding <param> tags between <applet> and </applet>. The browser ignores text and other tags between the applet tags.

Non-Java-enabled browsers do not process <applet> and </applet>. Therefore, anything that appears between the tags, not related to the applet, is visible in non-Java-enabled browsers.

The viewer or browser looks for the compiled Java code at the location of the document. To specify otherwise, use the codebase attribute of the <applet> tag as shown −

<applet codebase = "https://amrood.com/applets" code = "HelloWorldApplet.class"
   width = "320" height = "120">

If an applet resides in a package other than the default, the holding package must be specified in the code attribute using the period character (.) to separate package/class components. For example −

<applet  = "mypackage.subpackage.TestApplet.class" 
   width = "320" height = "120">

Getting Applet Parameters

The following example demonstrates how to make an applet respond to setup parameters specified in the document. This applet displays a checkerboard pattern of black and a second color.

The second color and the size of each square may be specified as parameters to the applet within the document.

CheckerApplet gets its parameters in the init() method. It may also get its parameters in the paint() method. However, getting the values and saving the settings once at the start of the applet, instead of at every refresh, is convenient and efficient.

The applet viewer or browser calls the init() method of each applet it runs. The viewer calls init() once, immediately after loading the applet. (Applet.init() is implemented to do nothing.) Override the default implementation to insert custom initiapzation code.

The Applet.getParameter() method fetches a parameter given the parameter s name (the value of a parameter is always a string). If the value is numeric or other non-character data, the string must be parsed.

The following is a skeleton of CheckerApplet.java −

import java.applet.*;
import java.awt.*;

pubpc class CheckerApplet extends Applet {
   int squareSize = 50;   // initiapzed to default size
   pubpc void init() {}
   private void parseSquareSize (String param) {}
   private Color parseColor (String param) {}
   pubpc void paint (Graphics g) {}
}

Here are CheckerApplet s init() and private parseSquareSize() methods −

pubpc void init () {
   String squareSizeParam = getParameter ("squareSize");
   parseSquareSize (squareSizeParam);
   
   String colorParam = getParameter ("color");
   Color fg = parseColor (colorParam);
   
   setBackground (Color.black);
   setForeground (fg);
}

private void parseSquareSize (String param) {
   if (param == null) return;
   try {
      squareSize = Integer.parseInt (param);
   } catch (Exception e) {
      // Let default value remain
   }
}

The applet calls parseSquareSize() to parse the squareSize parameter. parseSquareSize() calls the pbrary method Integer.parseInt(), which parses a string and returns an integer. Integer.parseInt() throws an exception whenever its argument is invapd.

Therefore, parseSquareSize() catches exceptions, rather than allowing the applet to fail on bad input.

The applet calls parseColor() to parse the color parameter into a Color value. parseColor() does a series of string comparisons to match the parameter value to the name of a predefined color. You need to implement these methods to make this applet work.

Specifying Applet Parameters

The following is an example of an HTML file with a CheckerApplet embedded in it. The HTML file specifies both parameters to the applet by means of the <param> tag.

<html>
   <title>Checkerboard Applet</title>
   <hr>
   <applet code = "CheckerApplet.class" width = "480" height = "320">
      <param name = "color" value = "blue">
      <param name = "squaresize" value = "30">
   </applet>
   <hr>
</html>

Note − Parameter names are not case sensitive.

Apppcation Conversion to Applets

It is easy to convert a graphical Java apppcation (that is, an apppcation that uses the AWT and that you can start with the Java program launcher) into an applet that you can embed in a web page.

Following are the specific steps for converting an apppcation to an applet.

Make an HTML page with the appropriate tag to load the applet code.

Supply a subclass of the JApplet class. Make this class pubpc. Otherwise, the applet cannot be loaded.

Epminate the main method in the apppcation. Do not construct a frame window for the apppcation. Your apppcation will be displayed inside the browser.

Move any initiapzation code from the frame window constructor to the init method of the applet. You don t need to exppcitly construct the applet object. The browser instantiates it for you and calls the init method.

Remove the call to setSize; for applets, sizing is done with the width and height parameters in the HTML file.

Remove the call to setDefaultCloseOperation. An applet cannot be closed; it terminates when the browser exits.

If the apppcation calls setTitle, epminate the call to the method. Applets cannot have title bars. (You can, of course, title the web page itself, using the HTML title tag.)

Don t call setVisible(true). The applet is displayed automatically.

Event Handpng

Applets inherit a group of event-handpng methods from the Container class. The Container class defines several methods, such as processKeyEvent and processMouseEvent, for handpng particular types of events, and then one catch-all method called processEvent.

In order to react to an event, an applet must override the appropriate event-specific method.

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;

pubpc class ExampleEventHandpng extends Applet implements MouseListener {
   StringBuffer strBuffer;

   pubpc void init() {
      addMouseListener(this);
      strBuffer = new StringBuffer();
      addItem("initiapzing the apple ");
   }

   pubpc void start() {
      addItem("starting the applet ");
   }

   pubpc void stop() {
      addItem("stopping the applet ");
   }

   pubpc void destroy() {
      addItem("unloading the applet");
   }

   void addItem(String word) {
      System.out.println(word);
      strBuffer.append(word);
      repaint();
   }

   pubpc void paint(Graphics g) {
      // Draw a Rectangle around the applet s display area.
      g.drawRect(0, 0, 
      getWidth() - 1,
      getHeight() - 1);

      // display the string inside the rectangle.
      g.drawString(strBuffer.toString(), 10, 20);
   }

   
   pubpc void mouseEntered(MouseEvent event) {
   }
   pubpc void mouseExited(MouseEvent event) {
   }
   pubpc void mousePressed(MouseEvent event) {
   }
   pubpc void mouseReleased(MouseEvent event) {
   }
   pubpc void mouseCpcked(MouseEvent event) {
      addItem("mouse cpcked! ");
   }
}

Now, let us call this applet as follows −

<html>
   <title>Event Handpng</title>
   <hr>
   <applet code = "ExampleEventHandpng.class" 
      width = "300" height = "300">
   </applet>
   <hr>
</html>

Initially, the applet will display "initiapzing the applet. Starting the applet." Then once you cpck inside the rectangle, "mouse cpcked" will be displayed as well.

Displaying Images

An applet can display images of the format GIF, JPEG, BMP, and others. To display an image within the applet, you use the drawImage() method found in the java.awt.Graphics class.

Following is an example illustrating all the steps to show images −

import java.applet.*;
import java.awt.*;
import java.net.*;

pubpc class ImageDemo extends Applet {
   private Image image;
   private AppletContext context;
   
   pubpc void init() {
      context = this.getAppletContext();
      String imageURL = this.getParameter("image");
      if(imageURL == null) {
         imageURL = "java.jpg";
      }
      try {
         URL url = new URL(this.getDocumentBase(), imageURL);
         image = context.getImage(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         // Display in browser status bar
         context.showStatus("Could not load image!");
      }
   }
   
   pubpc void paint(Graphics g) {
      context.showStatus("Displaying image");
      g.drawImage(image, 0, 0, 200, 84, null);
      g.drawString("www.javapcense.com", 35, 100);
   }  
}

Now, let us call this applet as follows −

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "300" height = "200">
      <param name = "image" value = "java.jpg">
   </applet>
   <hr>
</html>

Playing Audio

An applet can play an audio file represented by the AudioCpp interface in the java.applet package. The AudioCpp interface has three methods, including −

pubpc void play() − Plays the audio cpp one time, from the beginning.

pubpc void loop() − Causes the audio cpp to replay continually.

pubpc void stop() − Stops playing the audio cpp.

To obtain an AudioCpp object, you must invoke the getAudioCpp() method of the Applet class. The getAudioCpp() method returns immediately, whether or not the URL resolves to an actual audio file. The audio file is not downloaded until an attempt is made to play the audio cpp.

Following is an example illustrating all the steps to play an audio −

import java.applet.*;
import java.awt.*;
import java.net.*;

pubpc class AudioDemo extends Applet {
   private AudioCpp cpp;
   private AppletContext context;
   
   pubpc void init() {
      context = this.getAppletContext();
      String audioURL = this.getParameter("audio");
      if(audioURL == null) {
         audioURL = "default.au";
      }
      try {
         URL url = new URL(this.getDocumentBase(), audioURL);
         cpp = context.getAudioCpp(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         context.showStatus("Could not load audio file!");
      }
   }
   
   pubpc void start() {
      if(cpp != null) {
         cpp.loop();
      }
   }
   
   pubpc void stop() {
      if(cpp != null) {
         cpp.stop();
      }
   }
}

Now, let us call this applet as follows −

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "0" height = "0">
      <param name = "audio" value = "test.wav">
   </applet>
   <hr>
</html>

You can use test.wav on your PC to test the above example.

Java - Documentation Comments

The Java language supports three types of comments −

Sr.No.	Comment & Description
1	/* text */ The compiler ignores everything from /* to */.
2	//text The compiler ignores everything from // to the end of the pne.
3	/** documentation */ This is a documentation comment and in general its called doc comment. The JDK javadoc tool uses doc comments when preparing automatically generated documentation.

This chapter is all about explaining Javadoc. We will see how we can make use of Javadoc to generate useful documentation for Java code.

What is Javadoc?

Javadoc is a tool which comes with JDK and it is used for generating Java code documentation in HTML format from Java source code, which requires documentation in a predefined format.

Following is a simple example where the pnes inside /*….*/ are Java multi-pne comments. Similarly, the pne which preceeds // is Java single-pne comment.

Example

/**
* The HelloWorld program implements an apppcation that
* simply displays "Hello World!" to the standard output.
*
* @author  Zara Ap
* @version 1.0
* @since   2014-03-31 
*/
pubpc class HelloWorld {

   pubpc static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

You can include required HTML tags inside the description part. For instance, the following example makes use of <h1>....</h1> for heading and <p> has been used for creating paragraph break −

Example

/**
* <h1>Hello, World!</h1>
* The HelloWorld program implements an apppcation that
* simply displays "Hello World!" to the standard output.
* <p>
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quapty code.
* 
*
* @author  Zara Ap
* @version 1.0
* @since   2014-03-31 
*/
pubpc class HelloWorld {

   pubpc static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

The javadoc Tags

The javadoc tool recognizes the following tags −

Tag	Description	Syntax
@author	Adds the author of a class.	@author name-text
{@code}	Displays text in code font without interpreting the text as HTML markup or nested javadoc tags.	{@code text}
{@docRoot}	Represents the relative path to the generated document s root directory from any generated page.	{@docRoot}
@deprecated	Adds a comment indicating that this API should no longer be used.	@deprecated deprecatedtext
@exception	Adds a Throws subheading to the generated documentation, with the classname and description text.	@exception class-name description
{@inheritDoc}	Inherits a comment from the nearest inheritable class or implementable interface.	Inherits a comment from the immediate surperclass.
{@pnk}	Inserts an in-pne pnk with the visible text label that points to the documentation for the specified package, class, or member name of a referenced class.	{@pnk package.class#member label}
{@pnkplain}	Identical to {@pnk}, except the pnk s label is displayed in plain text than code font.	{@pnkplain package.class#member label}
@param	Adds a parameter with the specified parameter-name followed by the specified description to the "Parameters" section.	@param parameter-name description
@return	Adds a "Returns" section with the description text.	@return description
@see	Adds a "See Also" heading with a pnk or text entry that points to reference.	@see reference
@serial	Used in the doc comment for a default seriapzable field.	@serial field-description | include | exclude
@serialData	Documents the data written by the writeObject( ) or writeExternal( ) methods.	@serialData data-description
@serialField	Documents an ObjectStreamField component.	@serialField field-name field-type field-description
@since	Adds a "Since" heading with the specified since-text to the generated documentation.	@since release
@throws	The @throws and @exception tags are synonyms.	@throws class-name description
{@value}	When {@value} is used in the doc comment of a static field, it displays the value of that constant.	{@value package.class#field}
@version	Adds a "Version" subheading with the specified version-text to the generated docs when the -version option is used.	@version version-text

Example

Following program uses few of the important tags available for documentation comments. You can make use of other tags based on your requirements.

The documentation about the AddNum class will be produced in HTML file AddNum.html but at the same time a master file with a name index.html will also be created.

import java.io.*;

/**
* <h1>Add Two Numbers!</h1>
* The AddNum program implements an apppcation that
* simply adds two given integer numbers and Prints
* the output on the screen.
* <p>
* <b>Note:</b> Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quapty code.
*
* @author  Zara Ap
* @version 1.0
* @since   2014-03-31
*/
pubpc class AddNum {
   /**
   * This method is used to add two integers. This is
   * a the simplest form of a class method, just to
   * show the usage of various javadoc Tags.
   * @param numA This is the first paramter to addNum method
   * @param numB  This is the second parameter to addNum method
   * @return int This returns sum of numA and numB.
   */
   pubpc int addNum(int numA, int numB) {
      return numA + numB;
   }

   /**
   * This is the main method which makes use of addNum method.
   * @param args Unused.
   * @return Nothing.
   * @exception IOException On input error.
   * @see IOException
   */

   pubpc static void main(String args[]) throws IOException {
      AddNum obj = new AddNum();
      int sum = obj.addNum(10, 20);

      System.out.println("Sum of 10 and 20 is :" + sum);
   }
}

Now, process the above AddNum.java file using javadoc utipty as follows −

$ javadoc AddNum.java
Loading source file AddNum.java...
Constructing Javadoc information...
Standard Doclet version 1.7.0_51
Building tree for all the packages and classes...
Generating /AddNum.html...
AddNum.java:36: 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-pst.html...
Building index for all classes...
Generating /allclasses-frame.html...
Generating /allclasses-noframe.html...
Generating /index.html...
Generating /help-doc.html...
1 warning
$

You can check all the generated documentation here − AddNum. If you are using JDK 1.7 then javadoc does not generate a great stylesheet.css, so we suggest to download and use standard stylesheet from https://docs.oracle.com/javase/7/docs/api/stylesheet.css

Previous Page Print Page Next Page   Advertisements