A temporary file is a normal file that is created to hold the data temporarily. Efficient memory management is one of the important aspect of any normal application. Creation of temporary files and effective use of them help an application to free the memory in need for other purpose.

A temporary file can be created depending on certain condition and can be closed and deleted depending on some condition. For an example, lets assume we can upload and install a plug-in(a file) on an application. This file can be uploaded as a temporary file in a system defined temporary directory and can be installed from there. On a successful installation completion the temp file can be deleted permanently from the temporary directory.

Lets have a look at the following example ,

Listing 1 : Creating the Temporary file

package com.etechGuide.java.features;

import java.io.File;
import java.io.IOException;

public class TempCreation {
	public static void main(String[] args) {
		try {
			File tempFile = File.createTempFile("mailTogoa", ".ddd");
			System.out.print("Created temporary file with name ");
			System.out.println(tempFile.getAbsolutePath());
			tempFile.deleteOnExit();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

The Line number 9 creates a temporary file. Java IO provides an API like ,
createTempFile(String prefix, String suffix) ;
-Creates an empty file in the default temporary-file directory, using the given prefix and suffix to generate its name.
In the above programming example , we have used the API to create a temporary file whose prefix is mailTogoa and suffix is .ddd. This file will be created under the system defined temporary directory.
Java IO provides another API to create a temporary file . With the help of this API , you can create a temporary file in user defined location. The method look like this ,
createTempFile(String prefix, String suffix, File directory)
-Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name.
Both the above methods are public static method in the java.io.File class.

Line number 12 we call the deleteOnExit() method so that the temporary file can be deleted on JVM exit.

Last thing to be mentioned is , how to get the temporary file location pragmatically. Have a look at the following code list

Listing 2 : Detect the Temporary Directory

package com.etechGuide.java.features;

public class DetectTempDirectory {

	private static final String SYSTEM_PROPERTY_TEMP_FOLDER = "java.io.tmpdir";

	public static void main(String[] args) {
		String sTempFolder = System.getProperty(SYSTEM_PROPERTY_TEMP_FOLDER);
		System.out.println(sTempFolder);
	}
}

java.io.tmpdir property has the operating system specific temporary directory location. In the above example , we have read the property and printed on console.

But , how do you execute a thread successfully ? Take an example of the class below. This is a thread for installation purpose.

Listing 1 : Install Thread

public class InstallThread extends Thread {

	public InstallThread(String threadName){
		super(threadName);
	}

	@Override
	public void run() {
		super.run();
		System.out.println("installing......");
	}

}

The above class does not install anything but gives you an impression of how to create a basic thread. You must have to give an implementation of the run() method.

Have a look at the following class where the instance of the install thread will be created and started.

Listing 2 : Start the Install Thread

public class InstallThreadTest {

	public static void main(String[] args) {
		InstallThread installThread = new InstallThread("Install Thread;");
		installThread.start();
		System.out.println("Installed.");
	}
}

We have started the thread using the start() method of the Thread class rather using the public run() method of the thread we have created.Why it’s only proper to call the start() method to start the thread instead of calling the run() method directly?

Because the run() method is not an ordinary class method. It should only be called by the Java Virtual Machine(JVM). We write threads because we want multi-threading in most of the cases. Writing thread classes is not about a single sequential thread, it’s about the use of multiple threads running at the same time and performing different tasks in a single program.

The JVM needs to work closely with the underneath operating system for the actual implementation of concurrent operations. Improvement in the performance can be achieved by doing so.

You should not invoke the run() method directly. If you call the run() method directly, it will simply execute in the caller’s thread instead of as its own thread. Instead, you need to call the start() method, which schedules the thread with the JVM. The JVM will call the corresponding run() method when the resources and CPU is ready.

Here is a twist. Don’t expect your run method to be executed for all the treads in the same order of start() method execution. The JVM is not guaranteed to call the run() method right way when the start() method is called, or in the order that the start() methods are called.

The JVM must implement a scheduling mechanism that shares the processor among all running threads. This is why when you call the start() methods from more than one thread, the sequence of execution of the corresponding run() methods is random, controlled only by the JVM.

Use case :
Look at the following XML file (dept_HR_Products.xml) which holds the information about different products in a department and several employees belongs to each product. The XML defines , the department dept_HR_Products has three products , product_1 , product_2 and product_3 respectively. product_1 has 2 employees , product_2 has 1 employee where product_3 has 2 employees. This XML holds the name, designation(desig in the XML), employee Id and Manager name as well.
Spend some time to look and understand the XML file.

Listing 1 : dept_HR_Products.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<dept_HR_Products>

	<product_1>
		<employee>
			<id>2345</id>
			<desig>Associate</desig>
			<manager>Alex Braton</manager>
			<name>Yan Botham</name>
		</employee>

		<employee>
			<id>1000</id>
			<desig>Product Manager</desig>
			<manager>Borrek Marteen</manager>
			<name>Krishna Sharma</name>
		</employee>
	</product_1>

	<product_2>
		<employee>
			<id>122</id>
			<desig>sse</desig>
			<manager>Alex B</manager>
			<name>Chand T</name>
		</employee>
	</product_2>

	<product_3>
		<employee>
			<id>34</id>
			<desig>sse</desig>
			<manager>Vipul T</manager>
			<name>Rahim</name>
		</employee>

		<employee>
			<id>340</id>
			<desig>sse</desig>
			<manager>Vipul T</manager>
			<name>Sharma</name>
		</employee>
	</product_3>

</dept_HR_Products>

Lets assume , our application demands us to insert a new employee record to the XML file on click on a button from GUI. So we provide all the details like , employee ID , Designation , Name and Manager’s name from the GUI and click on the submit button to insert the employee record to XML(This is an example , I am sure that you would be having a plan of using a database to do it ). To insert the record to the XML , we need XML node notation . We need to form a node like following and write a routine to insert it ,

<employee>
			<id>100</id>
			<desig>Product Manager</desig>
			<manager>Simon T</manager>
			<name>Krishna Sharma</name>
</employee>

So , we are sure about the attributes an employee can have in our XML store. We should create a DTO(Data transfer object) for Employee which should consist all the attributes an employee can have and setters , getters method for them.
A Employee DTO should look like ,

Listing 2 : Employee DTO

package com.etecguide.java.xmlWrite.dto;
import java.io.Serializable;

public class Employee implements Serializable{
	private String userName;
	private String empId;
	private String designation;
	private String manager;

	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getEmpId() {
		return empId;
	}
	public void setEmpId(String empId) {
		this.empId = empId;
	}
	public String getDesignation() {
		return designation;
	}
	public void setDesignation(String designation) {
		this.designation = designation;
	}
	public String getManager() {
		return manager;
	}
	public void setManager(String manager) {
		this.manager = manager;
	}
      // Overriding toString() method
	public String toString(){
		StringBuffer sb = new StringBuffer();
		sb.append(getUserName());
		sb.append(":");
		sb.append(getEmpId());
		sb.append(":");
		sb.append(getDesignation());
		sb.append(":");
		sb.append(getManager());
		sb.append("]");
		return sb.toString();

	}
}

Now , Lets get into the business. Lets have a look at the Listing 3 which lists the Java code to insert a node to the XML file. Input parameters to the method are ,
xmlFileName – Name of the XML File.
productName – Name of the product(product_1,product_2,product_3) selected from the GUI.
employee – Employee DTO object which would have populated with the employee details provided from GUI.
Have a look at the following code and lets do a step-by-step analysis.

Listing 3 : Write to the XML file

public static void addToDepartment(String xmlFileName, String productName,
			Employee employee) throws ParserConfigurationException,
			SAXException, IOException, TransformerException {

		File file = new File(xmlFileName);
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();
		Document doc = db.parse(file);

		Element rootElement = doc.getDocumentElement();

		NodeList product = rootElement.getElementsByTagName(productName);

		for (int i = 0; i < product.getLength(); i++) {
			Node productNode = product.item(i);

			Node empNode = doc.createElement("employee");

			Node idNode = doc.createElement("id");
			Node idTextNode = doc.createTextNode("id");
			idTextNode.setTextContent(employee.getEmpId());
			idNode.appendChild(idTextNode);

			Node desigNode = doc.createElement("desig");
			Node desigTextNode = doc.createTextNode("desig");
			desigTextNode.setTextContent(employee.getDesignation());
			desigNode.appendChild(desigTextNode);

			Node managerNode = doc.createElement("manager");
			Node managerTextNode = doc.createTextNode("manager");
			managerTextNode.setTextContent(employee.getManager());
			managerNode.appendChild(managerTextNode);

			Node nameNode = doc.createElement("name");
			Node nameTextNode = doc.createTextNode("name");
			nameTextNode.setTextContent(employee.getUserName());
			nameNode.appendChild(nameTextNode);

			empNode.appendChild(idNode);
			empNode.appendChild(desigNode);
			empNode.appendChild(managerNode);
			empNode.appendChild(nameNode);

			productNode.appendChild(empNode);
			break;
		}

		TransformerFactory tFactory = TransformerFactory.newInstance();
		Transformer trs = tFactory.newTransformer();

		DOMSource source = new DOMSource(doc);
		StreamResult result = new StreamResult(new FileOutputStream(new File(
				xmlFileName)));

		trs.transform(source, result);
	}

We create a file object using the file name at the line number 5. Then create a DocumentBuilderFactory and a DocumentBuilder. We need a Document object that represents the parsed xml document. We create a Document object at the line number 8. Next Step is to get the root Element ( i.e, dept_HR_Products) and then get the list of all the nodes inside. As we know the product name , we can form a product node element to get all the child node under the specified product node. We achieve this at the line number 12.
The use of for-loop is unnecessary in this case ( as , we know the product name). We can directly get a product node using ,

Node productNode = product.item(0); 

instead of iterating through the for-loop.
Now we are going to create the node for the new employee along with the data we have passed through Employee DTO. Line 19-37 does this. We create an node and add , , , as a child node to it. Ultimately we add the employee node to the product node at the line number 44. Whatever we have written so far , we have written to the document , not to the XML file in the file System. The next step is to transform the document to the XML file. Here we have used javax.xml.transform.Transformer to do that.
We create a Transformer object at the line number 49 and create a Dom Source from the document at the line number 51. We create a StreamResult object using the xml file. Finally , the transformation happen at line number 55 ,

trs.transform(source, result);

.With this the new node for employee should be written to the XML file.
There could be several other ways to do the same. One should change the above code depending on the structure of the node in the XML. Best of luck for your all future insertion to the XML. Share your views and ideas to do insert to the XML using different techniques.

Object Serialization

Listing 1 : Create a User class which implements java.io.Serializable

package com.etechguide.java.serialization;

import java.io.Serializable;
import java.util.Date;

public class UserData implements Serializable {
	// Name of the User
	private String userName;
	// Employee Id of the User
	private String empId;
	// Creation date of the User in the database
	private Date creationDate;
	// Default constructor
	public UserData(){

	}
	/**
	 * Method to get the User Name
	 * @return String
	 */
	public String getUserName() {
		return userName;
	}
	/**
	 * Method to get the Employee Id
	 * @return String
	 */
	public String getEmpId() {
		return empId;
	}
	/**
	 * Method to get the User Creation
	 * Date and time
	 * @return java.util.Date instance
	 */
	public Date getCreationDate() {
		return creationDate;
	}
	/**
	 * Method to set the User name
	 * @param userName
	 */
	public void setUserName(String userName) {
		this.userName = userName;
	}
	/**
	 * Method to set the Employee Id
	 * @param empId
	 */
	public void setEmpId(String empId) {
		this.empId = empId;
	}
	/**
	 * Method to set the user creation
	 * Date and time
	 * @param creationDate
	 */
	public void setCreationDate(Date creationDate) {
		this.creationDate = creationDate;
	}
}

We would serialize the User object in the form of bytes to the file system. Remember Java i/o programming for file reading and writing ? Yes , we are going to do something of that sort. Look at the following code which should serialize the User object to a file system file , say , user.ser.

Listing 2 : Serializing the User object to file system file user.ser

package com.etechguide.java.serialization;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;

public class PersistUser {

	public static void main(String[] args) {
		String fileName = "user.ser";
		String userName = "admin";
		String empId = "889776";
		Date userCreationDate = new Date();

		UserData userData = new UserData();
		FileOutputStream fos = null;
		ObjectOutputStream out = null;

		try {
			fos = new FileOutputStream(fileName);
			out = new ObjectOutputStream(fos);
			userData.setUserName(userName);
			userData.setEmpId(empId);
			userData.setCreationDate(userCreationDate);
			out.writeObject(userData);
			out.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

Look at the line number 27 in Listing 2 .The method writeObject(Object object) does the main tricks of writing object’s state to file system in the form of sequence of bytes.We have created on User object at the line number 17 and set the values to it.We have created java.io.FileOutputStream object and java.io.ObjectOutputStream object to call the writeObject method. Once run the above main() method , one file called user.ser should be created. This file would have all the state stored for the user object. You can take this file (user.ser) to any other Jvm , any other application and restore the User object state to use it further.Before we proceed to restore the state of the User object under a new jvm or a new application , there are few things to remember and take care.
1. You should have the User.java class accessible to the new Jvm or the new application to restore the object’s state.You can access the class from a jar file in your new environment.
2. User Object class files and the methods are not saved into the user.ser file , only the state of the Object which is saved.
If you have understood both the pointers stated above , lets go ahead and restore the object information.

Listing 3 : Restoring the User object state from user.ser

package com.etechguide.java.serialization;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Date;

public class RestoreUserState {

	public static void main(String[] args) {
		// Specify the full path of the
		// user.ser file
		String filename = "user.ser";
		UserData userData = null;
		FileInputStream fis = null;
		ObjectInputStream in = null;
		try {
			fis = new FileInputStream(filename);
			in = new ObjectInputStream(fis);
			userData = (UserData) in.readObject();
		} catch (IOException ex) {
			ex.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		System.out.println("Accessing Date and Time = " + new Date().toString());
		System.out.println("user name = " + userData.getUserName());
		System.out.println("emp id = " + userData.getEmpId());
		System.out.println("creation Date and Time = "
				+ userData.getCreationDate().toString());
	}
}

Look at the line number 20 in the Listing 3.This is where the restoration is taking place.Look more closely to understand , we are casting the return type of readObject method to the User type.It is why we need the access to User class in the new jvm / new application.in.readObject() returns a java.lang.Object by-default. lets run the program and see the output.
Output :

Accessing Date and Time = Thu Jul 16 13:07:02 IST 2009
user name = admin
emp id = 889776
creation Date and Time = Thu Jul 16 12:28:21 IST 2009

It is clear from output of the program , User object’s state was saved at Thu Jul 16 12:28:21 IST 2009 with information like user name = admin and employee id=889776. We can clearly see the difference between the time we restore the User object , i.e , Thu Jul 16 13:07:02 IST 2009 and the creation time.
So intention is clear now. We have tried to create an User object with it’s user name , employee id and creation date properties . Then we saved the state of it to the file system and restored it for future use. Cool , huh ? The basic process of doing object serialization is very simple and straight-forward. But there are few more things that we should know about object serialization.

Learning 1 : java.lang.Object is not Serializable

Parent call of all java class is java.lang.Object. Object class does not implement the marker interface java.lang.Serializable , hence a direct object of java.lang.Object class can not be serialized. So why all java objects can not be serialized automatically. But there are plenty ready made serialized type available in java. Few of them are array , String , Swing components etc.

Learning 2 : Do Thread serializable?

The answer is No. Thread is not serializable like Socket.No one would try to use the Thread belongs to one application under one jvm to another jvm for another application.

Learning 3 : Want to serialize an object which has a non-serializable field.

Yes , you can serialize an object which has a non-serializable state declared like instance of a Thread. But there is a difference. You have to mark the variable declaration as,
transient private Thread myThread explicitly. look at the declaration, the key word transient to force the java serialization not to store the state of the field while storing the object’s state.

Learning 4 : I would like to serialize an object and send through metwork.

Yes possible. One of the main purpose of using Java Serialization mechanism is , one should serialize / de-serialize the object network.

Java reflection API provides a way to know more about your own class which includes methods and fields. The power of reflection helps you load a class dynamically , create an object of a class at the run time , inspect your fields , methods and modifiers at the run time and many more.There are few draw-backs of the Java Reflection and we are going to discuss that at the end of this tutorial. Lets start with a very simple way to know about your class , super class and modifiers.

Listing 1 : Know about class , super class and modifiers

private static void getBasicClassInfo() {

// User is a class in package com.etechguide.java.reflection
User user = new User();
Class klass = user.getClass();
// Another way of getting class object
// Class klass = User.class;
Class superKlass = klass.getSuperclass();
int modifier = klass.getModifiers();
System.out.println("Class is :" + klass);
System.out.println("Super Class of User Class is :" + superKlass);
System.out.println("Is Public Class : " + Modifier.isPublic(modifier));
System.out.println("Is final Class : " + Modifier.isFinal(modifier));
System.out.println("Is Abstract Class : "
+ Modifier.isAbstract(modifier));

}

Have a look at the code in Listing 1 . At the line number 3 we create an object of a class User which is under a package say , com.etechguide.java.reflection. At the line number 4 we create a java.lang.Class object(klass) from the user object.This class object(klass) gives us the handle to get all the information of the User class.At the line number 7 we get the super class of the class User and we use the java.lang.reflect.Modifier from reflection API at the line number 11 , 12 and 13 to know if the class is final public , final or abstract.Modifier class uses the integer flag to determine the type modifier of the class.
output :

Class is :class com.etechguide.java.reflection.User
Super Class of User Class is :class java.lang.Object
Is Public Class : true
Is final Class : false
Is Abstract Class : false
java.lang.Class object can be archived in two other ways.Lets have a look at the following code below ,

Listing 2 : Know about Class.forname

private static Object instantiateUserWithDefaultConstructor()
throws ClassNotFoundException, InstantiationException,
IllegalAccessException {

Class klass = Class.forName("com.etechguide.java.reflection.User");
Object userObj = klass.newInstance();
// This will call the toString method of User Object
System.out.println("User object created : \n" + userObj);
return userObj;
}

At the line number 5 , we create a java.lang.Class object by using Class.forname(class_name) method. forname(class_name) is a static method of the class java.lang.Class.Point to remember is forname(class-name) method takes a String class name as argument and create the java.lang.Class object. The class name passed as an argument to the method , should be a fully qualified class name ( with full package name) not a class name alone.
At the line number 6 , we create an instance of the class User. The java.lang.Class object for the class com.etechguide.java.reflection.User is the klass and we create an instance of com.etechguide.java.reflection.User by calling klass.newInstance().
output :

The output of the program should be the toString method called on the User object.

It’s time to go deep into reflection and get more details on the classes and objects. In my last two example codes in Listing 1 and Listing 2 , I have used a class called com.etechguide.java.reflection.User. Lets have a full picture of the com.etechguide.java.reflection.User class .

Listing 3 : User class

package com.etechguide.java.reflection;

import java.math.BigDecimal;

public class User {

private String userId;
private String userName;
private String userAddress;
private String phoneNumber;
private BigDecimal income;
private boolean isMarried;

public User() {
super();
System.out.println("Creating object with default constructor ... ");
userId = "admin";
userName = "Administrator";
userAddress = "Geneva";
phoneNumber = "001384959569";
income = new BigDecimal(356786);
isMarried = true;
}

public User(String userId, String userName, String userAddress,
String phoneNumber, BigDecimal income, boolean isMarried) {
System.out
.println("Creating object with parameterized constructor ... ");
this.userId = userId;
this.userName = userName;
this.userAddress = userAddress;
this.phoneNumber = phoneNumber;
this.income = income;
this.isMarried = isMarried;
}

public String getUserId() {
return userId;
}

public void setUserId(String userId) {
this.userId = userId;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

public String getUserAddress() {
return userAddress;
}

public void setUserAddress(String userAddress) {
this.userAddress = userAddress;
}

public String getPhoneNumber() {
return phoneNumber;
}

public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}

public BigDecimal getIncome() {
return income;
}

public void setIncome(BigDecimal income) {
this.income = income;
}

public boolean isMarried() {
return isMarried;
}

public void setMarried(boolean isMarried) {
this.isMarried = isMarried;
}

public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append("userId " + userId + "\n");
buffer.append("userName " + userName + "\n");
buffer.append("userAddress " + userAddress + "\n");
buffer.append("phoneNumber " + phoneNumber + "\n");
if (income != null)
buffer.append("income " + income.intValue() + "\n");
buffer.append("isMarried " + isMarried);
return buffer.toString();
}

private void SOP(String message) {
System.out.println("SOP Message");
System.out.println(message);
}

}

Our next target is to use java reflection to instantiate the User class by using the parameterized constructor of User class. Have a look at the following code in the next page .

public class MyException extends Exception{
// Your code goes here.
}

Lets take an example of an application which transfers the money from one account to another.The application enforces two constraints while the transfer take place.
constraints 1 : The amount of money to be transferred should be greater than 100 rs. (INR) per transaction.
constraints 2 : The amount of money to be transferred should be lesser than 25,000 rs (INR) per transaction.
Lets create a MoneyTransferException class which extends java.lang.Exception class

Listing 1 : MoneyTransferException.java

package com.etechguide.java.exception;
public class MoneyTransferException extends Exception {
private static final long serialVersionUID = 1L;
public MoneyTransferException() {
// Constructor without a message
super();
}
public MoneyTransferException(String transferMsg){
// Constructor with a message
super(transferMsg);
}
}

Now we need two different kind of exceptions that can be thrown when,
1. Transfer amount reached below 100 rs. (MinMoneyTransferException)
2. Transfer amount reached above 25,000 rs. (MaxMoneyTransferException)
Lets create both the classes which extends MoneyTransferException created in Listing 1.

Listing 2 : MinMoneyTransferException.java

package com.etechguide.java.exception;
public class MinMoneyTransferException extends MoneyTransferException {
private static final long serialVersionUID = 1L;
public MinMoneyTransferException() {
super();
System.out.println("Minimum limit has been reached");
}
public MinMoneyTransferException(String minTransferMsg){
super(minTransferMsg);
}
}

Listing 3 : MaxMoneyTransferException.java

package com.etechguide.java.exception;
public class MaxMoneyTransferException extends MoneyTransferException {
private static final long serialVersionUID = 1L;
public MaxMoneyTransferException() {
super();
System.out.println("Max limit has been reached..");
}
public MaxMoneyTransferException(String maxTransferMsg){
super(maxTransferMsg);
}
}

Now we will use these two exceptions in our program to validate that no transaction should take place if it violates the above constraints.

Listing 4 : MoneyTransferTest.java

package com.etechguide.java.exception;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class MoneyTransferTest {

/**
* A method which transfer money
* @param amount - to be transferred
* @throws MinMoneyTransferException - If amount is less than 100
* @throws MaxMoneyTransferException - If amount is greater than 25000
*/
private void transferMoney(long amount) throws
MinMoneyTransferException, MaxMoneyTransferException{

// Transfer should occur is the amount to be transferred
// is within the range of 100 and 25000.

if(amount >= 100 && amount <= 25000){
System.out.println("Transfer amount is correct");
System.out.println("System is ready for transfer");
}
// Amount is less than 100. Lets throw an exception
//, i.e , MinMoneyTransferException
if(amount <100){
throw new MinMoneyTransferException
("The amount "+amount+" rs. is too less to transfer.Minimum limit is 100 rs.");
}

// Amount is greater than 25000.
// Lets throw an exception , i.e , MaxMoneyTransferException

if(amount > 25000){
throw new MaxMoneyTransferException
("The amount "+amount+" rs. is more than 25,000 rs.Maximum limit is 25,000 rs.");
}
System.out.println("Money has been transferred successfully");
}

// Main method

public static void main(String[] args) {
MoneyTransferTest moneyTransferTest = new MoneyTransferTest();
// prompt the user to enter the Transfer amount
System.out.print("Enter the transfer amount: ");
// open up standard input
BufferedReader br = new BufferedReader
(new InputStreamReader(System.in));
String amount = null;
// read the amount from the command-line
try {
amount = br.readLine();
Long amountL = new Long(amount);
moneyTransferTest.transferMoney(amountL.longValue());
} catch (MinMoneyTransferException e) {
System.out.println(e.getMessage());
} catch (MaxMoneyTransferException e) {
System.out.println(e.getMessage());
} catch (IOException ioe) {
System.out.println("IO error trying to read the amount!");
System.exit(1);
}
}

}

Lets run the program MoneyTransferTest.java in Listing 4 for three different amount of transfer,
80 rs , 23434 rs and 34564 rs.
Output (for 80 rs):
Enter the transfer amount: 80
The amount 80 rs. is too less to transfer.Minimum limit is 100 rs.
Output (for 23434 rs):
Enter the transfer amount: 23434
Transfer amount is correct
System is ready for transfer
Money has been transferred successfully
Output (for 34564 rs):
Enter the transfer amount: 34564
The amount 34564 rs. is more than 25,000 rs.Maximum limit is 25,000 rs.

A simple Manifest.MF would look like this ,

Manifest-Version: 1.0
Main-Class: com.etechguide.java.feature.IdentityNeeded
Name: etechguide/Manifest/
Sealed: true
Specification-Title: "Teaching manifest"
Specification-Version: "1.1"
Implementation-Vendor: "http://etechGuide.in"

Lets see how to read some of these properties at runtime and do something useful.
Let us assume we have a jar file named etechguide.jar which has a Manifest.MF file with following specifications,

Manifest-Version: 1.0
Main-Class: com.etechguide.expert.IdentityNeeded
Implementation-Vendor: "http://etechGuide.in"

Manifest-Version is the Version of the application given as a Jar. Main-Class is the entry point to the application. It should have a full qualified class name and the class should have a public static void main(String []args) method.Implementation-Vendor is the the application/jar provider.
Say ,com.etechguide.expert.IdentityNeeded Class look like as ,

package com.etechguide.expert

public class IdentityNeeded {
public void someMethod(){
System.out.println("I do not do anything.");
}
public static void main(String args[]){
System.out.println("I need Identity");
}
}

Our intention is to read the Manifest.MF file from the etechGuide.jar file and instantiate the Main-class , i.e , com.etechguide.expert.IdentityNeeded and call it’s main method.
Lets read the manifest file first,

public static final String MANIFEST = "META-INF/MANIFEST.MF";
public static final String MAIN_CLASS = "Main-Class";

public String readManifest(JarFile jar) throws IOException {
String mainClass = null;
ZipEntry zipEntry = jar.getEntry(MANIFEST);
if (zipEntry == null) {
// Throw some customized exception here
}
InputStream inputStream = jar.getInputStream(zipEntry);
BufferedReader reader = null;
String key = null;
String value = null;
String lineReader = null;
int inx;
reader = new BufferedReader(new InputStreamReader(inputStream));
// Parsing the Manifest information

while ((lineReader = reader.readLine()) != null && lineReader.length() > 0) {
if ((inx = lineReader.indexOf(":")) > 0) {
key = lineReader.substring(0, inx);
value = lineReader.substring(inx + 1).trim();
} else if (lineReader.charAt(0) == ' ') {
value += lineReader.substring(1);
} else {
key = value = "";
continue;
}
if (key.equalsIgnoreCase(MAIN_CLASS)) {
mainClass = value;
break;
}
}
inputStream.close();
reader.close();
jar.close();

return mainClass;
}

The above method takes a JarFile as an input parameter and parse the Manifest.MF file to return the mainClass which is
com.etechguide.expert.IdentityNeeded in this example.
Now you can instantiate the class to call it’s methods as ,

Class cls = Class.forName(mainClass);
IdentityNeeded identityNeeded = (IdentityNeeded) cls.newInstance();
identityNeeded.main(null); // This would call your main method
identityNeeded.someMethod(); // Some other public method can be accessed in this way.

Math.sqrt(Math.pow(45, 2));

– here sqrt and pow are the static methods of the class Math.
A static import allows unqualified access to static member of a class.We should not keep any static member in an interface and then inherit from that rather it is a better idea to import them to a new class.
Static import can be achieved in two ways,
1. Single static import – Import a particular static member of a class.

import static packageName.ClassName.staticMemberName;

For an example , if you want to access Math class’s static member sqrt and pow the import should be,

import static java.lang.Math.sqrt;
import static java.lang.Math.pow;

2. Static import on demand – Import all static member of a class.

import static packageName.ClassName.*;

In this case the import should be import static

java.lang.Math.*

Have look at the following codes :

This is a class with Static methods :

package com.etechguide.java.feature;
public class ClassWithStaticMembers {
public static void talk(){
System.out.println("I am talking");
}
public static void walk(){
System.out.println("I am walking");
}
}

This is a class with Static veriables :

package com.etechguide.java.feature;
public class ClassWithStaticVers {
public static String fruit = "Apple";
public static String name = "Anthony";
public static String state = "green";
}

This class is making use of the static import

package com.etechguide.java.feature;
import static com.etechguide.java.feature.ClassWithStaticMembers.talk;
import static com.etechguide.java.feature.ClassWithStaticVers.*;
public class StaticImport {
public static void main(String[] args) {
talk(); // A static method from the class ClassWithStaticMembers in the package
// com.etechguide.java.feature
// Walk(); This also a staic method of the class ClassWithStaticMembers but not
// accessible as we have not imported it. To access this method ,
ClassWithStaticMembers.walk();

//Here accessing all the static variables of the class  ClassWithStaticVers

System.out.println(name + " loves " + state +" "+ fruit);

}
}

package com.etechguide.java.classtype;

public class SingleTon {
private SingleTon() {
// Not doing anything
}
static private SingleTon instance = null;

/**
* @return the unique instance.
*/
static public SingleTon getInstance() {
if(instance == null ) {
instance = new SingleTon();
}
return instance;
}
}

Here I have provided a default private constructor,

private SingleTon() {
// Not doing anything
}

and then provide a way to one point global access,

static public SingleTon getInstance() {
if(instance == null ) {
instance = new SingleTon();
}
return instance;
}

The above SingleTon Class should be improved to make the access method Synchronized to prevent thread Problems.This can be achieved as,

public static synchronized SingleTon getInstance()

But are we safe here ? No. we can still create a clone of the object using,

SingleTon ston = (SingleTon)obj.clone();

We should override the clone method so that an attempt of cloning the object resulted in an exception , say CloneNotSupportedException Exception.

public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}

Full version of the SingleTon Class is ,

package com.etechguide.java.classtype;
public class SingleTon {
private SingleTon() {
// Not doing anything
}
static private SingleTon instance = null;
/**
* @return the unique instance.
*/
public static synchronized SingleTon getInstance() {
if (instance == null) {
instance = new SingleTon();
}
return instance;
}
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

Single instantiation of the class can be done in the following way too,

public class SingleTon {

private static SingleTon instance = new SingleTon();
public static SingleTon getInstance() {
return instance;
}
private SingleTon() {
}
}