java j2ee interview questions

GWT Interview Questions

2009-07-15T17:54:00.000-07:00

What is Google Web Toolkit?

Google Web Toolkit (GWT) is an open source Java development framework that lets you escape the matrix of technologies that make writing AJAX applications so difficult and error prone. With GWT, you can develop and debug AJAX applications in the Java language using the Java development tools of your choice. When you deploy your application to production, the GWT compiler translates your Java application to browser-compliant JavaScript and HTML.

Here's the GWT development cycle:

Use your favorite Java IDE to write and debug an application in the Java language, using as many (or as few) GWT libraries as you find useful.
Use GWT's Java-to-JavaScript compiler to distill your application into a set of JavaScript and HTML files that you can serve with any web server.
Confirm that your application works in each browser that you want to support, which usually takes no additional work.

Write a Sample GWT programm ?

public class Slicr implements EntryPoint {

public void onModuleLoad() {
final Button button = new Button("Click me");
final Label label = new Label();
button.addClickListener(new ClickListener() {
public void onClick(Widget sender) {
if (label.getText().equals(""))
label.setText("Hello World!");
else
label.setText("");
}
});
RootPanel.get("slot1").add(button);
RootPanel.get("slot2").add(label);
}
}

What are the different listeners in GWT ?

Here is the list of listeners HistoryListener,Changes to Browser History,WindowCloseListener,WindowResizeListener,ChangeListener,ClickListener,
FormHandler,FocusListener,KeyBoardListener,LoadListener,MouseListener,PopupListener,
ScrollListener,TableListener,TabListener,TreeListener
More about listeners

Why doesn't GWT provide a synchronous server connection option?

GWT's network operations are all asynchronous, or non-blocking. That is, they return immediately as soon as called, and require the user to use a callback method to handle the results when they are eventually returned from the server. Though in some cases asynchronous operators are less convenient to use than synchronous operators, GWT does not provide synchronous operators.

The reason is that most browsers' JavaScript engines are single-threaded. As a result, blocking on a call to XMLHTTPRequest also blocks the UI thread, making the browser appear to freeze for the duration of the connection to the server. Some browsers provide a way around this, but there is no universal solution. GWT does not implement a synchronous network connection because to do so would be to introduce a feature that does not work on all browsers, violating GWT's commitment to no-compromise, cross-browser AJAX. It would also introduce complexity for developers, who would have to maintain two different versions of their communications code in order to handle all browsers.

What is AsyncCallback Interface?

public interface AsyncCallbackThe primary interface a caller must implement to receive a response from a remote procedure call.

If an RPC is successful, then onSuccess(Object) is called, otherwise onFailure(Throwable) is called.

Each callable asynchronous method corresponds to a method in the correlated service interface. The asynchronous method always takes an AsyncCallback as its last parameter, where T is the return type of the correlated synchronous method.

A call with a typical use of AsyncCallback might look like this:

service.getShapes(dbName, new AsyncCallback() {
public void onSuccess(Shape[] result) {
// It's always safe to downcast to the known return type.
controller.processShapes(result);
}

public void onFailure(Throwable caught) {
// Convenient way to find out which exception was thrown.
try {
throw caught;
} catch (IncompatibleRemoteServiceException e) {
// this client is not compatible with the server; cleanup and refresh the
// browser
} catch (InvocationException e) {
// the call didn't complete cleanly
} catch (ShapeException e) {
// one of the 'throws' from the original method
} catch (DbException e) {
// one of the 'throws' from the original method
} catch (Throwable e) {
// last resort -- a very unexpected exception
}
}
});

What are the language differences between web mode and hosted mode?

Typically, if your code runs as intended in hosted mode and compiles to JavaScript without error, web mode behavior will be equivalent. Occasional different problems can cause subtle bugs to appear in web mode that don't appear in hosted mode. Fortunately those cases are rare.

How do I make a call to the server if I am not using GWT RPC?

The heart of AJAX is making data read/write calls to a server from the JavaScript application running in the browser. GWT is "RPC agnostic" and has no particular requirements about what protocol is used to issue RPC requests, or even what language the server code is written in. Although GWT provides a library of classes that makes the RPC communications with a J2EE server extremely easy, you are not required to use them. Instead you can build custom HTTP requests to retrieve, for example, JSON or XML-formatted data.

To communicate with your server from the browser without using GWT RPC:

Create a connection to the server, using the browser's XMLHTTPRequest feature.
Construct your payload according to whatever protocol you wish to use, convert it to a string, and send it to the server over the connection.
Receive the server's response payload, and parse it according to the protocol.
You must use an asynchronous server connection.

Can I use GWT with my favorite server-side templating tool?

Yes, you are free to use GWT with any server-side templating tool.

With GWT development, your Java client code gets compiled into equivalent JavaScript that is loaded into your host pages. The generated product is totally independent from the server-side technology that you choose to use in your web application.

You can go ahead and use your favorite server-side templating tool and include your template directives into your host pages along with your GWT-generated JavaScript files. The server-side technology you're using to realize the templates is invisible to the browser and works just as it does without your GWT modules.

What is Gwt Sever Side RemoteServiceServlet?

public class RemoteServiceServletextends javax.servlet.http.HttpServletimplements SerializationPolicyProvider

The servlet base class for your RPC service implementations that automatically deserializes incoming requests from the client and serializes outgoing responses for client/server RPCs.

GWT event listeners

2009-07-15T17:15:00.001-07:00

GWT defines event listeners that you can attach to your widgets to monitor browser events. Event Listeners are just interfaces that you can implement in your widget. If you want to trap mouse click events, then your widget should implement the ClickListener interface and define the onClick(Widget sender) method. The code inside this method will be fired every time the user clicks on your widget.

You can create a new anonymous ClickListener every time you want to assign it to a widget as given in the Hello gwt example.

button.addClickListener(new ClickListener() {
 public void onClick(Widget sender) {
  processData(sender.getText());
  reportData(sender.getText());
  logResults();
 }
});

But this results in localized code and lesser code reusability. Let us say we want to add another widget (a HTML link), which has to run the same code as in the onClick() method. We would be using the addClickListener method for this link and would be rewriting the same code again separately. And if we need to add another method in the onClick() method code between processData() and reportData() we will have to change each instance of onClick().

Alternatively, we can implement the listeners in the container widget to handle the events of contained widgets as shown below, making the code more reusable.

public class MainPanel extends Composite 
 implements ClickListener{

 private Button button=new Button("Button");
 public MainPanel(){
 
  //...
  button.addClickListener(this);
 }

 public void onClick(Widget sender){
  if(sender==button){
   processData(sender.getText());
   reportData(sender.getText());
   logResults();
  }
 }
}

With this approach, if we want to add a HTML widget link that implements the same function, we would just have to add the line

link.addClickListener(this);

in MainPanel() and modify one line in the onClick(Widget sender) method

if(sender==button||sender==link)

Given Below is a listing of GWT Event listeners for handling various events:

Listener	Event notifications	Methods Defined
HistoryListener	Changes to Browser History	onHistoryChanged(String historyToken)
WindowCloseListener	Window Closure Events	onWindowClosed() onWindowClosing()
WindowResizeListener	Window Resizing Events	onWindowResized(int width, int height)
ChangeListener	fires when a widget changes	onChange(Widget sender)
ClickListener	fires when a widget receives a 'click'	onClick(Widget sender)
FormHandler	fires on receiving Form events from the FormPanel to which it is attached	onSubmit(FormSubmitEvent event) onSubmitComplete( FormSubmitCompleteEvent event)
FocusListener	Focus Events	onFocus(Widget sender) onLostFocus(Widget sender)
KeyBoardListener	Keyboard Events	onKeyDown(Widget sender, char keycode, int modifiers) onKeyPress(Widget sender, char keycode, int modifiers) onKeyUp(Widget sender, char keycode, int modifiers)
LoadListener	listens to 'load' event of a widget	onLoad(Widget Sender) onError(Widget Sender)
MouseListener	listens to mouse events of a widget	onMouseEnter(Widget sender) onMouseLeave(Widget sender) onMouseDown(Widget sender, int x, int y) onMouseUp(Widget sender, int x, int y) onMouseMove(Widget sender, int x, int y)
PopupListener	listens to the events of a PopupPanel widget	onPopupClosed(PopupPanel sender, boolean autoClose)
ScrollListener	listens to Scroll events	onScroll(Widget widget, int scrollLeft, int scrollTop)
TableListener	listens to events pertaining to a Table widget	onCellClicked( SourcesTableEvents sources, int row, int cell)
TabListener	listens to the events of a Tab Widget	onBeforeTabSelected( SourcesTabEvents sender, int tabIndex) onTabSelected( SourcesTabEvents sender, int tabIndex)
TreeListener	listens to the events of a Tree Widget	onTreeItemSelected( TreeItem item) onTreeItemChanged( TreeItem item)

The Button widget defines the addClickListener method which attaches a ClickListener object to it. Similarly, the Tree widget defines the addTreeListener method. Not all event listeners are available for all widgets - for example, the addMouseListener method is not defined for a DockPanel Widget. One way to add the MouseListener functionality to this DockPanel is to create a composite that includes a FocusPanel widget (which supports addMouseListener) and wrap the DockPanel widget within it.

GWT Examples and Tutorials

2009-06-24T14:18:00.000-07:00

GWT event listeners

GWT NumberFormat Example

GWT File UPLOAD Example

GWT File DownLoad Example

Core Java Examples and Tutorials

2009-06-24T13:44:00.000-07:00

Method overloading

Method overriding

Inheritance Example

Interface Example

Abstract Methods and Classes

ArrayList Example

Vector Example

Singleton class Example

Convert string to int in java

Convert Date to String in java

Convert String to Date in java

DecimalFormat Roundoff upto two digits

Singleton class Example

2009-06-23T19:26:00.001-07:00

Singleton Class

Ensure that only one instance of a class is created
Provide a global point of access to the object
Allow multiple instances in the future without affecting a singleton class's clients

Example 1 shows a classic Singleton design pattern implementation:

Example 1. The classic singleton

public class ClassicSingleton {
private static ClassicSingleton instance = null;
protected ClassicSingleton() {
// Exists only to defeat instantiation.
}
public static ClassicSingleton getInstance() {
if(instance == null) {
instance = new ClassicSingleton();
}
return instance;
}
}

Convert string to int in java

2009-06-23T19:25:00.002-07:00

public class ConvertStringToInt {
public static void main(String[] args) {
String aString = "78";
int aInt = Integer.parseInt(aString);

System.out.println(aInt);
}
}

Convert Date to String in java

2009-06-23T19:25:00.001-07:00

package org.kodejava.example.java.util;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class DateToString
{
public static void main(String[] args)
{
// Create an instance of SimpleDateFormat used for formatting
// the string representation of date (month/day/year)
DateFormat df = new SimpleDateFormat("MM/dd/yyyy");

// Get the date today using Calendar object.
Date today = Calendar.getInstance().getTime();
// Using DateFormat format method we can create a string
// representation of a date with the defined format.
String reportDate = df.format(today);

// Print what date is today!
System.out.println("Report Date: " + reportDate);
}
}

Convert String to Date in java

2009-06-23T19:24:00.000-07:00

import java.util.Date;
import java.text.SimpleDateFormat;
... ... ... ...

public void testConvertDateToString() {

// Allocates a Date object and initializes it so that it represents the time
// at which it was allocated, measured to the nearest millisecond.
Date dateNow = new Date ();

SimpleDateFormat dateformatYYYYMMDD = new SimpleDateFormat("yyyyMMdd");
SimpleDateFormat dateformatMMDDYYYY = new SimpleDateFormat("MMddyyyy");

StringBuilder nowYYYYMMDD = new StringBuilder( dateformatYYYYMMDD.format( dateNow ) );
StringBuilder nowMMDDYYYY = new StringBuilder( dateformatMMDDYYYY.format( dateNow ) );

System.out.println( "DEBUG: Today in YYYYMMDD: '" + nowYYYYMMDD + "'");
System.out.println( "DEBUG: Today in MMDDYYYY: '" + nowMMDDYYYY + "'");

}

DecimalFormat Roundoff upto two digits

2009-06-23T19:19:00.001-07:00

public static String decimalRoundoff(Double value){
//DecimalFormat myFormatter = new DecimalFormat(".00");
DecimalFormat myFormatter = new DecimalFormat("#,##0.00");
String output = myFormatter.format(value);
return output;
}

GWT NumberFormat Example

2009-06-23T19:18:00.003-07:00

public class NumberFormat
extends java.lang.Object
extends java.lang.Object

Formats and parses numbers using locale-sensitive patterns.

This class provides comprehensive and flexible support for a wide variety of
localized formats, including

Locale-specific symbols such as decimal point, group separator,
digit representation, currency symbol, percent, and permill

Numeric variations including integers ("123"), fixed-point
numbers ("123.4"), scientific notation ("1.23E4"), percentages ("12%"), and
currency amounts ("$123")

Predefined standard patterns that can be used both for parsing
and formatting, including decimal,
currency,
percentages, and
scientific

Custom patterns and supporting features designed to make it
possible to parse and format numbers in any locale, including support for
Western, Arabic, and Indic digits

Patterns

Formatting and parsing are based on customizable patterns that can include a
combination of literal characters and special characters that act as
placeholders and are replaced by their localized counterparts. Many
characters in a pattern are taken literally; they are matched during parsing
and output unchanged during formatting. Special characters, on the other
hand, stand for other characters, strings, or classes of characters. For
example, the '#' character is replaced by a localized digit.

Often the replacement character is the same as the pattern character. In the
U.S. locale, for example, the ',' grouping character is
replaced by the same character ','. However, the replacement
is still actually happening, and in a different locale, the grouping
character may change to a different character, such as '.'.
Some special characters affect the behavior of the formatter by their
presence. For example, if the percent character is seen, then the value is
multiplied by 100 before being displayed.

The characters listed below are used in patterns. Localized symbols use the
corresponding characters taken from corresponding locale symbol collection,
which can be found in the properties files residing in the
com.google.gwt.i18n.client.constants. To insert
a special character in a pattern as a literal (that is, without any special
meaning) the character must be quoted. There are some exceptions to this
which are noted below.

A NumberFormat pattern contains a postive and negative
subpattern separated by a semicolon, such as
"#,##0.00;(#,##0.00)". Each subpattern has a prefix, a
numeric part, and a suffix. If there is no explicit negative subpattern, the
negative subpattern is the localized minus sign prefixed to the positive
subpattern. That is, "0.00" alone is equivalent to
"0.00;-0.00". If there is an explicit negative subpattern, it
serves only to specify the negative prefix and suffix; the number of digits,
minimal digits, and other characteristics are ignored in the negative
subpattern. That means that "#,##0.0#;(#)" has precisely the
same result as "#,##0.0#;(#,##0.0#)".

The prefixes, suffixes, and various symbols used for infinity, digits,
thousands separators, decimal separators, etc. may be set to arbitrary
values, and they will appear properly during formatting. However, care must
be taken that the symbols and strings do not conflict, or parsing will be
unreliable. For example, the decimal separator and thousands separator should
be distinct characters, or parsing will be impossible.

The grouping separator is a character that separates clusters of integer
digits to make large numbers more legible. It commonly used for thousands,
but in some locales it separates ten-thousands. The grouping size is the
number of digits between the grouping separators, such as 3 for "100,000,000"
or 4 for "1 0000 0000".

Pattern Grammar (BNF)

The pattern itself uses the following grammar:

pattern:=subpattern (';' subpattern)?
subpattern:=prefix? number exponent? suffix?
number:=(integer ('.' fraction)?) sigDigits
prefix:='\u0000'..'\uFFFD' - specialCharacters
suffix:='\u0000'..'\uFFFD' - specialCharacters
integer:='#'* '0'*'0'
fraction:='0'* '#'*
sigDigits:='#'* '@''@'* '#'*
exponent:='E' '+'? '0'* '0'
padSpec:='*' padChar
padChar:='\u0000'..'\uFFFD' - quote

Notation:

X* 0 or more instances of X
X? 0 or 1 instances of X
XY either X or Y
C..D any character from C up to D, inclusive
S-T characters in S, except those in T

The first subpattern is for positive numbers. The second (optional) subpattern is for negative numbers.

Example

public class NumberFormatExample implements EntryPoint {

  public void onModuleLoad() {
    NumberFormat fmt = NumberFormat.getDecimalFormat();
    double value = 12345.6789;
    String formatted = fmt.format(value);
    // Prints 1,2345.6789 in the default locale
    GWT.log("Formatted string is" + formatted, null);

    // Turn a string back into a double
    value = NumberFormat.getDecimalFormat().parse("12345.6789");
    GWT.log("Parsed value is" + value, null);

    // Scientific notation
    value = 12345.6789;
    formatted = NumberFormat.getScientificFormat().format(value);
    // prints 1.2345E4 in the default locale
    GWT.log("Formatted string is" + formatted, null);

    // Currency
    fmt = NumberFormat.getCurrencyFormat();
    formatted = fmt.format(123456.7899);
    // prints $123,456.79 in the default locale
    GWT.log("Formatted currency is" + formatted, null);

    // Custom format
    value = 12345.6789;
    formatted = NumberFormat.getFormat("000000.000000").format(value);
    // prints 012345.678900 in the default locale
    GWT.log("Formatted string is" + formatted, null);
  }
}

Constructor Detail

NumberFormat


protected NumberFormat(com.google.gwt.i18n.client.constants.NumberConstants numberConstants,
                       java.lang.String pattern,
                       com.google.gwt.i18n.client.impl.CurrencyData cdata,
                       boolean userSuppliedPattern)

Constructs a format object based on the specified settings.

NumberFormat

protected NumberFormat(java.lang.String pattern,
                       com.google.gwt.i18n.client.impl.CurrencyData cdata,
                       boolean userSuppliedPattern)

Constructs a format object for the default locale based on the specified
settings.

Method Detail

getCurrencyFormat


public static NumberFormat getCurrencyFormat()

Provides the standard currency format for the default locale.

getCurrencyFormat
public static NumberFormat getCurrencyFormat(java.lang.String currencyCode)

Provides the standard currency format for the default locale using a
specified currency.

getDecimalFormat


public static NumberFormat getDecimalFormat()

Provides the standard decimal format for the default locale.

Returns:

a NumberFormat capable of producing and consuming
decimal format for the default locale

getFormat
public static NumberFormat getFormat(java.lang.String pattern)

Gets a NumberFormat instance for the default locale using
the specified pattern and the default currencyCode.

Parameters:: pattern - pattern for this formatter
Returns:: a NumberFormat instance
Throws:: java.lang.IllegalArgumentException - if the specified pattern is invalid

getFormat

public static NumberFormat getFormat(java.lang.String pattern,
                                     java.lang.String currencyCode)

Gets a custom NumberFormat instance for the default locale
using the specified pattern and currency code.

getPercentFormat


public static NumberFormat getPercentFormat()

Provides the standard percent format for the default locale.

Returns:

a NumberFormat capable of producing and consuming
percent format for the default locale

getScientificFormat


public static NumberFormat getScientificFormat()

Provides the standard scientific format for the default locale.

Returns:

a NumberFormat capable of producing and consuming
scientific format for the default locale

format


public java.lang.String format(double number)

This method formats a double to produce a string.
Parameters:

getPattern
public java.lang.String getPattern()

Returns the pattern used by this number format.

parse
public double parse(java.lang.String text)

throws java.lang.NumberFormatException

Parses text to produce a numeric value. A NumberFormatException is
thrown if either the text is empty or if the parse does not consume all
characters of the text.

parse
public double parse(java.lang.String text,

int[] inOutPos)

throws java.lang.NumberFormatException

Parses text to produce a numeric value.

The method attempts to parse text starting at the index given by pos. If
parsing succeeds, then the index of pos is updated to the
index after the last character used (parsing does not necessarily use all
characters up to the end of the string), and the parsed number is returned.
The updated pos can be used to indicate the starting point
for the next call to this method. If an error occurs, then the index of
pos is not changed.

GWT File UPLOAD

2009-06-23T19:18:00.001-07:00

Client:

public void onModuleLoad() {
final FormPanel form = new FormPanel();
form.setAction(GWT.getModuleBaseURL() + "/myFormHandler");

// Because we're going to add a FileUpload widget, we'll need to set the
// form to use the POST method, and multipart MIME encoding.
form.setEncoding(FormPanel.ENCODING_MULTIPART);
form.setMethod(FormPanel.METHOD_POST);

VerticalPanel panel = new VerticalPanel();
form.setWidget(panel);

// Create a FileUpload widget.
FileUpload upload = new FileUpload();
upload.setName("uploadFormElement");

panel.add(upload);

Button button2 = new Button("Submit", new ClickListener() {
public void onClick(Widget sender) {
form.submit();
}
});

// Add a 'submit' button.
panel.add(button2);

// Add an event handler to the form.
form.addFormHandler(new FormHandler() {

public void onSubmitComplete(FormSubmitCompleteEvent event) {
// When the form submission is successfully completed, this
// event is
// fired. Assuming the service returned a response of type
// text/html,
// we can get the result text here (see the FormPanel
// documentation for
// further explanation).
Window.alert(event.getResults());
}

public void onSubmit(FormSubmitEvent event) {
// TODO Auto-generated method stub

}
});

RootPanel.get().add(form);

}

.gwt.xml
add this line:

Server

public class MyFormHandler extends HttpServlet {

public void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {

resp.setContentType("text/html");

FileItem uploadItem = getFileItem(req);
if(uploadItem == null) {
resp.getWriter().write("NO-SCRIPT-DATA");
return;
}

resp.getWriter().write(new String(uploadItem.get()));

}

private FileItem getFileItem(HttpServletRequest req) {
FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);

try {
List items = upload.parseRequest(req);
Iterator it = items.iterator();

while(it.hasNext()) {
FileItem item = (FileItem) it.next();
if(!item.isFormField() && "uploadFormElement".equals(item.getFieldName())) {
return item;
}
}
}
catch(FileUploadException e){
return null;
}

return null;
}

}

GWT File DownLoad

2009-06-23T19:16:00.000-07:00

Per some requests for the File Download opposite of File Upload.

On the server side I implemented the doGet method of the HttpServlet class. I grab the raw data from the database and set it into the response (with the appropriate response type):

BufferedOutputStream output = null;
try {
RawAttachmentItem attachment = attachmentFileDao.retrieveContents(fileid);
ByteArrayInputStream input = new ByteArrayInputStream(attachment.getContents());
int contentLength = input.available();

resp.reset();
resp.setContentType("application/octet-stream");
resp.setContentLength(contentLength);
resp.setHeader("Content-disposition", "attachment; filename=\"" + attachment.getFilename()
+ "\"");
output = new BufferedOutputStream(resp.getOutputStream());
for(int data; (data=input.read()) != -1;) {
output.write(data);
}
output.flush();
}
catch (IOException e) {

e.printStackTrace();
}
finally {
close(output);
}
On the client side, you simple create a new iFrame with its 'src' attribute set to the servlet url for downloading the file:

boolean frameExists = (RootPanel.get("downloadiframe") != null);
if(frameExists) {
Widget widgetFrame = (Widget)RootPanel.get("downloadiframe");
widgetFrame.removeFromParent();
}

NamedFrame frame = new NamedFrame("downloadiframe");
frame.setUrl(GWT.getModuleBaseURL()
+ "/attachmentHandler?action=dl&fileid="
+ model.getFileId());
frame.setVisible(false);

RootPanel.get().add(frame);
When the file gets sent back to the iFrame, the browser will treat it as a file download and prompt you to do something with it (open, save, cancel, etc).

If anyone has questions or requires more detail, please do not hesitate to ask!!

Vector Example

2009-06-23T17:27:00.000-07:00

In this example we are going to show the use of java.util.Vector class. We will be creating an object of Vector class and performs various operation like adding, removing etc. Vector class extends AbstractList and implements List, RandomAccess, Cloneable, Serializable. The size of a vector increase and decrease according to the program. Vector is synchronized.

In this example we are using seven methods of a Vector class.

add(Object o): It adds the element in the end of the Vector

size(): It gives the number of element in the vector.

elementAt(int index): It returns the element at the specified index.

firstElement(): It returns the first element of the vector.

lastElement(): It returns last element.

removeElementAt(int index): It deletes the element from the given index.

elements(): It returns an enumeration of the element

In this example we have also used Enumeration interface to retrieve the value of a vector. Enumeration interface has two methods.

hasMoreElements(): It checks if this enumeration contains more elements or not.

nextElement(): It checks the next element of the enumeration.

Code of this program is given below:

//java.util.Vector and java.util.Enumeration;

import java.util.*;
public class VectorDemo{
public static void main(String[] args){
Vector vector = new Vector();
int primitiveType = 10;
Integer wrapperType = new Integer(20);
String str = "animal";
vector.add(primitiveType);
vector.add(wrapperType);
vector.add(str);
vector.add(2, new Integer(30));
System.out.println("the elements of vector: " + vector);
System.out.println("The size of vector are: " + vector.size());
System.out.println("The elements at position 2 is: " + vector.elementAt(2));
System.out.println("The first element of vector is: " + vector.firstElement());
System.out.println("The last element of vector is: " + vector.lastElement());
vector.removeElementAt(2);
Enumeration e=vector.elements();
System.out.println("The elements of vector: " + vector);
while(e.hasMoreElements()){
System.out.println("The elements are: " + e.nextElement());
}
}
}

Output of this example is given below:

the elements of vector: [10, 20, 30, animal]
The size of vector are: 4
The elements at position 2 is: 30
The first element of vector is: 10
The last element of vector is: animal
The elements of vector: [10, 20, animal]
The elements are: 10
The elements are: 20
The elements are: animal

ArrayList Example

2009-06-23T17:24:00.001-07:00

In this example we are going to show the use of java.util.ArrayList. We will be creatiing an object of ArrayList class and performs various operations like adding removing the objects.

Arraylist provides methods to manipulate the size of the array that is used internally to store the list. ArrayList extends AbstractList and implements List, Cloneable, Serializable. ArrayList capacity .grows automatically. The ArrayList is not synchronized. It permits all elements including null.

In this program we are inserting a value. We are using three methods of ArrayList class.

add(Object o): Appends the specified element to the end of this list. It returns a boolean value.

size(): Returns the number of elements in this list.

remove(int index): Removes the element at the specified position in this list. It returns the element that was removed from the list. It throws IndexOutOfBoundsException : if index is out of range.

Code of a program is given below:

import java.util.*;

public class ArrayListDemo{
public static void main(String[] args) {
ArrayList arl=new ArrayList();
Integer i1=new Integer(10);
Integer i2=new Integer(20);
Integer i3=new Integer(30);
Integer i4=new Integer(40);
String s1="animal";
System.out.println("The content of arraylist is: " + arl);
System.out.println("The size of an arraylist is: " + arl.size());
arl.add(i1);
arl.add(i2);
arl.add(s1);
System.out.println("The content of arraylist is: " + arl);
System.out.println("The size of an arraylist is: " + arl.size());
arl.add(i1);
arl.add(i2);
arl.add(i3);
arl.add(i4);
Integer i5=new Integer(50);
arl.add(i5);
System.out.println("The content of arraylist is: " + arl);
System.out.println("The size of an arraylist is: " + arl.size());
arl.remove(3);
Object a=arl.clone();
System.out.println("The clone is: " + a);
System.out.println("The content of arraylist is: " + arl);
System.out.println("The size of an arraylist is: " + arl.size());
}
}

The output of program will be like this:

The content of arraylist is: []
The size of an arraylist is: 0
The content of arraylist is: [10, 20, animal]
The size of an arraylist is: 3
The content of arraylist is: [10, 20, animal, 10, 20, 30, 40, 50]
The size of an arraylist is: 8
The clone is: [10, 20, animal, 20, 30, 40, 50]
The content of arraylist is: [10, 20, animal, 20, 30, 40, 50]
The size of an arraylist is: 7

Abstract Methods and Classes

2009-06-23T17:13:00.000-07:00

An abstract class is a class that is declared abstract—it may or may not include abstract methods. Abstract classes cannot be instantiated, but they can be subclassed.
An abstract method is a method that is declared without an implementation (without braces, and followed by a semicolon), like this:

abstract void moveTo(double deltaX, double deltaY);

If a class includes abstract methods, the class itself must be declared abstract, as in:

public abstract class GraphicObject {
// declare fields
// declare non-abstract methods
abstract void draw();
}

When an abstract class is subclassed, the subclass usually provides implementations for all of the abstract methods in its parent class. However, if it does not, the subclass must also be declared abstract.

--------------------------------------------------------------------------------
Note: All of the methods in an interface are implicitly abstract, so the abstract modifier is not used with interface methods (it could be—it's just not necessary).

An Abstract Class Example

First, you declare an abstract class, GraphicObject, to provide member variables and methods that are wholly shared by all subclasses, such as the current position and the moveTo method. GraphicObject also declares abstract methods for methods, such as draw or resize, that need to be implemented by all subclasses but must be implemented in different ways. The GraphicObject class can look something like this:

abstract class GraphicObject {
int x, y;
...
void moveTo(int newX, int newY) {
...
}
abstract void draw();
abstract void resize();
}

Each non-abstract subclass of GraphicObject, such as Circle and Rectangle, must provide implementations for the draw and resize methods:
class Circle extends GraphicObject {
void draw() {
...
}
void resize() {
...
}
}
class Rectangle extends GraphicObject {
void draw() {
...
}
void resize() {
...
}
}

Abstract Classes versus Interfaces

Unlike interfaces, abstract classes can contain fields that are not static and final, and they can contain implemented methods. Such abstract classes are similar to interfaces, except that they provide a partial implementation, leaving it to subclasses to complete the implementation. If an abstract class contains only abstract method declarations, it should be declared as an interface instead.

Multiple interfaces can be implemented by classes anywhere in the class hierarchy, whether or not they are related to one another in any way. Think of Comparable or Cloneable, for example.

By comparison, abstract classes are most commonly subclassed to share pieces of implementation. A single abstract class is subclassed by similar classes that have a lot in common (the implemented parts of the abstract class), but also have some differences (the abstract methods).

Interface Example

2009-06-23T17:09:00.001-07:00

In its most common form, an interface is a group of related methods with empty bodies. A bicycle's behavior, if specified as an interface, might appear as follows:

interface Bicycle {

void changeCadence(int newValue);

void changeGear(int newValue);

void speedUp(int increment);

void applyBrakes(int decrement);
}

To implement this interface, the name of your class would change (to ACMEBicycle, for example), and you'd use the implements keyword in the class declaration:

class ACMEBicycle implements Bicycle {

// remainder of this class implemented as before

}

Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

Inheritance Example

2009-06-23T17:05:00.000-07:00

Inheritance in Java
Inheritance is a compile-time mechanism in Java that allows you to extend a class (called the base class or superclass) with another class (called the derived class or subclass).

class inheritance - create a new class as an extension of another class, primarily for the purpose of code reuse. That is, the derived class inherits the public methods and public data of the base class. Java only allows a class to have one immediate base class, i.e., single class inheritance.

For class inheritance, Java uses the keyword extends

public class derived-class-name extends base-class-name {
// derived class methods extend and possibly override
// those of the base class
}

Method overriding

2009-06-23T16:57:00.001-07:00

In a class hierarchy, when a method in a subclass has the same name and type signature as a method in its superclass, then the method in the subclass is said to override the method in the superclass. When an overridden method is called from within a subclass, it will always refer to the version of that method defined by the subclass. The version of the method defined by the superclass will be hidden. Consider the following:
// Method overriding.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// display i and j
void show() {
System.out.println("i and j: " + i + " " + j);
}
}

class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// display k – this overrides show() in A
void show() {
System.out.println("k: " + k);
}
}

class Override {
public static void main(String args[]) {
B subOb = new B(1, 2, 3);
subOb.show(); // this calls show() in B
}
}

The output produced by this program is shown here:

k: 3

When show( ) is invoked on an object of type B, the version of show( ) defined within B is used. That is, the versio n of show( ) inside B overrides the version declared in A. If you wish to access the superclass version of an overridden function, you can do so by using super. For example, in this version of B, the superclass version of show( ) is invoked within the subclass' version. This allows all instance variables to be displayed.

class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
void show() {
super.show(); // this calls A's show()
System.out.println("k: " + k);
}
}

If you substitute this version of A into the previous program, you will see the following output:

i and j: 1 2
k: 3

Here, super.show( ) calls the superclass version of show( ). Method overriding occurs only when the names and the type signatures of the two methods are identical.

Method overloading

2009-06-23T16:48:00.000-07:00

In Java it is possible to define two or more methods within the same class that share the same name, as long as their parameter declarations are different. When this is the case, the methods are said to be overloaded, and the process is referred to as method overloading. Method overloading is one of the ways that Java implements polymorphism.

When an overloaded method is invoked, Java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actually call. Thus,
overloaded methods must differ in the type and/or number of their parameters. While overloaded methods may have different return types, the return type alone is insufficient to distinguish two versions of a method. When Java encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call. Here is a simple example that illustrates method overloading

// Demonstrate method overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter
double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.2);
System.out.println("Result of ob.test(123.2): " + result);
}
}

This program generates the following output:

No parameters
a: 10
a and b: 10 20
double a: 123.2
Result of ob.test(123.2): 15178.24

As you can see, test( ) is overloaded four times. The first version takes no parameters, the second takes one integer parameter, the third takes two integer parameters, and the fourth takes one double parameter. The fact that the fourth version of test( ) also returns a value is of no consequence relative to overloading, since return types do not play a role in overload resolution.

Xml Interview Questions

2009-06-13T19:47:00.000-07:00

Q)What is XML ?

XML stands for EXtensible Markup Language.

XML was designed to transport and store data.

XML documents are universally accepted as a standard way of representing information in platform and language independent manner.

XML is universal standard for information interchange.

XML documents can be created in any language and can be used in any language

Q) What is the difference between Schema and DTD?
Schema might outphase DTD. XML shemas are in XML. XML Schema has a lot of built-in data types including xs:string,xs:decimal,xs:integer,xs:boolean,xs:date,xs:time. XML schemas can be edited with Schema files, parsed with XML parser, manipulated with XML DOM, and transformed with XSLT.
The building blocks of DTD include elements, attributes, entities, PCDATA, and CDATA.

Q) How do you parse/validate the XML document?
By using a SAXParser, DOMParser, or XSDValidator.

Q) What is XML Namespace?
Namespaces are a simple and straightforward way to distinguish names used in XML documents and namespace to avoid confusion involves using a prefix and adding an xmlns attribute to the tag to give the prefix a qualified name associated with the namespace. All child elements with the same prefix are associated with the namespace defined in the start tag of an element.

Q)What is a well-formed XML document?
If a document is syntactically correct it can be called as well-formed XML documents. A well-formed document conforms to XML's basic rules of syntax:

Every open tag must be closed.
The open tag must exactly match the closing tag: XML is case-sensitive.
All elements must be embedded within a single root element.
Child tags must be closed before parent tags.
A well-formed document has correct XML tag syntax, but the elements might be invalid for the specified document type.

Q)What is a valid XML document?

If a document is structurally correct then it can be called as valid XML documents. A valid document conforms to the predefined rules of a specific type of document:

These rules can be written by the author of the XML document or by someone else.
The rules determine the type of data that each part of a document can contain.
Note:Valid XML document is implicitly well-formed, but well-formed may not be valid

Q)What is a CDATA section in XML?
The CDATA section of XML is used to describe the text that should not be parsed by the XML parser.

Any text that is included in CDATA section is ignored by the parser.

Q)What is the difference between SAX parser and DOM parser?
DOM
DOM spec defines an object-oriented hieararchy.
The DOM parser creates an internal tree based on the hierarchy of the XML data.
Tree stays in memory until released. The DOM parser is more memory intensive. DOM Parser’s advantage is that it is simple. Pairs nicely with XSLT.
-Nice for smaller XML files, but because of the whole XML file
representation is in memory, it is possible not useful for
very large documents
-good for representation of an XML document.

SAX:

SAX spec defines an event based approach, calling handler functions whenever certain text nodes or processing instructions are found.
These events include the start and end of the document, finding a text node, finding child elements, and hitting a malformed element. SAX development is more challenging. SAX can parse gigabytes worth of XML without hitting resource barriers.
It’s also faster and more complex. Better for huge XML docs. Best suited for sequential-scan applications.

Q)What's XLink?

This specification defines the XML Linking Language (XLink), which allows elements to be inserted into XML documents in order to create and describe links between resources. It uses XML syntax to create structures that can describe links similar to the simple unidirectional hyperlinks of today's HTML, as well as more sophisticated links.

Q)What is Xpath?
XPath is a language for addressing parts of an XML document, designed to be used by both XSLT and XPointer.

Q) What is XSL?
In addition to XSLT, XSL includes an XML vocabulary for specifying formatting. XSL specifies the styling of an XML document by using XSLT to describe how the document is transformed into another XML document that uses the formatting vocabulary.

Q) What is XSLT?
A language for transforming XML documents into other XML documents. XSLT is designed for use as part of XSL, which is a stylesheet language for XML.

Q)What is JAXP ?

The Java API for XML Processing (JAXP) is for processing XML data using applications written in the Java programming language. JAXP leverages the parser standards Simple API for XML Parsing (SAX) and Document Object Model (DOM) so that you can choose to parse your data as a stream of events or to build an object representation of it. JAXP also supports the Extensible Stylesheet Language Transformations (XSLT) standard, giving you control over the presentation of the data and enabling you to convert the data to other XML documents or to other formats, such as HTML. JAXP also provides namespace support, allowing you to work with DTDs that might otherwise have naming conflicts.

JMS

2009-06-13T19:32:00.001-07:00

Q: What is JMS?

A: Java Message Service: An interface implemented by most J2EE containers to provide point-to-point queueing and topic (publish/subscribe) behavior. JMS is frequently used by EJB's that need to start another process asynchronously.

For example, instead of sending an email directly from an Enterprise
JavaBean, the bean may choose to put the message onto a JMS queue to be handled by a Message-Driven Bean (another type of EJB) or another
system in the enterprise. This technique allows the EJB to return to
handling requests immediately instead of waiting for a potentially
lengthy process to complete.

Q: What are major JMS products available in the market?

A: IBM's MQ Series, SonicMQ, iBus etc.

Q:What are the advantages of JMS?

A: You can use it in the context of mutithreading but it means JMS is not meant for Multithreading. Its basically meant for object communication.

It will be useful when you are writing some event based applications
like Chat Server which needs a publish kind of event mechanism to send
messages between the server to the clients who got connected with the server. Moreover JMS gives Loosely-coupled kind of mechanism when compared with
RMI which is tightly-coupled. In JMS there is no need for the destination object to be available online while sending a message from
the client to the server. But in RMI it is necessary. So we can use JMS
in place of RMI where we need to have loosely-coupled mechanism.

Q: What are the different types of messages available in the JMS API?

A: Message, TextMessage, BytesMessage, StreamMessage, ObjectMessage, MapMessage are the different messages available in the JMS API.

Q: What are the different messaging paradigms JMS supports?

A: Publish and Subscribe i.e. pub/suc and Point to Point i.e. p2p.

Q: What are the various message types supported by JMS?

A: Stream Messages -- Group of Java Primitives
Map Messages -- Name Value Pairs. Name being a string& Value being a java primitive
Text Messages -- String messages (since being widely used a separate
messaging Type has been supported)
Object Messages -- Group of serialize able java object
Bytes Message -- Stream of uninterrupted bytes

Q: What are the types of messaging?

A: There are two kinds of Messaging.
Synchronous Messaging: Synchronous messaging involves a client that
waits for the server to respond to a message.

Asynchronous Messaging: Asynchronous messaging involves a client that does not wait for a message from the server. An event is used to trigger a message from a server.

Q: What are the three components of a Message ?

A: A JMS message consists of three parts:
Message header
For message identification. For example, the header is used to
determine if a given message is appropriate for a "subscriber"

Properties
For application-specific, provider-specific, and optional header fields

Body
Holds the content of the message. Several formats are supported,
including TextMessage, which wrap a simple String, that wrap arbitrary
Java objects (which must be serializable). Other formats are supported
as well.

Q: What kind of information found in the header of a Message ?

A: The header of a message contains message identification and routing information. This includes , but is not limited to :

JMSDestination
JMSDeliveryMode
JMSMessageID
JMSTimeStamp
JMSExpiration
JMSReplyTO
JMSCorrelationID
JMSType
JMSRedelivered

Q: What is the basic difference between Publish Subscribe model and P2P model?

A: Publish Subscribe model is typically used in one-to-many situation. It is unreliable but very fast. P2P model is used in one-to-one situation. It is highly reliable.

Q: What is the difference between BytesMessage and StreamMessage?

A: BytesMessage stores the primitive data types by converting them to their byte representation.
Thus the message is one contiguous stream of bytes. While the
StreamMessage maintains a boundary between the different data types
stored because it also stores the type information along with the value
of the primitive being stored. BytesMessage allows data to be read
using any type. Thus even if your payload contains a long value, you
can invoke a method to read a short and it will return you something.
It will not give you a semantically correct data but the call will
succeed in reading the first two bytes of data. This is strictly
prohibited in the StreamMessage. It maintains the type information of
the data being stored and enforces strict conversion rules on the data
being read.

Q: What is point-to-point messaging?

A: What are the core JMS-related objects required for each JMS-enabled
application?

Each JMS-enabled client must
establish the following:
• A connection object provided by the JMS server (the message broker)
• Within a connection, one or more sessions, which provide a context
for message sending and receiving
• Within a session, either a queue or ic object representing the
destination (the message staging area) within the message broker
• Within a session, the appropriate sender or publisher or receiver or
subscriber object (depending on whether the client is a message
producer or consumer and uses a point-to-point or publish/subscribe
strategy, respectively)
Within a session, a message object (to send or to receive)

Q: What is the difference between ic and queue?

A: A ic is typically used for one to many messaging i.e. it supports publish subscribe model of messaging. While queue is used for one-to-one messaging i.e. it supports Point to Point Messaging.

Q)What are the core JMS-related objects required for each JMS-enabled application?

A: : Each JMS-enabled client must establish the following:
• A connection object provided by the JMS server (the message broker)
• Within a connection, one or more sessions, which provide a context for message sending and receiving
• Within a session, either a queue or topic object representing the destination (the message staging area) within the message broker
• Within a session, the appropriate sender or publisher or receiver or subscriber object (depending on whether the client is a message producer or consumer and uses a point-to-point or publish/subscribe strategy, respectively)
Within a session, a message object (to send or to receive)

Q : What is the use of Message object?

A: Message is a light weight message having only header and properties and no payload. Thus if theIf the receivers are to be notified abt an event, and no data needs to be exchanged then using Message can be very efficient.

Q: What is the use of BytesMessage?

A: BytesMessage contains an array of primitive bytes in it's payload. Thus it can be used for transfer of data between two applications in their native format which may not be compatible with other Message types. It is also useful where JMS is used purely as a transport between two systems and the message payload is opaque to the JMS client. Whenever you store any primitive type, it is converted into it's byte representation and then stored in the payload. There is no boundary line between the different data types stored. Thus you can even read a long as short. This would result in erroneous data and hence it is advisable that the payload be read in the same order and using the same type in which it was created by the sender.

Q: What is the use of StreamMessage?

A: StreamMessage carries a stream of Java primitive types as it's payload. It contains some conveient methods for reading the data stored in the payload. However StreamMessage prevents reading a long value as short, something that is allwed in case of BytesMessage. This is so because the StreamMessage also writes the type information alonwgith the value of the primitive type and enforces a set of strict conversion rules which actually prevents reading of one primitive type as another.

Q: What is the use of TextMessage?

A: TextMessage contains instance of java.lang.String as it's payload. Thus it is very useful for exchanging textual data. It can also be used for exchanging complex character data such as an XML document.

Q: What is the use of ObjectMessage?

A: ObjectMessage contains a Serializable java object as it's payload. Thus it allows exchange of Java objects between applications. This in itself mandates that both the applications be Java applications. The consumer of the message must typecast the object received to it's appropriate type. Thus the consumer should before hand know the actual type of the object sent by the sender. Wrong type casting would result in ClassCastException. Moreover the class definition of the object set in the payload should be available on both the machine, the sender as well as the consumer. If the class definition is not available in the consumer machine, an attempt to type cast would result in ClassNotFoundException. Some of the MOMs might support dynamic loading of the desired class over the network, but the JMS specification does not mandate this behavior and would be a value added service if provided by your vendor. And relying on any such vendor specific functionality would hamper the portability of your application. Most of the time the class need to be put in the classpath of both, the sender and the consumer, manually by the developer.

Q: What is the use of MapMessage?

A: A MapMessage carries name-value pair as it's payload. Thus it's payload is similar to the java.util.Properties object of Java. The values can be Java primitives or their wrappers.

Q: What is MDB and What is the special feature of that?

A: MDB is Message driven bean, which very much resembles the Stateless session bean. The incoming and out going messages can be handled by the Message driven bean. The ability to communicate asynchronously is the special feature about the Message driven bean.

JUnit

2009-06-13T17:39:00.001-07:00

1)What is JUnit?

JUnit is a simple, open source framework to write and run repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks. JUnit features include:

Assertions for testing expected results
Test fixtures for sharing common test data
Test runners for running tests

2)How do I write and run a simple test?

Create a class:

package junitfaq;

import org.junit.*;
import static org.junit.Assert.*;

import java.util.*;

public class SimpleTest {
Write a test method (annotated with @Test) that asserts expected results on the object under test:

@Test
public void testEmptyCollection() {
Collection collection = new ArrayList();
assertTrue(collection.isEmpty());
}

If you are running your JUnit 4 tests with a JUnit 3.x runner, write a suite() method that uses the JUnit4TestAdapter class to create a suite containing all of your test methods:

public static junit.framework.Test suite() {
return new junit.framework.JUnit4TestAdapter(SimpleTest.class);
}
Although writing a main() method to run the test is much less important with the advent of IDE runners, it's still possible:

public static void main(String args[]) {
org.junit.runner.JUnitCore.main("junitfaq.SimpleTest");
}
}
Run the test:

To run the test from the console, type:

java org.junit.runner.JUnitCore junitfaq.SimpleTest
To run the test with the test runner used in main(), type:

java junitfaq.SimpleTest
The passing test results in the following textual output:

.
Time: 0

OK (1 tests)

3)What CLASSPATH settings are needed to run JUnit?

(Submitted by: Eric Armstrong)

To run your JUnit tests, you'll need the following elemements in your CLASSPATH:

JUnit class files
Your class files, including your JUnit test classes
Libraries your class files depend on
If attempting to run your tests results in a NoClassDefFoundError, then something is missing from your CLASSPATH.

Windows Example:

set CLASSPATH=%JUNIT_HOME%\junit.jar;c:\myproject\classes;c:\myproject\lib\something.jar

Unix (bash) Example:

export CLASSPATH=$JUNIT_HOME/junit.jar:/myproject/classes:/myproject/lib/something.jar

4)Why not just use System.out.println()?

Inserting debug statements into code is a low-tech method for debugging it. It usually requires that output be scanned manually every time the program is run to ensure that the code is doing what's expected.

It generally takes less time in the long run to codify expectations in the form of an automated JUnit test that retains its value over time. If it's difficult to write a test to assert expectations, the tests may be telling you that shorter and more cohesive methods would improve your design.

5)How do I test a method that doesn't return anything?

Often if a method doesn't return a value, it will have some side effect. Actually, if it doesn't return a value AND doesn't have a side effect, it isn't doing anything.

There may be a way to verify that the side effect actually occurred as expected. For example, consider the add() method in the Collection classes. There are ways of verifying that the side effect happened (i.e. the object was added). You can check the size and assert that it is what is expected:

@Test
public void testCollectionAdd() {
Collection collection = new ArrayList();
assertEquals(0, collection.size());
collection.add("itemA");
assertEquals(1, collection.size());
collection.add("itemB");
assertEquals(2, collection.size());
}
Another approach is to make use of MockObjects.

A related issue is to design for testing. For example, if you have a method that is meant to output to a file, don't pass in a filename, or even a FileWriter. Instead, pass in a Writer. That way you can pass in a StringWriter to capture the output for testing purposes. Then you can add a method (e.g. writeToFileNamed(String filename)) to encapsulate the FileWriter creation.

6)How do I test protected methods?

Place your tests in the same package as the classes under test.

7)How do I test private methods?

Testing private methods may be an indication that those methods should be moved into another class to promote reusability.

But if you must...

If you are using JDK 1.3 or higher, you can use reflection to subvert the access control mechanism with the aid of the PrivilegedAccessor.

8) Under what conditions should I test get() and set() methods?

Unit tests are intended to alleviate fear that something might break. If you think a get() or set() method could reasonably break, or has in fact contributed to a defect, then by all means write a test.

In short, test until you're confident. What you choose to test is subjective, based on your experiences and confidence level. Remember to be practical and maximize your testing investment.

9)Under what conditions should I not test get() and set() methods?

Most of the time, get/set methods just can't break, and if they can't break, then why test them? While it is usually better to test more, there is a definite curve of diminishing returns on test effort versus "code coverage". Remember the maxim: "Test until fear turns to boredom."

Assume that the getX() method only does "return x;" and that the setX() method only does "this.x = x;". If you write this test:

@Test
public void testGetSetX() {
setX(23);
assertEquals(23, getX());
}
then you are testing the equivalent of the following:

@Test
public void testGetSetX() {
x = 23;
assertEquals(23, x);
}
or, if you prefer,

@Test
public void testGetSetX() {
assertEquals(23, 23);
}
At this point, you are testing the Java compiler, or possibly the interpreter, and not your component or application. There is generally no need for you to do Java's testing for them.

If you are concerned about whether a property has already been set at the point you wish to call getX(), then you want to test the constructor, and not the getX() method. This kind of test is especially useful if you have multiple constructors:

@Test
public void testCreate() {
assertEquals(23, new MyClass(23).getX());
}

10)How do I write a test that passes when an expected exception is thrown?

Add the optional expected attribute to the @Test annotation. The following is an example test that passes when the expected IndexOutOfBoundsException is raised:

@Test(expected=IndexOutOfBoundsException.class)
public void testIndexOutOfBoundsException() {
ArrayList emptyList = new ArrayList();
Object o = emptyList.get(0);
}

11) How do I write a test that fails when an unexpected exception is thrown?

Declare the exception in the throws clause of the test method and don't catch the exception within the test method. Uncaught exceptions will cause the test to fail with an error.

The following is an example test that fails when the IndexOutOfBoundsException is raised:

@Test
public void testIndexOutOfBoundsExceptionNotRaised()
throws IndexOutOfBoundsException {

ArrayList emptyList = new ArrayList();
Object o = emptyList.get(0);
}

12)Why does JUnit only report the first failure in a single test?

Reporting multiple failures in a single test is generally a sign that the test does too much, compared to what a unit test ought to do. Usually this means either that the test is really a functional/acceptance/customer test or, if it is a unit test, then it is too big a unit test.

JUnit is designed to work best with a number of small tests. It executes each test within a separate instance of the test class. It reports failure on each test. Shared setup code is most natural when sharing between tests. This is a design decision that permeates JUnit, and when you decide to report multiple failures per test, you begin to fight against JUnit. This is not recommended.

Long tests are a design smell and indicate the likelihood of a design problem. Kent Beck is fond of saying in this case that "there is an opportunity to learn something about your design." We would like to see a pattern language develop around these problems, but it has not yet been written down.

Finally, note that a single test with multiple assertions is isomorphic to a test case with multiple tests:

One test method, three assertions:

public class MyTestCase {
@Test
public void testSomething() {
// Set up for the test, manipulating local variables
assertTrue(condition1);
assertTrue(condition2);
assertTrue(condition3);
}
}
Three test methods, one assertion each:

public class MyTestCase {
// Local variables become instance variables

@Before
public void setUp() {
// Set up for the test, manipulating instance variables
}

@Test
public void testCondition1() {
assertTrue(condition1);
}

@Test
public void testCondition2() {
assertTrue(condition2);
}

@Test
public void testCondition3() {
assertTrue(condition3);
}
}
The resulting tests use JUnit's natural execution and reporting mechanism and, failure in one test does not affect the execution of the other tests. You generally want exactly one test to fail for any given bug, if you can manage it.

13) Do I need to write a test class for every class I need to test?

No. It is a convention to start with one test class per class under test, but it is not necessary.

Test classes only provide a way to organize tests, nothing more. Generally you will start with one test class per class under test, but then you may find that a small group of tests belong together with their own common test fixture.[1] In this case, you may move those tests to a new test class. This is a simple object-oriented refactoring: separating responsibilities of an object that does too much.

Another point to consider is that the TestSuite is the smallest execution unit in JUnit: you cannot execute anything smaller than a TestSuite at one time without changing source code. In this case, you probably do not want to put tests in the same test class unless they somehow "belong together". If you have two groups of tests that you think you'd like to execute separately from one another, it is wise to place them in separate test classes.

[1] A test fixture is a common set of test data and collaborating objects shared by many tests. Generally they are implemented as instance variables in the test class.

14) In Java 1.4, assert is a keyword. Won't this conflict with JUnit's assert() method?
JUnit 3.7 deprecated assert() and replaced it with assertTrue(), which works exactly the same way.

JUnit 4 is compatible with the assert keyword. If you run with the -ea JVM switch, assertions that fail will be reported by JUnit.

15) How do I test things that must be run in a J2EE container (e.g. servlets, EJBs)?

Refactoring J2EE components to delegate functionality to other objects that don't have to be run in a J2EE container will improve the design and testability of the software.

Cactus is an open source JUnit extension that can be used to test J2EE components in their natural environment.

16)Is there a basic template I can use to create a test?

The following templates are a good starting point. Copy/paste and edit these templates to suit your coding style.

SampleTest is a basic test template:

import org.junit.*;
import static org.junit.Assert.*;

public class SampleTest {

private java.util.List emptyList;

/**
* Sets up the test fixture.
* (Called before every test case method.)
*/
@Before
public void setUp() {
emptyList = new java.util.ArrayList();
}

/**
* Tears down the test fixture.
* (Called after every test case method.)
*/
@After
public void tearDown() {
emptyList = null;
}

@Test
public void testSomeBehavior() {
assertEquals("Empty list should have 0 elements", 0, emptyList.size());
}

@Test(expected=IndexOutOfBoundsException.class)
public void testForException() {
Object o = emptyList.get(0);
}
}

17)How do I write a test for an abstract class?

Refer to http://c2.com/cgi/wiki?AbstractTestCases.

18)When are tests garbage collected?

By design, the tree of Test instances is built in one pass, then the tests are executed in a second pass. The test runner holds strong references to all Test instances for the duration of the test execution. This means that for a very long test run with many Test instances, none of the tests may be garbage collected until the end of the entire test run.

Therefore, if you allocate external or limited resources in a test, you are responsible for freeing those resources. Explicitly setting an object to null in the tearDown() method, for example, allows it to be garbage collected before the end of the entire test run.

19)How can I run setUp() and tearDown() code once for all of my tests?

The desire to do this is usually a symptom of excessive coupling in your design. If two or more tests must share the same test fixture state, then the tests may be trying to tell you that the classes under test have some undesirable dependencies.

Refactoring the design to further decouple the classes under test and eliminate code duplication is usually a better investment than setting up a shared test fixture.

But if you must...

You can add a @BeforeClass annotation to a method to be run before all the tests in a class, and a @AfterClass annotation to a method to be run after all the tests in a class. Here's an example:

package junitfaq;

import org.junit.*;
import static org.junit.Assert.*;
import java.util.*;

public class SimpleTest {

private Collection collection;

@BeforeClass
public static void oneTimeSetUp() {
// one-time initialization code
}

@AfterClass
public static void oneTimeTearDown() {
// one-time cleanup code
}

@Before
public void setUp() {
collection = new ArrayList();
}

@After
public void tearDown() {
collection.clear();
}

@Test
public void testEmptyCollection() {
assertTrue(collection.isEmpty());
}

@Test
public void testOneItemCollection() {
collection.add("itemA");
assertEquals(1, collection.size());
}
}
Given this test, the methods will execute in the following order:

oneTimeSetUp()
setUp()
testEmptyCollection()
tearDown()
setUp()
testOneItemCollection()
tearDown()
oneTimeTearDown()
Running Tests
20)What CLASSPATH settings are needed to run JUnit?

To run your JUnit tests, you'll need the following elemements in your CLASSPATH:

JUnit class files
Your class files, including your JUnit test classes
Libraries your class files depend on
If attempting to run your tests results in a NoClassDefFoundError, then something is missing from your CLASSPATH.

Windows Example:

set CLASSPATH=%JUNIT_HOME%\junit.jar;c:\myproject\classes;c:\myproject\lib\something.jar

Unix (bash) Example:

export CLASSPATH=$JUNIT_HOME/junit.jar:/myproject/classes:/myproject/lib/something.jar

21)How do I run JUnit from my command window?

Set your CLASSPATH

Invoke the runner:

java org.junit.runner.JUnitCore (test class name)

22)How do I pass command-line arguments to a test execution?

Use the -D JVM command-line options, as in:

-DparameterName=parameterValue
If the number of parameters on the command line gets unweildy, pass in the location of a property file that defines a set of parameters. Alternatively, the JUnit-addons package contains the XMLPropertyManager and PropertyManager classes that allow you to define a property file (or XML file) containing test parameters.

23)Why do I get the warning "AssertionFailedError: No tests found in XXX" when I run my test?

Make sure you have more or more method annotated with @Test.

For example:

@Test
public void testSomething() {
}

24)Why do I get a NoClassDefFoundError when trying to test JUnit or run the samples?

Most likely your CLASSPATH doesn't include the JUnit installation directory.

Refer to "What CLASSPATH settings are needed to run JUnit?" for more guidance.

Also consider running WhichJunit to print the absolute location of the JUnit class files required to run and test JUnit and its samples.

Unix Commands

2009-01-18T09:53:00.001-08:00

mkdir .............. make a directory
rmdir .............. remove directory (rm -r to delete folders with files)
rm ................. remove files
cd ................. change current directory
ls ................. show directory, in alphabetical order
logout ............. logs off system
talk (user) ........ pages user for chat - (user) is a email address
write (user) ....... write a user on the local system (control-c to end)
man (command) ...... shows help on a specific command

pico (filename) .... easy to use text editor to edit files
pine ............... easy to use mailer
more (file) ........ views a file, pausing every screenful

grep ............... search for a string in a file
tail ............... show the last few lines of a file
who ................ shows who is logged into the local system
w .................. shows who is logged on and what they're doing
finger (emailaddr).. shows more information about a user
df ................. shows disk space available on the system
du ................. shows how much disk space is being used up by folders
chmod .............. changes permissions on a file
bc ................. a simple calculator

passwd ............. change your password
chfn ............... change your "Real Name" as seen on finger
chsh ............... change the shell you log into

sz ................. send a file (to you) using zmodem
rz ................. recieve a file (to the unix system) using zmodem

ftp (host) ......... connects to a FTP site
telnet (host) ...... connect to another Internet site
archie (filename) .. search the Archie database for a file on a FTP site
irc ................ connect to Internet Relay Chat
lynx ............... a textual World Wide Web browser
gopher ............. a Gopher database browser
tin, trn ........... read Usenet newsgroups

gzip ............... best compression for UNIX files
zip ................ zip for IBM files
tar ................ combines multiple files into one or vice-versa
lharc, lzh, lha .... un-arc'ers, may not be on your system

make ............... compiles source code
gcc (file.c) ....... compiles C source into a file named 'a.out'

unix2dos (file) (new) - adds CR's to unix text files
dos2unix (file) (new) - strips CR's out of dos text files

Jdbc Interview Questions

2009-01-17T16:11:00.001-08:00

Q.What is the Java Database Connectivity (JDBC) ?

Java Database Connectivity (JDBC) is a standard Java API to interact with relational databases form Java.

Q)What are types of JDBC drivers?

There are four types of drivers defined by JDBC as follows:

Type 1: JDBC/ODBC—These require an ODBC (Open Database Connectivity) driver for the database to be installed. This type of driver works by translating the submitted queries into equivalent ODBC queries and forwards them via native API calls directly to the ODBC driver. It provides no host redirection capability.

Type2: Native API (partly-Java driver)—This type of driver uses a vendor-specific driver or database API to interact with the database. An example of such an API is Oracle OCI (Oracle Call Interface). It also provides no host redirection.

Type 3: Open Protocol-Net—This is not vendor specific and works by forwarding database requests to a remote database source using a net server component. How the net server component accesses the database is transparent to the client. The client driver communicates with the net server using a database-independent protocol and the net server translates this protocol into database calls. This type of driver can access any database.

Type 4: Proprietary Protocol-Net(pure Java driver)—This has a same configuration as a type 3 driver but uses a wire protocol specific to a particular vendor and hence can access only that vendor's database. Again this is all transparent to the client.

Q)Which type of JDBC driver is the fastest one?

JDBC Net pure Java driver(Type IV) is the fastest driver because it converts the JDBC calls into vendor specific protocol calls and it directly interacts with the database.

Q)Explain Basic Steps in a JDBC Programming?

Load the RDBMS specific JDBC driver because this driver actually communicates with the database (Incase of JDBC 4.0 this is automatically loaded).
Class.forName ("sun.jdbc.odbc.JdbcOdbcDriver");

Open the connection to database which is then used to send SQL statements and get results back.
Connection con = DriverManager.getConnection( "jdbc:odbc:SSPer","Tiger","tictac");

Create JDBC Statement object. This object contains SQL query.

PreparedStatement ps = conn.prepareStatement(
"select * from Dept where deptid=? and dept=?");
ps.setString(1,deptid);
ps.setString(2,dept);

Execute PreparedStatement which returns resultset(s). ResultSet contains the tuples of database table as a result of SQL query.

ResultSet rs = ps.executeQuery();

Process the result set.
while (rs.next()) {
}

//Close the connection.
con.close();

Q)What will Class.forName do while loading drivers?

It is used to create an instance of a driver and register it with the
DriverManager. When you have loaded a driver, it is available for making a connection with a DBMS.

Q)What is PreparedStatement?

A prepared statement is an SQL statement that is precompiled by the database. Through precompilation, prepared statements improve the performance of SQL commands that are executed multiple times (given that the database supports prepared statements). Once compiled, prepared statements can be customized prior to each execution by altering predefined SQL parameters.

PreparedStatement pstmt = conn.prepareStatement("select * from EMPLOYEES where SALARY = ? and ID = ?");
pstmt.setBigDecimal(1, 2333.00);
pstmt.setInt(2, 4333);
ResultSet rs = pstmt.executeQuery();

Q)What is the difference between a Statement and a PreparedStatement?
Statement
Statement has to verify its metadata against the database every time.
If you want to execute the SQL statement once go for STATEMENT

PreparedStatement

A PreparedStatement is a precompiled statement. This means that when the PreparedStatement is executed, the RDBMS can just run the PreparedStatement SQL statement without having to compile it first.
Prepared statement has to verify its metadata against the database only once.
If you want to execute a single SQL statement multiple number of times, then go for PREPAREDSTATEMENT. PreparedStatement objects can be reused with passing different values to the queries

Q)What does setAutoCommit do?

When a connection is created, it is in auto-commit mode. This means that each individual SQL statement is treated as a transaction and will be automatically committed right after it is executed. The way to allow two or more statements to be grouped into a transaction is to disable auto-commit mode:

con.setAutoCommit(false);

Once auto-commit mode is disabled, no SQL statements will be committed until you call the method commit explicitly.

con.setAutoCommit(false);
PreparedStatement updateSales =
con.prepareStatement( "UPDATE ICECREAMS SET SALES = ? WHERE ICECREAM_NAME LIKE ?");
updateSales.setInt(1, 50);
updateSales.setString(2, "chocolate");
updateSales.executeUpdate();
PreparedStatement updateTotal =
con.prepareStatement("UPDATE ICECREAMS SET TOTAL = TOTAL + ? WHERE ICECREAM_NAME LIKE ?");
updateTotal.setInt(1, 50);
updateTotal.setString(2, "chocolate");
updateTotal.executeUpdate();
con.commit();
con.setAutoCommit(true);

Q)What are callable statements ?

Callable statements are used from JDBC application to invoke stored procedures and functions.

Q)How to call a stored procedure from JDBC ?

PL/SQL stored procedures are called from within JDBC programs by means of the prepareCall() method of the Connection object created. A call to this method takes variable bind parameters as input parameters as well as output variables and creates an object instance of the CallableStatement class.

The following line of code illustrates this:

CallableStatement stproc_stmt = conn.prepareCall("{call procname(?,?,?)}");
Here conn is an instance of the Connection class.

Q)How do I retrieve warnings?

SQLWarning objects are a subclass of SQLException that deal with database access warnings. Warnings do not stop the execution of an
application, as exceptions do; they simply alert the user that something did not happen as planned. A warning can be reported on a
Connection object, a Statement object (including PreparedStatement and CallableStatement objects), or a ResultSet object. Each of these
classes has a getWarnings method, which you must invoke in order to see the first warning reported on the calling object:

SQLWarning warning = stmt.getWarnings();
if (warning != null)
{
System.out.println("n---Warning---n");
while (warning != null)
{
System.out.println("Message: " + warning.getMessage());
System.out.println("SQLState: " + warning.getSQLState());
System.out.print("Vendor error code: ");
System.out.println(warning.getErrorCode());
System.out.println("");
warning = warning.getNextWarning();
}
}

Q)Does the JDBC-ODBC Bridge support multiple concurrent open statements per connection?
No. You can open only one Statement object per connection when you are using the JDBC-ODBC Bridge.

Q)Which is the right type of driver to use and when?

Type I driver is handy for prototyping
Type III driver adds security, caching, and connection control
Type III and Type IV drivers need no pre-installation
Note: Preferred by 9 out of 10 Java developers: Type IV. Click here to learn more about JDBC drivers.

Q)What are the standard isolation levels defined by JDBC?

The values are defined in the class java.sql.Connection and are:

TRANSACTION_NONE
TRANSACTION_READ_COMMITTED
TRANSACTION_READ_UNCOMMITTED
TRANSACTION_REPEATABLE_READ
TRANSACTION_SERIALIZABLE

Q)What are the types of resultsets?

The values are defined in the class java.sql.Connection and are:

TYPE_FORWARD_ONLY specifies that a resultset is not scrollable, that is, rows within it can be advanced only in the forward direction.
TYPE_SCROLL_INSENSITIVE specifies that a resultset is scrollable in either direction but is insensitive to changes committed by other transactions or other statements in the same transaction.
TYPE_SCROLL_SENSITIVE specifies that a resultset is scrollable in either direction and is affected by changes committed by other transactions or statements within the same transaction.
Note: A TYPE_FORWARD_ONLY resultset is always insensitive.

Q)What’s the difference between TYPE_SCROLL_INSENSITIVE , and TYPE_SCROLL_SENSITIVE?

You will get a scrollable ResultSet object if you specify one of these ResultSet constants.The difference between the two has to do with whether a result set reflects changes that are made to it while it is open and whether certain methods can be called to detect these changes. Generally speaking, a result set that is TYPE_SCROLL_INSENSITIVE does not reflect changes made while it is still open and one that is TYPE_SCROLL_SENSITIVE does. All three types of result sets will make changes visible if they are closed and then reopened:

Statement stmt =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
ResultSet srs =
stmt.executeQuery("SELECT COF_NAME, PRICE FROM COFFEES");
srs.afterLast();
while (srs.previous())
{
String name = srs.getString("COF_NAME");
float price = srs.getFloat("PRICE");
System.out.println(name + " " + price);
}

Q)How to Make Updates to Updatable Result Sets?

Another new feature in the JDBC 2.0 API is the ability to update rows in a result set using methods in the Java programming language rather than having to send an SQL command. But before you can take advantage of this capability, you need to create a ResultSet object that is updatable. In order to do this, you supply the ResultSet constant CONCUR_UPDATABLE to the createStatement method.

Connection con =
DriverManager.getConnection("jdbc:mySubprotocol:mySubName");
Statement stmt =
con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet uprs =
stmt.executeQuery("SELECT COF_NAME, PRICE FROM COFFEES");

Q)What is a DataSource?
A DataSource object is the representation of a data source in the Java programming language. In basic terms,

A DataSource is a facility for storing data.
DataSource can be referenced by JNDI.
Data Source may point to RDBMS, file System , any DBMS etc..

Q)What are the advantages of DataSource?
The few advantages of data source are :

An application does not need to hardcode driver information, as it does with the DriverManager.
The DataDource implementations can easily change the properties of data sources. For example: There is no need to modify the application code when making changes to the database details.
The DataSource facility allows developers to implement a DataSource class to take advantage of features like connection pooling and distributed transactions.

Q)What is connection pooling? what is the main advantage of using connection pooling?
A connection pool is a mechanism to reuse connections created. Connection pooling can increase performance dramatically by reusing connections rather than creating a new physical connection each time a connection is requested..

Ejb Interview Questions

2009-01-16T18:52:00.000-08:00

Q)What are the different kinds of enterprise beans?

Stateless session bean- An instance of these non-persistent EJBs provides a service without storing an interaction or conversation state between methods. Any instance can be used for any client.

Stateful session bean- An instance of these non-persistent EJBs maintains state across methods and transactions. Each instance is associated with a particular client.

Entity bean- An instance of these persistent EJBs represents an object view of the data, usually rows in a database. They have a primary key as a unique identifier. Entity bean persistence can be either container-managed or bean-managed.

Message-driven bean- An instance of these EJBs is integrated with the Java Message Service (JMS) to provide the ability for message-driven beans to act as a standard JMS message consumer and perform asynchronous processing between the server and the JMS message producer

Q)What is session bean ?

There are two types of session beans: stateful and stateless.

Stateful Session Beans

The state of an object consists of the values of its instance variables. In a stateful session bean, the instance variables represent the state of a unique client-bean session. Because the client interacts ("talks") with its bean, this state is often called the conversational state.

The state is retained for the duration of the client-bean session. If the client removes the bean or terminates, the session ends and the state disappears. This transient nature of the state is not a problem, however, because when the conversation between the client and the bean ends there is no need to retain the state.

Stateless Session Beans

A stateless session bean does not maintain a conversational state for a particular client. When a client invokes the method of a stateless bean, the bean's instance variables may contain a state, but only for the duration of the invocation. When the method is finished, the state is no longer retained. Except during method invocation, all instances of a stateless bean are equivalent, allowing the EJB container to assign an instance to any client.

Because stateless session beans can support multiple clients, they can offer better scalability for applications that require large numbers of clients. Typically, an application requires fewer stateless session beans than stateful session beans to support the same number of clients.

At times, the EJB container may write a stateful session bean to secondary storage. However, stateless session beans are never written to secondary storage. Therefore, stateless beans may offer better performance than stateful beans.

Q)What is Entity Bean?

The entity bean is used to represent data in the database. It provides an object-oriented interface to data that would normally be accessed by the JDBC or some other back-end API. More than that, entity beans provide a component model that allows bean developers to focus their attention on the business logic of the bean, while the container takes care of managing persistence,transactions, and access control.

There are two basic kinds of entity beans: container-managed ersistence (CMP) andbean-managed persistence (BMP).

Container-managed persistence beans are the simplest for the bean developer to create and the most difficult for the EJB server to support. This is because all the logic for synchronizing the bean's state with the database is handled automatically by the container. This means that the bean developer doesn't need to write any data access logic, while the EJB server is
supposed to take care of all the persistence needs automatically. With CMP, the container manages the persistence of the entity bean. Vendor tools are used to map the entity fields to the database and absolutely no database access code is written in the bean class.

The bean-managed persistence (BMP) enterprise bean manages synchronizing its state with the database as directed by the container. The bean uses a database API to read and write its fields to the database, but the container tells it when to do each synchronization operation and manages the transactions for the bean automatically. Bean-managed persistence gives the bean developer the flexibility to perform persistence operations that are too complicated for the container or to use a data source that is not supported by the container.

Q)what are Container-Managed Transactional attributes ?

NotSupported

The bean is not involved in a transaction. If the bean invoker calls the bean while involved in a transaction, the invoker's transaction is suspended, the bean executes, and when the bean returns, the invoker's transaction is resumed.

Required

The bean must be involved in a transaction. If the invoker is involved in a transaction, the bean uses the invoker's transaction. If the invoker is not involved in a transaction, the container starts a new transaction for the bean.

Supports

Whatever transactional state that the invoker is involved in is used for the bean. If the invoker has begun a transaction, the invoker's transaction context is used by the bean. If the invoker is not involved in a transaction, neither is the bean.

RequiresNew

Whether or not the invoker is involved in a transaction, this bean starts a new transaction that exists only for itself. If the invoker calls while involved in a transaction, the invoker's transaction is suspended until the bean completes.

Mandatory

The invoker must be involved in a transaction before invoking this bean. The bean uses the invoker's transaction context.

Never

The bean is not involved in a transaction. Furthermore, the invoker cannot be involved in a transaction when calling the bean. If the invoker is involved in a transaction, a RemoteException is thrown.

Q)What's difference between httpsession and EJB session bean ?

A session in a Servlet, is maintained by the Servlet Container through the HttpSession object, that is acquired through the request object. You cannot really instantiate a new HttpSession object, and it doesn't contains any business logic, but is more of a place where to store objects.

A session in EJB is maintained using the SessionBeans. You design beans that can contain business logic, and that can be used by the clients. You have two different session beans: Stateful and Stateless. The first one is somehow connected with a single client. It maintains the state for that client, can be used only by that client and when the client "dies" then the session bean is "lost".

A Stateless Session Bean doesn't maintain any state and there is no guarantee that the same client will use the same stateless bean, even for two calls one after the other. The lifecycle of a Stateless Session EJB is slightly different from the one of a Stateful Session EJB. Is EJB Container's responsability to take care of knowing exactly how to track each session and redirect the request from a client to the correct instance of a Session Bean. The way this is done is vendor dependant, and is part of the contract.

Q)What is the default transaction attribute for an EJB?

There is no default transaction attribute for an EJB.
Deployer must specify a value for the transaction attribute for those methods having container managed transaction.
In WebLogic, the default transaction attribute for EJB is SUPPORTS.
WAS6.0 its "Required".

Q) What is the need of Remote and Home interface. Why cant it be in one?

The main reason is because there is a clear division of roles and responsabilities between the two interfaces. The home interface is your way to communicate with the container, that is who is responsable of creating, locating even removing one or more beans. The remote interface is your link to the bean, that will allow you to remotely access to all its methods and members. As you can see there are two distinct elements (the container and the beans) and you need two different interfaces for accessing to both of them.

Q) What is the diffrence between Bean Managed Persistance and Container Managed Persistance?

CMP means Container Managed Persistence. When we write CMP bean , we dont need to write any JDBC code to connect to Database. The container will take care of connection our enitty beans fields with database. The Container manages the persistence of the bean. Absolutely no database access code is written inside the bean class.

BMP means Bean Managed Persistence. When we write BMP bean, it is programmer responsiblity to write JDBC code to connect to Database.

Q)Why is ejbFindByPrimaryKey mandatory?

An Entity Bean represents persistent data that is stored outside of the EJB Container/Server. The ejbFindByPrimaryKey is a method used to locate and load an Entity Bean into the container, similar to a SELECT statement in SQL. By making this method mandatory, the client programmer can be assured that if they have the primary key of the Entity Bean, then they can retrieve the bean without having to create a new bean each time

Q)What are the Differences between EJB 3.0 and EJB 2.1?

1)EJB 3.0 allows developers to program EJB components as ordinary Java objects with ordinary Java business interfaces rather than as heavy weight components like EJB 2 (home,remote).

2)In EJB 3.0 you can use annotaion or deployment descriptors but in
EJB 2 you have to use deployment descriptors.

3) EJB 3 introduced persistence API for database access. In EJB 2 you can use Entity bean.

4) EJB 3.0 is much faster the EJB 2.

Ajax Interview Questions

2009-01-11T09:09:00.002-08:00

1) What is AJAX?

AJAX stands for Asynchronous JavaScript And XML.

With AJAX you can create better, faster, and more user-friendly web applications.

AJAX is based on JavaScript and HTTP requests.

2)What is XMLHttpRequest Object ?

Your JavaScript communicates directly with the server, through the JavaScript XMLHttpRequest object

By using the XMLHttpRequest object, a web developer can update a page with data from the server after the page has loaded!

3)Can Ajax be implemented in browsers that do not support the XmlHttpRequest object?

Yes. This is possible using remote scripts.

4)How to we create an XmlHttpRequest object for Internet Explorer? How is this different for other browsers?

For Internet Explorer, an ActiveXObject is used for declaring an XmlHttpRequest object in Javascript.
//Code as below for IE:
xmlHttpObject = new ActiveXObject("Msxml2.XMLHTTP");
//For Other browsers, code as below:
xmlHttpObject = new XMLHttpRequest();
Note that XmlHttpObject used above is simply a variable for the respective browsers.

5)What are the properties of the XmlHttpRequest object? What are the different types of readyStates in Ajax?

i) onreadyStateChange - This function is used to process the reply from the web server.
ii) readyState - This property holds the response status of the web server. There are 5 states:
1 - request not yet initialized
2 - request now set
3 - request sent
4 - request processing
5 - request completes

Q)Which request is better with AJAX, Get or Post?

AJAX requests should use an HTTP GET request while retrieving data where the data does not change for a given URL requested. An HTTP POST should be used when state is updated on the server. This is in line with HTTP idempotency recommendations and is highly recommended for a consistent web application architecture.

Q)When do I use a synchronous versus a asynchronous request?

They don't call it AJAX for nothing! A synchronous request would block in page event processing and I don't see many use cases where a synchronous request is preferable

Q)Explain limitations of Ajax.

Back functionality cannot work because the dynamic pages don’t register themselves to the browsers history engine..........

Q)List out differences between AJAX and JavaScript.

Ajax is Asynchronous Java Script and XML. Here on Ajax sending request to the server, one needn’t wait for the.......

Q)When should AJAX NOT be used?

If the page is expected to be shown in a search engine like Google. Since Web crawlers don’t execute...............

Q)Are there any security issues with AJAX?

JavaScript is in plain view to the user with by selecting view source of the page. JavaScript can not access the local filesystem without the user's permission. An AJAX interaction can only be made with the servers-side component from which the page was loaded. A proxy pattern could be used for AJAX interactions with external services. You need to be careful not to expose your application model in such as way that your server-side components are at risk if a nefarious user to reverse engineer your application. As with any other web application, consider using HTTPS to secure the connection when confidential information is being exchanged.

Hibernate Interview Questions

2009-01-11T09:09:00.001-08:00

Q. What is ORM?

ORM stands for Object/Relational mapping. It is the programmed and translucent
perseverance of objects in a Java application in to the tables of a relational database using
the metadata that describes the mapping between the objects and the database. It works
by transforming the data from one representation to another.

Q). What is Hibernate?

Hibernate is a powerful, high performance object/relational persistence and query service.
This lets the users to develop persistent classes following object-oriented principles such
as association, inheritance, polymorphism, composition, and collections.

Q)What object states Hibernate defines and supports ?

Transient - an object is transient if it has just been instantiated using the new operator, and it is not associated with a Hibernate Session. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application doesn't hold a reference anymore.

Persistent - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a Session. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes.

Detached - a detached instance is an object that has been persistent, but its Session has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new Session at a later point in time, making it (and all the modifications) persistent again.

Q)What is lazy fetching in Hibernate?

Lazy fetching decides whether to load child objects while loading the Parent Object.

You need to do this setting respective hibernate mapping file of the parent class.
Lazy = true (means not to load child)
By default the lazy loading of the child objects is true.
This make sure that the child objects are not loaded unless they are explicitly invoked in the application by calling getChild() method on parent.In this case hibernate issues a fresh database call to load the child when getChild() is actully called on the Parent object
.But in some cases you do need to load the child objects when parent is loaded.
Just make the lazy=false and hibernate will load the child when parent is loaded from the database.

Q)how to create primary key using hibernate?

generator class="increment"

increment :: It generates identifiers of type long, short or int that are unique only when no other process is inserting data into the same table. It should not the used in the clustered environment.
identity :: It supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type long, short or int.
sequence :: The sequence generator uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type long, short or int
native :: It picks identity, sequence or hilo depending upon the capabilities of the underlying database.
assigned :: lets the application to assign an identifier to the object before save() is called. This is the default strategy if no generator element is specified.

Q. How will you configure Hibernate?

The configuration files hibernate.cfg.xml (or hibernate.properties) and mapping files *.hbm.xml are used by the Configuration class to create (i.e. configure and bootstrap hibernate) the SessionFactory, which in turn creates the Session instances. Session instances are the primary interface for the persistence service.

• hibernate.cfg.xml (alternatively can use hibernate.properties): These two files are used to configure the hibernate sevice (connection driver class, connection URL, connection username, connection password, dialect etc). If both files are present in the classpath then hibernate.cfg.xml file overrides the settings found in the hibernate.properties file.

• Mapping files (*.hbm.xml): These files are used to map persistent objects to a relational database. It is the best practice to store each object in an individual mapping file (i.e mapping file per class) because storing large number of persistent classes into one mapping file can be difficult to manage and maintain. The naming convention is to use the same name as the persistent (POJO) class name. For example Account.class will have a mapping file named Account.hbm.xml. Alternatively hibernate annotations can be used as part of your persistent class code instead of the *.hbm.xml files.

Q. What is a SessionFactory? Is it a thread-safe object?

SessionFactory is Hibernate’s concept of a single datastore and is threadsafe so that many threads can access it concurrently and request for sessions and immutable cache of compiled mappings for a single database. A SessionFactory is usually only built once at startup. SessionFactory should be wrapped in some kind of singleton so that it can be easily accessed in an application code.

SessionFactory sessionFactory = new Configuration().configure().buildSessionfactory();

Q)What is the difference between session.save() , session.saveOrUpdate() and session.persist()?
session.save() : Save does an insert and will fail if the primary key is already persistent.

session.saveOrUpdate() : saveOrUpdate does a select first to determine if it needs to do an insert or an update.
Insert data if primary key not exist otherwise update data.

session.persist() : Does the same like session.save().
But session.save() return Serializable object but session.persist() return void.
session.save() returns the generated identifier (Serializable object) and session.persist() doesn't.
Example :

System.out.println(session.save(question));
This will print the generated primary key.
System.out.println(session.persist(question));
Compile time error because session.persist() return void.

Q. What are the benefits of detached objects?

Detached objects can be passed across layers all the way up to the presentation layer without having to use any DTOs (Data Transfer Objects). You can later on re-attach the detached objects to another session.

Q. What are the Advantages and DisAdvantages of detached objects?
Advantages:

• When long transactions are required due to user think-time, it is the best practice to break the long transaction up into two or more transactions. You can use detached objects from the first transaction to carry data all the way up to the presentation layer. These detached objects get modified outside a transaction and later on re-attached to a new transaction via another session.

DisAdvantages

• In general, working with detached objects is quite cumbersome, and better to not clutter up the session with them if possible. It is better to discard them and re-fetch them on subsequent requests. This approach is not only more portable but also more efficient because - the objects hang around in Hibernate's cache anyway.

• Also from pure rich domain driven design perspective it is recommended to use DTOs (DataTransferObjects) and DOs (DomainObjects) to maintain the separation between Service and UI tiers.

Q. What is the file extension you use for hibernate mapping file?
The name of the file should be like this : filename.hbm.xml
The filename varies here. The extension of these files should be “.hbm.xml”.
This is just a convention and it’s not mandatory. But this is the best practice to follow this
extension.

Q. How do you create a SessionFactory?
Configuration cfg = new Configuration();
cfg.addResource("myinstance/MyConfig.hbm.xml");
cfg.setProperties( System.getProperties() );
SessionFactory sessions = cfg.buildSessionFactory();
First, we need to create an instance of Configuration and use that instance to refer to the
location of the configuration file. After configuring this instance is used to create the
SessionFactory by calling the method buildSessionFactory().

Q. What is the difference between the session.get() method and the
session.load() method?

Both the session.get(..) and session.load() methods create a persistent object by loading the required object from the database. But if there was not such object in the database then the method session.load(..) throws an exception whereas session.get(…) returns null.

Q. What is the difference between the session.update() method and the
session.lock() method?

Both of these methods and saveOrUpdate() method are intended for reattaching a detached object. The session.lock() method simply reattaches the object to the session without checking or updating the database on the assumption that the database in sync with the detached object. It is the best practice to use either session.update(..) or session.saveOrUpdate(). Use session.lock() only if you are absolutely sure that the detached object is in sync with your detached object or if it does not matter because you will be overwriting all the columns that would have changed later on within the same transaction.

Note: When you reattach detached objects you need to make sure that the dependent objects are reatched as well.

Q. How would you reatach detached objects to a session when the same object has already been loaded into the session?

You can use the session.merge() method call.

Q. What are the best practices for defining your Hibernate persistent classes?

1.You must have a default no-argument constructor for your persistent classes and there should be getXXX() (i.e accessor/getter) and setXXX( i.e. mutator/setter) methods for all your persistable instance variables.

2.You should implement the equals() and hashCode() methods based on your business key and it is important not to use the id field in your equals() and hashCode() definition if the id field is a surrogate key (i.e. Hibernate managed identifier). This is because the Hibernate only generates and sets the field when saving the object.

3. It is recommended to implement the Serializable interface. This is potentially useful if you want to migrate around a multi-processor cluster.

4.The persistent class should not be final because if it is final then lazy loading cannot be used by creating proxy objects.

5.Use XDoclet tags for generating your *.hbm.xml files or Annotations (JDK 1.5 onwards), which are less verbose than *.hbm.xml files.

Q. What are POJOs?

POJO stands for plain old java objects. These are just basic JavaBeans that have defined
setter and getter methods for all the properties that are there in that bean. Besides they
can also have some business logic related to that property. Hibernate applications works
efficiently with POJOs rather then simple java classes.

Q. What is object/relational mapping metadata?

ORM tools require a metadata format for the application to specify the mapping between
classes and tables, properties and columns, associations and foreign keys, Java types and
SQL types. This information is called the object/relational mapping metadata. It defines
the transformation between the different data type systems and relationship
representations.

Q. What is HQL?

HQL stands for Hibernate Query Language. Hibernate allows the user to express queries
in its own portable SQL extension and this is called as HQL. It also allows the user to
express in native SQL.

Q. What are managed associations and hibernate associations?
Associations that are related to container management persistence are called managed
associations. These are bi-directional associations. Coming to hibernate associations,
these are unidirectional.

Q. Where should SessionFactory be placed so that it can be easily accessed?
As far as it is compared to J2EE environment, if the SessionFactory is placed in JNDI
then it can be easily accessed and shared between different threads and various
components that are hibernate aware. You can set the SessionFactory to a JNDI by
configuring a property hibernate.session_factory_name in the hibernate.properties file.

Spring Interview Questions

2009-01-01T17:41:00.001-08:00

Q)What is Spring's MVC package?

This package provides a Model-View-Controller (MVC) implementation for web-applications. Spring's MVC framework is different from other implementations as it provides a clean separation between model code and web forms, and allows you to use all the other features of the Spring Framework.

Q)What are the benifits of Spring framework?

The features of Spring are as follows:

Spring has layered architecture. Use what you need and leave you don't need now.
Spring Enables POJO Programming. and POJO programming enables continuous integration and testability.
Dependency Injection and Inversion of Control Simplifies JDBC
Open source and no vendor lock-in.

Q)Explain about Spring ?

Lightweight - spring is lightweight when it comes to size
and transparency. The basic version of spring framework is around 1MB.
And the processing overhead is also very negligible.

Inversion of control (IoC) - Loose coupling is achieved in
spring using the technique Inversion of Control. The objects give their
dependencies instead of creating or looking for dependent objects.

Aspect oriented (AOP) - Spring supports Aspect oriented
programming and enables cohesive development by separating application
business logic from system services.

Container - Spring contains and manages the life cycle and
configuration of application objects.

Framework - Spring provides most of the intra functionality
leaving rest of the coding to the developer.

Q)What is Inversion of Control(or Dependency Injection)?

The basic concept of the Inversion of Control pattern (also known as dependency injection) is that you do not create your objects but describe how they should be created. You don't directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (in the case of the Spring framework, the IOC container) is then responsible for hooking it all up.

i.e., Applying IoC, objects are given their dependencies at creation time by some external entity that coordinates each object in the system. That is, dependencies are injected into objects. So, IoC means an inversion of responsibility with regard to how an object obtains references to collaborating objects.

Q)What are the features of IOC (Dependency Injection)?

Benefits of IOC (Dependency Injection) are as follows:

IOC containers support eager instantiation and lazy loading of services. Containers also provide support for instantiation of managed objects, cyclical dependencies, life cycles management, and dependency resolution between managed objects etc.

Minimizes the amount of code in your application. With IOC containers you do not care about how services are created and how you get references to the ones you need. You can also easily add additional services by adding a new constructor or a setter method with little or no extra configuration.

Loose coupling is promoted with minimal effort and least intrusive mechanism. The factory design pattern is more intrusive because components or services need to be requested explicitly whereas in IOC the dependency is injected into requesting piece of code. Also some containers promote the design to interfaces not to implementations design concept by encouraging managed objects to implement a well-defined service interface of your own.

Q)What are the different types of Inversion of Control(dependency injection) ?

Constructor Injection:
Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator.

Setter Injection:
Setter-based DI is realized by calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

Q)What are Bean Factory and Application Context?

Bean Factory

A BeanFactory is like a factory class that contains a collection of beans. The BeanFactory holds Bean Definitions of multiple beans within itself and then instantiates the bean whenever asked for by clients.

BeanFactory is able to create associations between collaborating objects as they are instantiated. This removes the burden of configuration from bean itself and the beans client.
BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.

Application Context

A bean factory is fine to simple applications, but to take advantage of the full power of the Spring framework, you may want to move up to Springs more advanced container, the application context. On the surface, an application context is same as a bean factory.Both load bean definitions, wire beans together, and dispense beans upon request. But it also provides:

A means for resolving text messages, including support for internationalization.
A generic way to load file resources.
Events to beans that are registered as listeners.

Q) What are the common implementations of the Application Context ?

The three commonly used implementation of 'Application Context' are

ClassPathXmlApplicationContext : It Loads context definition from an XML file located in the classpath, treating context definitions as classpath resources. The application context is loaded from the application's classpath by using the code .
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
FileSystemXmlApplicationContext : It loads context definition from an XML file in the filesystem. The application context is loaded from the file system by using the code .
ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml");
XmlWebApplicationContext : It loads context definition from an XML file contained within a web application.

Q)How many major modules are there in Spring? What are they?

The core container:
The core container provides the essential functionality of the Spring framework. A primary component of the core container is the BeanFactory, an implementation of the Factory pattern. The BeanFactory applies the Inversion of Control (IOC) pattern to separate an application's configuration and dependency specification from the actual application code.

Spring context:
The Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internalization, validation, and scheduling functionality.

Spring AOP:
The Spring AOP module integrates aspect-oriented programming functionality directly into the Spring framework, through its configuration management feature. As a result you can easily AOP-enable any object managed by the Spring framework. The Spring AOP module provides transaction management services for objects in any Spring-based application. With Spring AOP you can incorporate declarative transaction management into your applications without relying on EJB components.

Spring DAO:
The Spring JDBC DAO abstraction layer offers a meaningful exception hierarchy for managing the exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the amount of exception code you need to write, such as opening and closing connections. Spring DAO's JDBC-oriented exceptions comply to its generic DAO exception hierarchy.

Spring ORM:
The Spring framework plugs into several ORM frameworks to provide its Object Relational tool, including JDO, Hibernate, and iBatis SQL Maps. All of these comply to Spring's generic transaction and DAO exception hierarchies.

Spring Web module:
The Web context module builds on top of the application context module, providing contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.

Spring MVC framework:
The Model-View-Controller (MVC) framework is a full-featured MVC implementation for building Web applications. The MVC framework is highly configurable via strategy interfaces and accommodates numerous view technologies including JSP, Velocity, Tiles, iText, and POI.

Q)What is the difference between Bean Factory and Application Context ?

An application context is same as a bean factory. But application context offers much more..

Application contexts provide a means for resolving text messages, including support for i18n of those messages.

Application contexts provide a generic way to load file resources, such as images.

Application contexts can publish events to beans that are registered as listeners.

Certain operations on the container or beans in the container, which have to be handled in a programmatic fashion with a bean factory, can be handled declaratively in an application context.

ResourceLoader support: Spring’s Resource interface us a flexible generic abstraction for handling low-level resources. An application context itself is a ResourceLoader, Hence provides an application with access to deployment-specific Resource instances.

MessageSource support: The application context implements MessageSource, an interface used to obtain localized messages, with the actual implementation being pluggable

Q)How is a typical spring implementation look like ?

For a typical Spring Application we need the following files:

An interface that defines the functions.

An Implementation that contains properties, its setter and getter methods, functions etc.,

Spring AOP (Aspect Oriented Programming)

A XML file called Spring configuration file.

Client program that uses the function.

Q)What is the typical Bean life cycle in Spring Bean Factory Container ?

Bean life cycle in Spring Bean Factory Container is as follows:

The spring container finds the bean’s definition from the XML file and instantiates the bean.

Using the dependency injection, spring populates all of the properties as specified in the bean definition

If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean’s ID.

If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.

If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization() methods will be called.

If an init-method is specified for the bean, it will be called.

Finally, if there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.

Q)What do you mean by Bean wiring ?

The act of creating associations between application components (beans) within the Spring container is reffered to as Bean wiring.

Q)What do you mean by Auto Wiring?

The Spring container is able to autowire relationships between collaborating beans. This means that it is possible to automatically let Spring resolve collaborators (other beans) for your bean by inspecting the contents of the BeanFactory. The autowiring functionality has five modes.

no

byName

byType

constructor

autodirect

Q)What is DelegatingVariableResolver?

Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard Java Server Faces managed beans mechanism which lets you use JSF and Spring together. This variable resolver is called as DelegatingVariableResolver

Q)How to integrate Java Server Faces (JSF) with Spring?

JSF and Spring do share some of the same features, most noticeably in the area of IOC services. By declaring JSF managed-beans in the faces-config.xml configuration file, you allow the FacesServlet to instantiate that bean at startup. Your JSF pages have access to these beans and all of their properties.We can integrate JSF and Spring in two ways:

DelegatingVariableResolver: Spring comes with a JSF variable resolver that lets you use JSF and Spring together.

include org.springframework.web.jsf.DelegatingVariableResolver in variable-resolver of faces-config

The DelegatingVariableResolver will first delegate value lookups to the default resolver of the underlying JSF implementation, and then to Spring's 'business context' WebApplicationContext. This allows one to easily inject dependencies into one's JSF-managed beans.

FacesContextUtils:custom VariableResolver works well when mapping one's properties to beans in faces-config.xml, but at times one may need to grab a bean explicitly. The FacesContextUtils class makes this easy. It is similar to WebApplicationContextUtils, except that it takes a FacesContext parameter rather than a ServletContext parameter.

ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());

Q)What are the difference between Spring and EJB ?

have a look at the main important differences between the two:

1) Distributed Computing – If components in your web-container need to access remote components, then EJB provides in-build support for remote method calls. The EJB container manages all RMI-IIOP connections. Spring provides support for proxying remote calls via RMI, JAX-RPC etc.
2) Transaction Support – EJB by default uses the JTA manager provided by the EJB container and hence can support XA or distributed transactions. Spring does not have default support for distributed transactions, but it can plug in a JTA Transaction manager. Both EJB and Spring allows for declarative transaction demarcation. EJB uses deployment descriptor and Spring uses AOP.
3) Persistance – Entity Beans provide CMP and BMP strategies, but my personal experience with these options has been devastating. Entity Beans are too slow!!!.
Spring integrates with Hibernate, IBatis and also has good JDBC wrapper components (JdbcTemplate).
4) Security – EJB provides support for declarative security through the deployment descriptor. But again, this incurs a heavy performance penalty and I have rarely seen projects using EJB-container managed security.

Q)What is Java Server Faces (JSF) - Spring integration mechanism?

Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard JavaServer Faces managed beans mechanism. When asked to resolve a variable name, the following algorithm is performed:

Does a bean with the specified name already exist in some scope (request, session, application)? If so, return it

Is there a standard JavaServer Faces managed bean definition for this variable name? If so, invoke it in the usual way, and return the bean that was created.

Is there configuration information for this variable name in the Spring WebApplicationContext for this application? If so, use it to create and configure an instance, and return that instance to the caller.

If there is no managed bean or Spring definition for this variable name, return null instead.

BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.

As a result of this algorithm, you can transparently use either JavaServer Faces or Spring facilities to create beans on demand.

Q)What is Significance of JSF- Spring integration ?

Spring - JSF integration is useful when an event handler wishes to explicitly invoke the bean factory to create beans on demand, such as a bean that encapsulates the business logic to be performed when a submit button is pressed.

Q)How to integrate your Struts application with Spring?

To integrate your Struts application with Spring, we have two options:

Configure Spring to manage your Actions as beans, using the ContextLoaderPlugin, and set their dependencies in a Spring context file.

Subclass Spring's ActionSupport classes and grab your Spring-managed beans explicitly using a getWebApplicationContext() method.

Q) What are ORM’s Spring supports ?

Spring supports the following ORM’s :
Hibernate
iBatis
JPA (Java Persistence API)
TopLink
JDO (Java Data Objects)
OJB

Q)How to integrate Spring and Hibernate ?

Spring and Hibernate can integrate using Spring’s SessionFactory called LocalSessionFactory. The integration process is of 3 steps.

Configure Hibernate mappings.
Configure Hibernate properties.
Wire dependant object to SessionFactory.

Q)What are the ways to access Hibernate using Spring ?

There are two ways to access Hibernate from Spring:

Through Hibernate Template.
Subclassing HibernateDaoSupport
Extending HibernateDaoSupport and Applying an AOP Interceptor

QWhat are Bean scopes in Spring Framework ?

The Spring Framework supports exactly five scopes (of which three are available only if you are using a web-aware ApplicationContext). The scopes supported are listed below:

Scope Description
singleton
Scopes a single bean definition to a single object instance per Spring IoC container.

prototype
Scopes a single bean definition to any number of object instances.

request
Scopes a single bean definition to the lifecycle of a single HTTP request; that is each and every HTTP request will have its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.

session
Scopes a single bean definition to the lifecycle of a HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.

global session
Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

Q)What is AOP?

Aspect-oriented programming, or AOP, is a programming technique that allows programmers to modularize crosscutting concerns, or behavior that cuts across the typical divisions of responsibility, such as logging and transaction management. The core construct of AOP is the aspect, which encapsulates behaviors affecting multiple classes into reusable modules.

Q)How the AOP used in Spring?

AOP is used in the Spring Framework: To provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management, which builds on the Spring Framework's transaction abstraction.To allow users to implement custom aspects, complementing their use of OOP with AOP.

Q)What are the types of the transaction management Spring supports ?

Spring Framework supports:

Programmatic transaction management.
Declarative transaction management.

Q)What are the benefits of the Spring Framework transaction management ?

The Spring Framework provides a consistent abstraction for transaction management that delivers the following benefits:

Provides a consistent programming model across different transaction APIs such as JTA, JDBC, Hibernate, JPA, and JDO.
Supports declarative transaction management.
Provides a simpler API for programmatic transaction management than a number of complex transaction APIs such as JTA.
Integrates very well with Spring's various data access abstractions.

Q)Why most users of the Spring Framework choose declarative transaction management ?

Most users of the Spring Framework choose declarative transaction management because it is the option with the least impact on application code, and hence is most consistent with the ideals of a non-invasive lightweight container.

Q)When to use programmatic and declarative transaction management ?

Programmatic transaction management is usually a good idea only if you have a small number of transactional operations.
On the other hand, if your application has numerous transactional operations, declarative transaction management is usually worthwhile. It keeps transaction management out of business logic, and is not difficult to configure.

Q)Explain about the Spring DAO support ?

The Data Access Object (DAO) support in Spring is aimed at making it easy to work with data access technologies like JDBC, Hibernate or JDO in a consistent way. This allows one to switch between the persistence technologies fairly easily and it also allows one to code without worrying about catching exceptions that are specific to each technology.

Q)What are the exceptions thrown by the Spring DAO classes ?

Spring DAO classes throw exceptions which are subclasses of DataAccessException(org.springframework.dao.DataAccessException).Spring provides a convenient translation from technology-specific exceptions like SQLException to its own exception class hierarchy with the DataAccessException as the root exception. These exceptions wrap the original exception.

Q)What is Spring's JdbcTemplate ?

Spring's JdbcTemplate is central class to interact with a database through JDBC. JdbcTemplate provides many convenience methods for doing things such as converting database data into primitives or objects, executing prepared and callable statements, and providing custom database error handling.

JdbcTemplate template = new JdbcTemplate(myDataSource);

Struts Interview Questions

2008-12-31T14:30:00.000-08:00

Q: What is Struts Framework?

A: Struts is MVC architecture and The aim of MVC architecture is to separate the business logic and data of the application from the presentation of data to the user. Following is the small description of each of the components in MVC architecture:

Controller : All the user requests to the application go through the controller. The controller intercepts the requests from view and passes it to the model for appropriate action. Based on the result of the action on data, the controller directs the user to the subsequent view
Example :: Action Servlet

Model : The model represents the data of an application. Anything that an application will persist becomes a part of model. The model also defines the way of accessing this data ( the business logic of application) for manipulation. It knows nothing about the way the data will be displayed by the application. It just provides service to access the data and modify it.
Example :: Java Bean,EJB

View : The view represents the presentation of the application. The view queries the model for its content and renders it. The way the model will be rendered is defined by the view. The view is not dependent on data or application logic changes and remains same even if the business logic undergoes modification.
Example :: Jsp,Html

Q: What is Action Class and Write code of any Action Class?

A: The class org.apache.struts.action.ActionServlet is the called the ActionServlet which plays the role of controller. All the requests to the server goes through the controller. Controller is responsible for handling all the requests.and the purpose of Action Class is to translate the HttpServletRequest to the business logic. To use the Action, we need to Subclass and overwrite the execute() method.

Here is the code of Action Class that returns the ActionForward object.

TestAction.java

package struts.com.example;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class TestAction extends Action
{
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws Exception{
return mapping.findForward("testAction");
}
}

Q: How you will make available any Message Resources Definitions file to the Struts Framework Environment?

A: Message Resources Definitions file are simple .properties files .
Message Resources Definitions files can be added to the struts-config.xml file through message-resources tag.
Example:

Q: What is ActionForm?

A: An ActionForm is a JavaBean that extends org.apache.struts.action.ActionForm. ActionForm maintains the session state for web application and the ActionForm object is automatically populated on the server side with data entered from a form on the client side.

Q: What is Struts Validator Framework and validation XML files ?
A: Struts Framework provides the functionality to validate the form data. It can be use to validate the data on the users browser as well as on the server side.

The Validator Framework uses two XML configuration files

1) validator-rules.xml
The validator-rules.xml defines the standard validation routines, these are reusable and used in validation.xml. to define the form specific validations.

2)validation.xml
The validation.xml file is used to declare sets of validations that should be applied to Form Beans. Each Form Bean you want to validate has its own definition in this file.

Q. How you will display validation fail errors on jsp page?
A: Following tag displays all the errors:
html:errors tag

Q.What are the various Struts tag libraries?
A)The various Struts tag libraries are:

Bean Tags
Logic Tags
HTML Tags
Template Tags
Nested Tags
Tiles Tags

Q)Can we have more than one struts-config.xml file for a single Struts application?
A)Yes, application can have more than one struts-config.xml for a single Struts application. They can be included in param-value of web.xml.
Example :: /WEB-INF/struts-config.xml,/WEB-INF/struts-admin.xml,/WEB-INF/struts-config-forms.xml

Q)What is DynaActionForm and how do you create DynaActionForm??

A specialized subclass of ActionForm that allows the creation of form beans with dynamic sets of properties (configured in configuration file), without requiring the developer to create a Java class for each type of form bean.

Using a DynaActionForm instead of a custom subclass of ActionForm is relatively straightforward.

In struts-config.xml: use your form-bean to be an org.apache.struts.action.DynaActionForm instead of some subclass of ActionForm

Sql Interview Questions

2008-12-30T17:44:00.000-08:00

Q What is the diffrence between delete and truncate?

A • 1)The deletion of each row gets logged in the transaction log, which makes it slow.

2)Truncate table deletes all the rows in a table, but it won’t log the deletion of each row, instead it logs the de-allocation of the data pages of the table, which makes it faster. Of course, truncate table cannot be rolled back., but the table structure and its columns, constraints, indexes etc., remains as it is.

3)Truncate table is functionally identical to delete statement with no “where clause” both remove all rows in the table. But truncate table is faster and uses fewer system and transaction log resources than delete.

4)You cannot use truncate table on a table referenced by a foreign key constraint; instead, use delete statement without a where clause. Because truncate table is not logged, it cannot activate a trigger.

5)Truncate table may not be used on tables participating in an indexed view.

Q) What are basic SQL Optimization Tips ?

1)Use views and stored procedures instead of heavy-duty queries.
2)Try to avoid using SQL Server cursors, whenever possible.
3)Try to avoid using the DISTINCT clause, whenever possible.
4)Try to restrict the queries result set by using the WHERE clause.
5)Try to avoid the HAVING clause, whenever possible.
6)Try to restrict the queries result set by returning only the particular columns from the table, not all table's columns.
7)If you need to return the total table's row count, you can use alternative way instead of SELECT COUNT(*) statement.
8)Try to use constraints instead of triggers, whenever possible.
9)Use table variables instead of temporary tables.
10)Use the select statements with TOP keyword or the SET ROWCOUNT statement, if you need to return only the first n rows.
11)Use the FAST number_rows table hint if you need to quickly return 'number_rows' rows.

Q)What are the advantages of Stored Procedures?

1)Stored Procedures are stored in the database and there is no need to transfer the code from the client to the database server,this results in much less network traffic and again improves scalability.

2)Stored Procedures are pre-compiled and executes on the database server side which is likely to me more faster and powerful

Q)How SQL Performance Tuning using Indexes?

A) Indexes directly improve the performance of database applications and looks for a specific record or set of records with a join condition,where clause,group by and order by.

Servlet Interview Questions

2008-12-30T12:24:00.000-08:00

Q: Explain the life cycle methods of a Servlet.

A: The javax.servlet.Servlet interface defines the three methods known as life-cycle method.
Initializing a Servlet:public void init(ServletConfig config) throws ServletException
Interacting with Clients:public void service( ServletRequest req, ServletResponse res) throws ServletException, IOException
Destroying a Servlet
public void destroy()
First the servlet is constructed, then initialized wih the init() method.
Any request from client are handled initially by the service() method before delegating to the doXxx() methods in the case of HttpServlet.

The servlet is removed from service, destroyed with the destroy() methid, then garbaged collected and finalized.

Q: What is the difference between HttpServlet and GenericServlet?

A: A GenericServlet has a service() method aimed to handle requests. HttpServlet extends GenericServlet and adds support for doGet(), doPost(), doHead() methods (HTTP 1.0) plus doPut(), doOptions(), doDelete(), doTrace() methods (HTTP 1.1).
Both these classes are abstract.

Q: Explain ServletContext.

A: ServletContext interface is a window for a servlet to view it's environment. A servlet can use this interface to get information such as initialization parameters for the web applicationor servlet container's version. Every web application has one and only one ServletContext and is accessible to all active resource of that application.

Q: What is the difference between Difference between doGet() and doPost()?

Answer: doGet is used when there is a requirement of sending data appended to a query string in the URL. The doGet models the GET method of Http and it is used to retrieve the info on the client from some server as a request to it. The doGet cannot be used to send too much info appended as a query stream. GET puts the form values into the URL string. GET is limited to about 256 characters (usually a browser limitation) and creates really ugly URLs.
A request string for doGet() looks like the following:
http://www.allapplabs.com/svt1?p1=v1&p2=v2&...&pN=vN

POST allows you to have extremely dense forms and pass that to the server without clutter or limitation in size. e.g. you obviously can't send a file from the client to the server via GET. POST has no limit on the amount of data you can send and because the data does not show up on the URL you can send passwords. But this does not mean that POST is truly secure. For real security you have to look into encryption which is an entirely different topic

Q: What is the difference between ServletContext and ServletConfig?

A: ServletContext: Defines a set of methods that a servlet uses to communicate with its servlet container, for example, to get the MIME type of a file, dispatch requests, or write to a log file.The ServletContext object is contained within the ServletConfig object, which the Web server provides the servlet when the servlet is initialized

ServletConfig: The object created after a servlet is instantiated and its default constructor is read. It is created to pass initialization information to the servlet

Q :: Difference between forward and sendRedirect?

A :: When you invoke a forward request, the request is sent to another resource on the server, without the client being informed that a different resource is going to process the request. This process occurs completly with in the web container.

When a sendRedirtect method is invoked, it causes the web container to return to the browser indicating that a new URL should be requested. Because the browser issues a completly new request any object that are stored as request attributes before the redirect occurs will be lost. This extra round trip a redirect is slower than forward.and you want to forward to is not in the same web application, use sendRedirect().

Q: What are the common mechanisms used for session tracking?
A: Cookies
SSL sessions
URL- rewriting

Q: Explain the directory structure of a web application.
A: The directory structure of a web application consists of two parts.
1) private directory called WEB-INF
2) public resource directory which contains public resource folder.

WEB-INF folder consists of
1. web.xml
2. classes directory
3. lib directory

Q.What is the difference between the getRequestDispatcher(String path) ServletRequest interface and ServletContext interface?

The getRequestDispatcher(String path) method of ServletRequest interface accepts parameter the path to the resource to be included or forwarded to, which can be relative to the request of the calling servlet. If the path begins with a "/" it is interpreted as relative to the current context root.

The getRequestDispatcher(String path) method of ServletContext interface cannot accepts relative paths. All path must sart with a "/" and are interpreted as relative to curent context root. If the resource is not available, or if the server has not implemented a RequestDispatcher object for that type of resource, getRequestDispatcher will return null. Your servlet should be prepared to deal with this condition.

JSP Interview Questions

2008-12-29T20:59:00.001-08:00

Q)What are Jsp Tags?

A)Directive tag
Declaration tag
Expression tag
Scriptlet tag
Declarations
This tag is used for defining the functions and variables to be used in the JSP.

Scriplets
In this tag we can insert any amount of valid java code and these codes are placed in _jspService method by the JSP engine.

Expressions
We can use this tag to output any data on the generated page. These data are automatically converted to string and printed on the output stream

Directives
In the directives we can import packages, define error handling pages or the session information of the JSP page.

language
extends
import
session
buffer
autoFlush
isThreadSafe
info
errorPage
IsErrorPage
contentType

Q)What are implicit objects?

A)Certain objects that are available for the use in JSP documents without being declared first. These objects are parsed by the JSP engine and inserted into the generated servlet.

1)request
2)response
3)pageContext
4)session
5)application
6)outconfig
7)page
8)exception

Q)Difference between forward and sendRedirect?

A)When you invoke a forward request, the request is sent to another resource on the server, without the client being informed that a different resource is going to process the request. This process occurs completly with in the web container.

When a sendRedirtect method is invoked, it causes the web container to return to the browser indicating that a new URL should be requested. Because the browser issues a completly new request any object that are stored as request attributes before the redirect occurs will be lost. This extra round trip a redirect is slower than forward.and you want to forward to is not in the same web application, use sendRedirect().

Q)What are the different scope values for the Jsp Use Bean ?
A)
1. page2. request3.session4.application

Q)Explain the life-cycle mehtods in JSP?
A)
JSP Page Translation :
java servlet file is generated from the JSP source file and the generated java servlet file is compiled into a java servlet class.

jspInit( ):
This method is called when the instance is created and it is called only once during JSP life cycle. It is called for the servlet instance initialization.
_jspService():
This method is called for every request of this JSP during its life cycle. It passes the request and the response objects. _jspService() cannot be overridden.
jspDestroy():
This method is called when this JSP is destroyed and will not be available for future requests.

Q)How can I implement a thread-safe JSP page? What are the advantages and Disadvantages of using it?

A)You can make your JSPs thread-safe by having them implement the SingleThreadModel interface. This is done by adding the directive <%@ page isThreadSafe="false" %> within your JSP page. With this, instead of a single instance of the servlet generated for your JSP page loaded in memory, you will have N instances of the servlet loaded and initialized, with the service method of each instance effectively synchronized. You can typically control the number of instances (N) that are instantiated for all servlets implementing SingleThreadModel through the admin screen for your JSP engine. More importantly, avoid using the tag for variables. If you do use this tag, then you should set isThreadSafe to true, as mentioned above. Otherwise, all requests to that page will access those variables, causing a nasty race condition. SingleThreadModel is not recommended for normal use. There are many pitfalls, including the example above of not being able to use <%! %>. You should try really hard to make them thread-safe the old fashioned way: by making them thread-safe .

Q)How can I enable session tracking for JSP pages if the browser has disabled cookies?

A)The session tracking uses cookies by default to associate a session identifier with a unique user. If the browser does not support cookies, or if cookies are disabled, you can still enable session tracking using URL rewriting. URL rewriting essentially includes the session ID within the link itself as a name/value pair. However, for this to be effective, you need to append the session ID for each and every link that is part of your servlet response. Adding the session ID to a link is greatly simplified by means of of a couple of methods: response.encodeURL() associates a session ID with a given URL, and if you are using redirection, response.encodeRedirectURL() can be used by giving the redirected URL as input. Both encodeURL() and encodeRedirectedURL() first determine whether cookies are supported by the browser; if so, the input URL is returned unchanged since the session ID will be persisted as a cookie.

multithreading interview questions

2008-12-29T16:54:00.000-08:00

1)What is Thread ?

A thread is an independent path of execution in a system.

2)What is the difference between the Thread and Runnable ?

Thread Class :: if you extend a Thread class , it does not allow to extend another class. A class extends the Thread class and overrides it's run() method.
Runnable interface :: if you implement Runnable interface ,you can extend another class. A class implements the Runnable interface, which has one method: run(). The class passes a reference to itself when it creates a thread. The thread then calls back to the run() method in the class.

3)What is multithreading and what are the methods for inter-thread communication and what is the class in which these methods are defined? -
Multithreading is the mechanism in which more than one thread run independent of each other within the process. wait (), notify () and notifyAll() methods can be used for inter-thread communication and these methods are in Object class.wait() : When a thread executes a call to wait() method, it surrenders the object lock and enters into a waiting state.notify() or notifyAll() : To remove a thread from the waiting state, some other thread must make a call to notify() or notifyAll() method on the same object.

4)What is the difference between sleep() and wait() in multithreading ?
the difference i think is that a wait() realeases the lock for the synchronized object butsleep() don't..so it may be interesting to implementthe behaviour of wait() and notify() and compare withsleep()....
Never use sleep when you are using synchronization, it could cause deadlocks.Instead, use wait as wait will release all your locks and thus reduce the chance of deadlock.Remember that your thread may be holding locks that you are unaware of so it's best to wait (not sleep).

5)What is deadlock?
- When two threads are waiting each other and can’t precede the program is said to be deadlock.

6)What is Demoniac Thread ?
A thread that exists/runs in the background.basically a low priority thread.garbage collector thread is an example for Deamon thread

7) What are the methods available in the Thread class?
1.isAlive() 2.join() 3.resume()4.suspend()5.stop()6.start()7.sleep()8.destroy()

Core Java Interview Questions

2008-12-28T17:05:00.000-08:00

1)What are Encapsulation, Inheritance Polymorphism?

- Encapsulation is the mechanism that binds together code and data it manipulates and keeps both safe from outside interference and misuse.

Inheritance is the process by which one object acquires the properties of another object.

1. class inheritance - create a new class as an extension of another class, primarily for the purposeof code reuse. That is, the derived class inherits the public methods and public data of thebase class. Java only allows a class to have one immediate base class, i.e., single classinheritance.

Polymorphism is a term that describes a situation where one name may refer to different methods. In java there are two type of polymorphism: overloading type and overriding type.

2)What are different types of access modifiers?
public: Any thing declared as public can be accessed from anywhere.
private: Any thing declared as private can’t be seen outside of its class.
protected: Any thing declared as protected can be accessed by classes in the same package and subclasses in the other packages.
default modifier : Can be accessed only to classes in the same package.

Modifier Class Package Subclass World
public ------Y--Y-------- Y-------- Y
protected---Y--Y-------- Y-------- N
default------Y--Y-------- N-------- N
private -----Y--N-------- N-------- N

3)What is the difference between Instance variable and Static Variables ?

Instance variable :: Copy belong to Particular class,and will be created with new key word
Class Variables (Static Variables) :: A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. A field defining the number of gears for a particular kind of bicycle could be marked as static since conceptually the same number of gears will apply to all instances. The code static int numGears = 6; would create such a static field. Additionally, the keyword final could be added to indicate that the number of gears will never change.

4)What is the difference between checked and unchecked exceptions?

Checked: You have to catch or declare it. It's stuff that your program can expect to go wrong and should be able to deal with.
Unchecked: You don't have to catch (in fact, usually shouldn't) or declare it. It's stuff that you can't anticipate or can't really do anything about--like a bug in a method you're calling, or a problem in the VM.
RuntimeException and its children are Exceptions that are for program bugs. Error and its children are for VM problems.
You don’t need to declare unchecked Exceptions, those that derive from java.lang.Error and java.lang.RuntimeException, in your throws clauses. Checked Exceptions usually derive from java.lang.Exception.

5)What is difference between overloading and overriding?
a) In overloading, there is a relationship between methods available in the same class whereas in overriding, there is relationship between a superclass method and subclass method.
b) Overloading does not block inheritance from the superclass whereas overriding blocks inheritance from the superclass.
c) In overloading, separate methods share the same name whereas in overriding, subclass method replaces the superclass.
d) Overloading must have different method signatures whereas overriding must have same signature.

6)What is the difference between this() and super()?
this() can be used to invoke a constructor of the same class whereas super() can be used to invoke a super class constructor.

7)What is the difference between abstract class and interface?
a) All the methods declared inside an interface are abstract whereas abstract class must have at least one abstract method and others may be concrete or abstract. b) In abstract class, key word abstract must be used for the methods whereas interface we need not use that keyword for the methods. c) Abstract class must have subclasses whereas interface can’t have subclasses.

8)What is the difference between String and String Buffer?
a) String objects are constants and immutable whereas StringBuffer objects are not. b) String class supports constant strings whereas StringBuffer class supports growable and modifiable strings.

9)What is the difference between set and list?
- Set stores elements in an unordered way but does not contain duplicate elements, whereas list stores elements in an ordered way but may contain duplicate elements.

10)What is final, finalize() and finally?
- final : final keyword can be used for class, method and variables. A final class cannot be subclassed and it prevents other programmers from subclassing a secure class to invoke insecure methods. A final method can’t be overridden. A final variable can’t change from its initialized value.
finalize() : finalize() method is used just before an object is destroyed and can be called just prior to garbage collection.
finally : finally, a key word used in exception handling, creates a block of code that will be executed after a try/catch block has completed and before the code following the try/catch block. The finally block will execute whether or not an exception is thrown. For example, if a method opens a file upon exit, then you will not want the code that closes the file to be bypassed by the exception-handling mechanism. This finally keyword is designed to address this contingency.

11)What is Garbage Collection and how to call it explicitly?
- When an object is no longer referred to by any variable, java automatically reclaims memory used by that object. This is known as garbage collection. System. gc() method may be used to call it explicitly.

12)What are Transient and Volatile Modifiers?
Transient: The transient modifier applies to variables only and it is not stored as part of its object’s Persistent state. Transient variables are not serialized.
Volatile: Volatile modifier applies to variables only and it tells the compiler that the variable modified by volatile can be changed unexpectedly by other parts of the program.

13)What are inner class and anonymous class?
Inner class : classes defined in other classes, including those defined in methods are called inner classes. An inner class can have any accessibility including private.
Anonymous class : Anonymous class is a class defined inside a method without a name and is instantiated and declared in the same place and cannot have explicit constructors.

14)Can you have an inner class inside a method and what variables can you access?
- Yes, we can have an inner class inside a method and final variables can be accessed.

15)What is the difference between process andthread?
Process is a program in execution whereas thread is a separate path of execution in a program.

16)What is multithreading and what are the methods for inter-thread communication and what is the class in which these methods are defined?
- Multithreading is the mechanism in which more than one thread run independent of each other within the process. wait (), notify () and notifyAll() methods can be used for inter-thread communication and these methods are in Object class.
wait() : When a thread executes a call to wait() method, it surrenders the object lock and enters into a waiting state.
notify() or notifyAll() : To remove a thread from the waiting state, some other thread must make a call to notify() or notifyAll() method on the same object.

17)What is the class and interface in java to create thread and which is the most advantageous method?
- Thread class and Runnable interface can be used to create threads and using Runnable interface is the most advantageous method to create threads because we need not extend thread class here.

18)What are the states associated in the thread?
- Thread contains ready, running, waiting and dead states.

19)What is synchronization?
- Synchronization is the mechanism that ensures that only one thread is accessed the resources at a time.

20)When you will synchronize a piece of your code?
- When you expect your code will be accessed by different threads and these threads may change a particular data causing data corruption.

21)What is deadlock?
- When two threads are waiting each other and can’t precede the program is said to be deadlock.

22)What is daemon thread and which method is used to create the daemon thread?
- Daemon thread is a low priority thread which runs intermittently in the back ground doing the garbage collection operation for the java runtime system. setDaemon method is used to create a daemon thread.

23)What are Vector, Hashtable, LinkedList and Enumeration?
- Vector : The Vector class provides the capability to implement a growable array of objects. Hashtable : The Hashtable class implements a Hashtable data structure. A Hashtable indexes and stores objects in a dictionary using hash codes as the object’s keys. Hash codes are integer values that identify objects. LinkedList: Removing or inserting elements in the middle of an array can be done using LinkedList. A LinkedList stores each object in a separate link whereas an array stores object references in consecutive locations. Enumeration: An object that implements the Enumeration interface generates a series of elements, one at a time. It has two methods, namely hasMoreElements() and nextElement(). HasMoreElemnts() tests if this enumeration has more elements and nextElement method returns successive elements of the series.

24)What is Singleton Class ?

Singleton ensure that the user can create only one instance of this class and provides access to this object from all areas of the application

public class ClassSingleton
{
private static ClassSingleton instance = null;
protected ClassSingleton()
{
// Exists only to defeat instantiation.
}
public static ClassSingleton getInstance()
{
if(instance == null)
{
instance = new ClassSingleton();
}
return instance;
}
}

25)What is the diffrence between Double vs BigDecimal ?

Double ::The Double class wraps a value of the primitive type double in an object. An object of type Double contains a single field whose type is double.

In addition, this class provides several methods for converting a double to a String and a String to a double, as well as other constants and methods useful when dealing with a double.

BigDecimal :: BigDecimal extends Number implements Comparable

It allows greater preceision than Double.

The BigDecimal class gives its user complete control over rounding behavior.

The BigDecimal class provides operations for arithmetic, scale manipulation, rounding, comparison, hashing, and format conversion. The toString() method provides a canonical representation of a BigDecimal.

Immutable, arbitrary-precision signed decimal numbers. A BigDecimal consists of an arbitrary precision integer unscaled value and a 32-bit integer scale.

26)What is the diffrence between Vector and ArrayList?

Vector and ArrayList both of these classes are implemented using dynamically resizable
The Vector is synchronized and the ArrayList is not synchronized
The Vector class is less efficient than the ArrayList class mainly because the Vector class is synchronized

27) Is it possible to override the main method?
NO, because main is a static method. A static method can't be overridden in Java.

28)What are the diffrence between JDK, JRE and JVM ?
JDK: Java Developer Kit contains tools needed to develop the Java programs, and JRE to run the programs. The tools include compiler (javac.exe), Java application launcher (java.exe), Appletviewer, etc…

Compiler converts java code into byte code. Java application launcher opens a JRE, loads the class, and invokes its main method.

You need JDK, if at all you want to write your own programs, and to compile them. For running java programs, JRE is sufficient.

JRE: Java Runtime Environment contains JVM, class libraries, and other supporting files. Actually JVM runs the program, and it uses the class libraries, and other supporting files provided in JRE. If you want to run any java program, you need to have JRE installed in the system.

JVM: Java Virtual Machine interprets the bytecode into the machine code depending upon the underlying operating system and hardware combination. It is responsible for all the things like garbage collection, array bounds checking, etc… JVM is platform dependent.

The JVM is called "virtual" because it provides a machine interface that does not depend on the underlying operating system and machine hardware architecture. This independence from hardware and operating system is a cornerstone of the write-once run-anywhere value of Java programs.

GWT DecimalFormat Example

2008-12-24T20:53:00.000-08:00

public class NumberFormat
extends java.lang.Object
extends java.lang.Object

Formats and parses numbers using locale-sensitive patterns.

This class provides comprehensive and flexible support for a wide variety of
localized formats, including

Locale-specific symbols such as decimal point, group separator,
digit representation, currency symbol, percent, and permill

Numeric variations including integers ("123"), fixed-point
numbers ("123.4"), scientific notation ("1.23E4"), percentages ("12%"), and
currency amounts ("$123")

Predefined standard patterns that can be used both for parsing
and formatting, including decimal,
currency,
percentages, and
scientific

Custom patterns and supporting features designed to make it
possible to parse and format numbers in any locale, including support for
Western, Arabic, and Indic digits

Patterns

Pattern Grammar (BNF)

Notation:

X* 0 or more instances of X
X? 0 or 1 instances of X
XY either X or Y
C..D any character from C up to D, inclusive
S-T characters in S, except those in T

The first subpattern is for positive numbers. The second (optional) subpattern is for negative numbers.

Example

public class NumberFormatExample implements EntryPoint {

  public void onModuleLoad() {
    NumberFormat fmt = NumberFormat.getDecimalFormat();
    double value = 12345.6789;
    String formatted = fmt.format(value);
    // Prints 1,2345.6789 in the default locale
    GWT.log("Formatted string is" + formatted, null);

    // Turn a string back into a double
    value = NumberFormat.getDecimalFormat().parse("12345.6789");
    GWT.log("Parsed value is" + value, null);

    // Scientific notation
    value = 12345.6789;
    formatted = NumberFormat.getScientificFormat().format(value);
    // prints 1.2345E4 in the default locale
    GWT.log("Formatted string is" + formatted, null);

    // Currency
    fmt = NumberFormat.getCurrencyFormat();
    formatted = fmt.format(123456.7899);
    // prints $123,456.79 in the default locale
    GWT.log("Formatted currency is" + formatted, null);

    // Custom format
    value = 12345.6789;
    formatted = NumberFormat.getFormat("000000.000000").format(value);
    // prints 012345.678900 in the default locale
    GWT.log("Formatted string is" + formatted, null);
  }
}

Constructor Detail

NumberFormat


protected NumberFormat(com.google.gwt.i18n.client.constants.NumberConstants numberConstants,
                       java.lang.String pattern,
                       com.google.gwt.i18n.client.impl.CurrencyData cdata,
                       boolean userSuppliedPattern)

Constructs a format object based on the specified settings.

NumberFormat

protected NumberFormat(java.lang.String pattern,
                       com.google.gwt.i18n.client.impl.CurrencyData cdata,
                       boolean userSuppliedPattern)

Constructs a format object for the default locale based on the specified
settings.

Method Detail

getCurrencyFormat


public static NumberFormat getCurrencyFormat()

Provides the standard currency format for the default locale.

getCurrencyFormat
public static NumberFormat getCurrencyFormat(java.lang.String currencyCode)

Provides the standard currency format for the default locale using a
specified currency.

getDecimalFormat


public static NumberFormat getDecimalFormat()

Provides the standard decimal format for the default locale.

Returns:

a NumberFormat capable of producing and consuming
decimal format for the default locale

getFormat
public static NumberFormat getFormat(java.lang.String pattern)

Gets a NumberFormat instance for the default locale using
the specified pattern and the default currencyCode.

Parameters:: pattern - pattern for this formatter
Returns:: a NumberFormat instance
Throws:: java.lang.IllegalArgumentException - if the specified pattern is invalid

getFormat

public static NumberFormat getFormat(java.lang.String pattern,
                                     java.lang.String currencyCode)

Gets a custom NumberFormat instance for the default locale
using the specified pattern and currency code.

getPercentFormat


public static NumberFormat getPercentFormat()

Provides the standard percent format for the default locale.

Returns:

a NumberFormat capable of producing and consuming
percent format for the default locale

getScientificFormat


public static NumberFormat getScientificFormat()

Provides the standard scientific format for the default locale.

Returns:

a NumberFormat capable of producing and consuming
scientific format for the default locale

format


public java.lang.String format(double number)

This method formats a double to produce a string.
Parameters:

getPattern
public java.lang.String getPattern()

Returns the pattern used by this number format.

parse
public double parse(java.lang.String text)

throws java.lang.NumberFormatException

Parses text to produce a numeric value. A NumberFormatException is
thrown if either the text is empty or if the parse does not consume all
characters of the text.

parse
public double parse(java.lang.String text,

int[] inOutPos)

throws java.lang.NumberFormatException

Parses text to produce a numeric value.

The method attempts to parse text starting at the index given by pos. If
parsing succeeds, then the index of pos is updated to the
index after the last character used (parsing does not necessarily use all
characters up to the end of the string), and the parsed number is returned.
The updated pos can be used to indicate the starting point
for the next call to this method. If an error occurs, then the index of
pos is not changed.