JAVA BY KHALEEL

ListIterator

2011-06-22T15:50:00.001+05:30

import java.util.*;
public class ListIteratorDemo {
    public static void main(String[] args) {
        LinkedList l=new LinkedList();
        l.add("sharukh");
        l.add("aamir");
        l.add("salman");
        ListIterator li=l.listIterator();
        while(li.hasNext()){
            System.out.println(li.next());

        }
        while(li.hasPrevious()){
            System.out.println(li.previous());
        }
    }
}

Iterator

2011-06-22T11:11:00.003+05:30

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorArray {

    public static void main(String[] args) {
        ArrayList a=new ArrayList();
        for(int i=0;i<15;i++){
            a.add(i);
        }
        Iterator i=a.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
    }

}

Enumeration

2011-06-22T10:41:00.002+05:30

import java.util.*;
public class EnumerationDemo {


    public static void main(String[] args) {
        Vector v=new Vector();
        for(int i=0;i<10;i++){
            v.addElement(i);
        }
        Enumeration e=v.elements();
        while(e.hasMoreElements()){
            Integer g=(Integer) e.nextElement();
            System.out.println(g);
        }
        /*while(e.hasMoreElements()){
            System.out.println(e.nextElement());
        }*/
        }
    }

Stack

2011-06-21T18:42:00.002+05:30

import java.util.*;
public class StackDemo {

    public static void main(String[] args) {
        Stack s=new Stack();
        s.push("A");
        s.push("B");
        s.push("C");
        System.out.println(s);
        System.out.println(s.capacity());
        System.out.println(s.search("C"));
        System.out.println(s.search("B"));
        System.out.println(s.search("A"));
        System.out.println(s);

    }

}

Vector

2011-06-21T18:41:00.002+05:30

import java.util.*;
public class VectorDemo {


    public static void main(String[] args) {
        Vector v=new Vector();
        System.out.println(v.capacity());
        for(int i=0;i<10;i++){
            v.add(i);
        }
       System.out.println(v.capacity());
       v.addElement("A");
       System.out.println(v.capacity());
       System.out.println(v);
    }

}

LinkedList

2011-06-21T18:38:00.002+05:30

import java.util.*;
public class LinkedListDemo {


    public static void main(String[] args) {
        LinkedList l=new LinkedList();
        System.out.println("=============");
        System.out.println(l.size());
        l.add("khaleel");
        l.add("khaleel");
        l.add("bhaskar");
        l.add("murali");
        l.add("murali");
        l.add(null);
        l.add(null);
        l.add(new Integer(10));
        System.out.println(l);
        l.set(1, "killer");
        System.out.println(l);
        l.addLast("centris");
        System.out.println(l);
        l.addFirst("hero");
        //l.removeFirst();
        System.out.println(l);
        System.out.println(l.size());
    }

}

ArrayList

2011-06-21T18:36:00.002+05:30

import java.util.*;
public class ArrayListDemo {

    public static void main(String[] args) {
        ArrayList a=new ArrayList();
        System.out.println(a.size());
        a.add("khaleel");
        a.add("baskar");
        a.add("murali");
        a.add("khaleel");
        a.add(null);
        a.add(new Integer(20));
        a.add(new String("hero"));
        ArrayList b=(ArrayList)a.clone();
        System.out.println(a);
        System.out.println(b);
        System.out.println(a.size());
    }

}

Hibernate configuration file to connect Mysql

2011-06-17T14:54:00.000+05:30

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">


<hibernate-configuration>

    <session-factory>

        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://192.168.1.101:3306/atrdev</property>
        <property name="hibernate.connection.username">atrdev</property>
        <property name="connection.password">centris</property>
        <property name="connection.pool_size">10</property>
        <property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>
        <property name="show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <mapping resource="com/khaleelsoftsol/atr/dao/sessionfactory/AtrEmployeeInfo.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

Building HelloWorld using Ant

2011-06-08T12:04:00.000+05:30

Building HelloWorld with Ant

The best way to learn Ant is to build a very simple Java class using our build file. We'll need two files for our example: the Java source class and our build.xml file. Open your favorite text editor and enter the code in Listing 16.5 and 16.6. Save your Java file as HelloWord.java, and your Ant file as build.xml.

Listing 16.5 HelloWorld Sample Class

public class HelloWorld{

public static void main(String []args){

System.out.println("Hello World!");

}

Listing 16.6 HelloWorld Ant Build File (build.xml)

</target>

</target>

</project>

Let's take a line-by-line look at our build file:

Line 1: We set the name of our project and the default target.
Line 2: We use a user-defined property to store our build output directory name (output in our case).
Line 3: We define the first of our two targets. The init target initializes or prepares the output directory.
Line 4: We perform a recursive delete on our output directory.
Line 5: We create the output directory using our build.dir property. Ant will replace ${"build.dir"} with the value of the build.dir property.
Line 7: We define our main target and include a dependency on the init target. This means that the target compile will execute init before it begins its own tasks.
Line 8: We use the javac task to call the Java compiler on any .java files located in the current folder. The destdir attribute holds the value of our output directory.
All that remains now is to run Ant across our build file. We're using the default filename (build.xml), so there is no need to specify the build file when we invoke Ant. Open a command window and navigate to the folder you saved your sample files in. We've used c:\ant as our source folder, but usually your build root will exist under your main source or project directory. To build HelloWorld, simply type Ant <enter> at the command prompt. You should see output we have displayed in Figure 16.3.
Figure 16.3. Building HelloWorld with Ant.
Congratulations, you've built your first application with Ant! You'll find the result of the build, Helloworld.class, in the output directory. We caused Ant to execute the default target (compiler) by not specifying any startup parameters. It's likely that you'll want to call particular targets, such as a release or debug build. In our case, we'll call the init target to clear out the results of our sample build. To do this, we run Ant with
Ant init
Figure 16.4 shows Ant running out init target, clearing out the directory structure.
Figure 16.4. Calling the init target with Ant.

Finally, we can get a listing that describes the build file by calling Ant with the projecthelp switch. To run this enter the following at the command prompt:
Ant -projecthelp
The projecthelp switch causes Ant to parse through your build file and print out the description attributes it finds. Figure 16.5 illustrates the results of executing Ant with projecthelp on our sample build file.
Figure 16.5. Displaying build file descriptions with Ant.
Most of this hour has been slanted toward Java development, but we don't want to leave Microsoft readers in the cold! With this in mind, we'll end with some tips to using Ant with Microsoft .NET.

ANT Description

2011-06-08T11:55:00.001+05:30

The Ant Build File

Ant is driven by a build file that describes the projects, dependencies, and tasks required to build your application. The build file is written in XML and, as such, is in a humanreadable format. The Ant build file normally resides in the project's base build directory or folder. By default, Ant looks for a file called build.xml in the current directory, reads, parses, and then executes the contents. Most builds follow a similar pattern as we've outlined in Figure 16.2:

Figure 16.2. The Ant build process.

Ant will access the source control repository to extract the latest source code, clean or prepare the target folders, compile, and then deploy to some kind of staging area for functional tests. In our example, a step to run a suite of automated unit tests is also included, the output of which we could report via XML to the project Web site.

The build file has many XML elements, but the most important are the project, target, and task elements. Each build will have one project element that, in turn, has many possible targets such as debug, release, and test builds. The target is created by a series of tasks that describe the actions to take. The task, then, is where the actual work takes place. Examples of tasks are operating system–level commands such as make directory or delete file. Perhaps the easiest way to learn about the structure of the build file is by looking at an example file. Listing 16.4 shows the basic layout of the build file:

Listing 16.4 The Ant Build File Layout

</javac>

</target>

</project>

The build file example will compile all the Java source files in the current directory (as denoted by .). All build files require one <project> element and at least one <target> element. Our project is called test, and the default target is all.

Projects

The project tag is the top-level attribute in the build file and describes the project itself. The project tag has three attributes: name, default, and basedir, see Table 16.2.

Table 16.2. Project Tag Attributes

Attribute	Description
name	The name of the project.
default	The default target to use when no target is supplied.
basedir	The base directory from which all path calculations are done. This attribute might be overridden by setting the basedir property beforehand. When this is done, it must be omitted in the project tag. If neither the attribute nor the property has been set, the parent directory of the build file will be used.

Targets

The target tag defines a collection of Ant tasks and can depend on other targets. You might have a target for compiling, for example, and a target for creating a distributable. You can only build a distributable when you have compiled first, so the distribute target depends on the compile target. Ant resolves these dependencies.

It should be noted that Ant's depends attribute only specifies the order in which targets should be executed. Ant tries to execute the targets in the depends attribute in the order they appear (from left to right). A target gets executed only once, even when more than one target depends on it.

A target also has the capability to perform its execution if (or unless) a property has been set. This allows, for example, better control on the building process depending on the state of the system (Java version, operating system, command-line property defines, and so on). To make a target aware of this property, you should add the if (or unless) attribute with the name of the property that the target should react to. For example:

The target will always be executed, if no if or unless attribute is present. The optional description attribute can be used to provide a one-line description of this target, which is printed by the -projecthelp command-line option.

It is a good practice to place your tstamp (timestamp) tasks in a so-called initialization target on which all other targets depend. Make sure that target is always the first one in the depends list of the other targets. Table 16.3 lists the target attribute for us.

Table 16.3. Target Tag Attributes

Attribute	Description
name	The name of the target.
depends	A comma-separated list of names of targets on which this target depends.
if	The name of the property that must be set for this target to execute.
unless	The name of the property that must not be set for this target to execute.
description	A short description of this target's function.

Tasks

A task is a piece of code that can be executed. A task can have multiple attributes or arguments. The value of an attribute might contain references to a property. These references will be resolved before the task is executed.

Tasks have a common structure:

Where name is the identifier of the task, and where the attribute (as many as you like from 1–N) are paired with a value (from 1–N). As in the previous example, attribute1 is the name of the attribute and value1 is the value associated with attribute1; similarly for attribute2. There is a set of built-in tasks, along with a number of optional tasks; it's also very easy to write your own. All tasks share a task name attribute, and Ant will use the value for the logging of any messages generated by the build.

Tasks can be assigned an id attribute, as well:

Where taskname is the name of the task, and taskID is a unique name for this task. You can refer to the corresponding task object in scripts or other tasks via this name.

Properties

A project can have a set of properties. These might be set in the build file by the property task, or might be set outside Ant. A property has a name and a value. Properties can be used in the value of task attributes. This is done by placing the property name between "${" and "}" in the attribute value. For example, if there is a builddir property with the value build, this could be used in an attribute like this: ${builddir}/classes. This is resolved as build/classes.

Ant provides access to all system properties as if they had been defined using a <property> task. For example, ${os.name} expands to the name of the operating system. In addition to the user-defined or system properties, Ant has some built-in properties, which are listed in Table 16.4:

Table 16.4. Project Tag Attributes

Property	Description
basedir	The absolute path of the project's basedir (as set with the basedir attribute of <project>).
ant.file	The absolute path of the build file.
ant.version	The version of Ant.
ant.project.name	The name of the project that is currently executing; it is set in the name attribute of <project>.
ant.java.version	The JVM version Ant detected; currently it can hold the values 1.1, 1.2, 1.3, and 1.4.

Now you should have a good understanding about how to run Ant and the structure of the build file. We'll put it all together in the next section and complete a simple sample build.

class.forName()

2011-06-06T15:13:00.002+05:30

Class.forName():

Class.forName() is used to load the class on to the JVM without creating the object.
    We do this because to execute if any static blocks are available.

Ex:
    public class Test{
    static{
        System.out.prinln("we are in static block of test class");
        }
    public void display(){
        System.out.prinln("we are in display method");
    }
      }

    public class MyApp{
    p.s.v.main(String args[]){
    try{
        Class c=Class.forName("Test");
        System.out.prinln(c.getName());
        System.out.prinln(c.getPackage());
        Object o=c.newInstace();
        Test t=(Test)o;
        t.display();
       }
    }
When we execute the above program Test class will be loaded into JVM without creating object of Test class.Thenafter JVM executes static block of Test class and it creates Class object and place information about class and name of package and location of Test(loaded class)class.
To get the name of the class and package we use getName and getPackage methods.
To create the object of a class we have to use newInstance method.That object is stored as super class Object.So we have to typecast from superclass object to our class(Test).

JVM Internal Architecture

2011-06-06T12:14:00.001+05:30

Java Interview Questions

2011-06-06T11:51:00.002+05:30

1)How will you convert a String array to an ArrayList object?

A.String[] stringArray = new String[] {"x", "y", "Z"};
   List list = Arrays.asList(stringArray);

2)What's the difference between the methods sleep() and wait()

A.The code sleep(1000); puts thread aside for exactly one second. The code wait(1000),

causes a wait of up to one second. A thread could stop waiting earlier if it receives

the notify() or notifyAll() call. The method wait() is defined in the class Object and

the method sleep() is defined in the class Thread.

3)You are planning to do an indexed search in a list of objects. Which of the two Java

collections should you use: ArrayList or LinkedList?

A.ArrayList

4)How would you make a copy of an entire Java object with its state?

A.Have this class implement Cloneable interface and call its method clone().

5)There are two classes: A and B. The class B need to inform a class A when some important

event has happened. What Java technique would you use to implement it?

A. If these classes are threads then consider notify() or notifyAll(). For regular classes

one can use the Observer interface.

Treeset

2011-06-06T10:58:00.000+05:30

/ retrieving sorted and unique data from database using treeset
package com.centris.atr.util;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSort {

    /**
    * @param args
    */

        public static void main(final String[] args) {
        TreeSet treeset = new TreeSet();
        treeset.add("Lincoln");
        treeset.add("Clinton");
        treeset.add("Obama");
        treeset.add("Obama");
        treeset.add("Regan");
        treeset.add("Washington");
        treeset.add("Bush");
        System.out.println("TreeSet with Prez:");
        Iterator iterator = treeset.iterator();
        while (iterator.hasNext()) {
        Object object = iterator.next();
        System.out.println(object);
        }
    }

}

What are implicit objects

2011-06-03T13:05:00.002+05:30

What are implicit objects

Implicit objects are Instances of some of the Servlet API classes, which are available to all the JSP pages to be used within Scriptlets and expressions. You don't need to instantiate them, they are available Implicitly, and hence the name Implicit Objects. Implicit objects has standard variable names and are available in all JSP without writing any extra code.

If developer's does not instantiate implicit objects then who does it ! The answer is, JSP container. It is the responsibility of container to instantiate Implicit objects and make them available to JSP pages.

What implicit objects are used for !

Depending upon the type of the object, an Implicit object can be used to do various things. For example, request implicit object can be used to obtain request parameters, out implicit object can be used to write to the response. application implicit object can be used to obtain the ServletContext attributes.

Following is a list of all JSP implicit objects.

request
response
out
pageContext
session
application
config
page
exception

JSP implicit objects

Now let's look at each of the Implicit objects, which type of object it is and some examples of how it can be used.
The request object

Variable name : request
Type : javax.servlet.http.HttpServletRequest
The request object provides acceess to information like HTTP headers, request parameters, and request attributes.
Example

Print value of a named request parameter using expression

<%= request.getParameter("name") %>

Access the value of a request attribute of type String inside scriptlet.

<% String name = request.getAttribute("name"); %>

The response object

Variable name : response
Type : javax.servlet.http.HttpServletResponse

The response object is an instance of HttpServletResponse. The response object can be used for things like setting a response header and sending a cookie.
Example

Set a cache control header.

<% response.setHeader("Cache-Control”, "no-cache"); %>

The pageContext object

Variable name : pageContext
Type : javax.servlet.jsp.PageContext

The pagecontext object provides access to page attributes, It is the convinient place to put the shared data within the page.
Example

set an attibute in pagecontext

<% pagecontext.setAttribute("name", "servletworld"); %>

Access value of a pagecontext attribute and output to response.

<%= pagecontext.getAttribute("name") %>

The session object

Variable name : session
Type: javax.servlet.http.HttpSession

The session object represents session created for a client and can be used to store and retrive data from session. The session object is not available if the session="false" is used in page directive.
Example

Store username as session attribute.

<% session.setAttribute("username", "servletworld"); %>

output the value of a session attribute.

<%= session.getAttribute("username") %>

The application object

Variable name : application
Type : avax.servlet.ServletContext

application object is an instance of ServletContext, It can be used to obtain the context parameters, or get/set context attributes.
Example

Assign value of a context init parameter to a variable.

<% String param1 = application.getInitParameter("param1"); %>

The out object

variable name : out
Type : javax.servlet.jsp.JspWriter

The out object is an instance of JspWriter that can be used to write to the response.
Example

Write the value of a session attribute to response.

<% out.write(session.getAttribute("username")); %>

The config object

Variable name : config
Type : javax.servlet.ServletConfig

The config objet can be used to access the page configuration.
Example

Get the value of a configuration parameter.

<% String param1 = config.getInitParameter("param1"); %>

The page object

Variable name : page
Type : java.lang.Object
The page object is an instance of the page's implementation servlet class. The page object can be thought of as a synonym to the 'this' keyword withi page.
The exception object

Variable name : exception
Type : java.lang.Throwable

The exception object is available within the error pages (The page with isErrorPage="true"). It represents the uncaught exception which caused the exception page to be invoked.

Note: The exception object is available in error pages only.

Java Multi Threading Interview Questions

2011-06-03T12:05:00.006+05:30

1) What are the two types of multitasking?

Ans : 1.process-based

2.Thread-based

2) What are the two ways to create the thread?

Ans : 1.by implementing Runnable

2.by extending Thread

3) What is the signature of the constructor of a thread class?

Ans : Thread(Runnable threadob,String threadName)

4) What are all the methods available in the Runnable Interface?

Ans : run()

5) What is the data type for the method isAlive() and this method is

available in which class?

Ans : boolean, Thread

6) What are all the methods available in the Thread class?

Ans : 1.isAlive()

2.join()

3.resume()

4.suspend()

5.stop()

6.start()

7.sleep()

8.destroy()

7) What are all the methods used for Inter Thread communication and what is the class in which these methods are defined?

Ans :1. wait(),notify() & notifyall()

2. Object class

8) What is the mechanisam defined by java for the Resources to be used by only one Thread at a time?

Ans : Synchronization

9) What is the procedure to own the monitor by many threads?

Ans : not possible

10) What is the unit for 1000 in the below statement?

ob.sleep(1000)

Ans : long milliseconds

11) What is the data type for the parameter of the sleep() method?

Ans : long

12) What are all the values for the following level?

max-priority

min-priority

normal-priority

Ans : 10,1,5

13) What is the method available for setting the priority?

Ans : setPriority()

14) What is the default thread at the time of starting the program?

Ans : main thread

15) The word synchronized can be used with only a method.

True/ False

Ans : False

16) Which priority Thread can prompt the lower primary Thread?

Ans : Higher Priority

17) How many threads at a time can access a monitor?

Ans : one

18) What are all the four states associated in the thread?

Ans : 1. new 2. runnable 3. blocked 4. dead

19) The suspend()method is used to teriminate a thread?

True /False

Ans : False

20) The run() method should necessary exists in clases created as subclass of thread?

True /False

Ans : True

21) When two threads are waiting on each other and can't proceed the programe is said to be in a deadlock?

True/False

Ans : True

22) Which method waits for the thread to die ?

Ans : join() method

23) Which of the following is true?

1) wait(),notify(),notifyall() are defined as final & can be called only from with in a synchronized method

2) Among wait(),notify(),notifyall() the wait() method only throws IOException

3) wait(),notify(),notifyall() & sleep() are methods of object class

1
2
3
1 & 2
1,2 & 3
Ans : D
24) Garbage collector thread belongs to which priority?

Ans : low-priority

25) What is meant by timeslicing or time sharing?

Ans : Timeslicing is the method of allocating CPU time to individual threads in a priority schedule.

26) What is meant by daemon thread? In java runtime, what is it's role?

Ans : Daemon thread is a low priority thread which runs intermittently in the background doing the garbage collection operation for the java runtime system

27) What happens when start() method is called on an already running thread?
A: IllegalStateException is thrown

28) Which is best approach to create a thread implementing Runnable or extending Thread?
A: Implementing Runnable. Because we still have opportunity to extend another class as well as implement more interfaces

Struts / Java / J2EE Frequently-Asked Interview Questions

2011-06-02T18:03:00.001+05:30

Are Struts's action classes Thread-safe?
Yes. Action classes are based on "one-instance and many-threads". This is to conserve resources and to provide the best possible throughput.

What are the various Struts Tag libraries?
There are various struts tags. But the most-repeated tags are:
struts-bean.tld
struts-html.tld
struts-logic.tld
struts-nested.tld

What is ActionMapping in struts?
Action mapping defines the flow of one request. The possible sequence is
User -> request -> Form -> Validation -> Business Code -> Forward -> JSP -> response -> User.
The components involved are Action classes, Forms and JSP.

What are the advantages of having multiple struts-config in the same application?
The implementation with many struts-config is to organize the development work, so that many people may be involved and it is some organized way of doing things. But this would result in some compromise in performance(speed). Technically there is no any difference between single and multiple struts-config files.

What are the ways in which resource file can be used in struts?
Defining message resources in struts-config file.
Programmatically using resource files in Java classes or in JSP files.

Explain the term 'architecture of the application'?
Architecture is the set of rules (or framework) to bring in some common way of assembling or using J2EE components in the application. This helps in bringing consistency between codes developed by various developers in the team.

Which is the architecture followed by struts?
Struts follows MVC architecture.

What are components corresponding o M, V and C in struts?

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. Here 'Form Bean' represents Model layer.

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. JSP represents View Layer.

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. Action classes (action servlets) represent Controller layer.

Differentiate between the terms 'Design Patterns', 'Framework' and 'Architecture'.
Design Pattern: The various solutions arrived at for the known problem. This helps to avoid re-inventing the wheel. The risk-free solution can be easily used by others. For example, singleton is the design pattern that you can use instantly to enfore one object per class. You do not need to think of this on your own.
Framework: A framework is a structure or set of rules, used to solve or address complex issues. It is basically a reusable designf for the J2EE applications. For example, Struts, JSF,etc., are the frameworks. You can use these frameworks based on the requirements of your application and each has its own set of advantages.

Architecture: It is a design that describes how the various components in the application fit together. For example, MVC is an architecture which is helpful to define how the components interact within the application.

What is the difference between ActionForm and DynaActionForm?
In action form, you need to define the form class that extends ActionForm explicitly, whereas you can define the form dynamically inside the struts-config file when using DynaActionForm.

How can you use Validator framework in struts?
Validator Frameworks are helpful when the application needs server-side validation such that the particular set of validations occur very frequently within the same application. This avoids writing complex code in validation() method in every form bean. Using validator framework, there are different pre-written validations in place. You can customize these validations in XML file.

What are client-side and server-side vaidations?
Client-side validations: These are the validations that id done using javascripts. There is always a danger involved that the user can get through (crack-through) these validations. But for some simple validations, like converting lower-case to upper-case or date validations can be done, you can use javascripts.
Server-side validations: These are the validations done in server-side using Java components (Form bean or in business logics) where the user has no chance to crookedly get through the system.

What are the advantages & differences between using validate() method in form over validations using validator framework.
Refer to the previous-answer.

Define the terms authentication and authorisation.
Authentication is the process/rule that validates if the user is allowed to access the system or not.
Authorization is the process/rule that validates if the user is allowed to access the particular part of the system or not. This occurs after user's successful authentication.

What are the components provided in J2EE to perform authentication and authorization?
Authentication – RequestProcessor and/or Filter.
Authorization - DTO, JDO or Java or Action classes.

Give the difference between between 'DispatchAction' and 'Action'.
A DispatchAction contains various different methods other than the standard execute() method in Action classes. These methods are executed based on some request parameter. For example, you can code in such a way that three buttons (namely Insert, Delete, Update) buttons correspond to different methods such as insert(), delete() and udpate(). The submit button in JSP would have the property that has the value which matches to any one of the methods defined in DispatchAction class.

What is pagination technique? How can you design them in struts?
Pagination is the technique where the bulk of results are split into different pages and only the information where the user can conveniently see are displayed in a page. (Like in Goooooogle). This can be achieved in many ways, but the simplest method is to have a query string (say http://www.testwebsite?pageNumber=2) would lead to information corresponding to resultset rows from 11 to 20. Assuming that you want to display 10 related rows of information, you can set the formula as follows:
Starting row = (pageNumber-1) * + 1 which is equal to 11.
Ending row = Starting row + which is equal to 20.

How can you populate the drop-down list using form properties?
There are many ways for this. But the best method is to use which defines collection that needs to be used to populate the drop-down list, the property to store the selected value and the collection that is used to display the labels (what we see in JSP page). For Example,

html:options collection="form-collection-property"
property="form-property"
labelProperty="form-another-collection-property"

What is the XML parser provided in struts? Can you use it for other purposes?
'Digester' framework. Yes we can use for our applications to store and parse our application-related data.

Difference between Struts 1.0 and 1.1

Perform() method was replaced by execute()
DynaActionForms are introduced.
Tiles Concept is introduced
We can write our own Controller by Inheriting RequestProcessor

how-to-integrate-ant-tool-with-eclipse?

2011-06-02T17:58:00.005+05:30

ANT Eclipse IDE(latest edition of Eclipse IDE is Galileo) integration is a very simple process as summarized in following steps:

1. As a first step, create a Java Project in Eclipse IDE.

2. Associate a build.xml with this project and ensure you put this XML at the same location as shown in package structure in Eclipse IDE :

The code of build.xml is as given below:

<?xml version="1.0" ?> 
<project name="IQJava" default="execute">

 <target name="init" depends="clean">
  <mkdir dir="build/classes" />
 </target>

 <target name="compile" depends="init">
  <javac srcdir="src" destdir="build/classes" />
 </target>
 
 <target name="execute" depends="compile">
  <java classname="com.iqjava.ant.AntExample" 
              classpath="build/classes" />
 </target>

 <target name="clean">
  <delete dir="build" />
 </target>
 
</project>

3. Run this build XML

what-is-ant-and-how-can-one-configure?

2011-06-02T17:53:00.002+05:30

ANT is a Java based build tool and helps in automating whole of build process of a Java project.
ANT uses an XML build file and by default it looks for a build file named build.xml from the directory it has been executed.

A build.xml contains several targets e.g. creating or deleting directory structure, post compilation creation of jar or ear files, extracting/unzipping jar/ear files etc.One target can depend upon one or more targets and it can contain one or more tasks.

One can download Apace Ant 1.7.1 from here.Once that is done, extract it any of your local drive. Set the system variables as follows:

ANT_HOME =D:\apache-ant-1.7.1 (Here I have extracted the ANT ZIP at D drive)
PATH = %ANT_HOME%\bin

To ensure proper installation of ANT, go to command prompt and execute the command "ant - version", you will see the installed ant version.

The execution of ANT file is done from the directory where build.xml resides and simply typing ant command on console and hit enter will start the execution of build file.

The build.xml looks like as given below:

Compilation Complete! Building .jar file Complete!

In the build.xml, element is the root element, name attribute of this represents the name of the project.

element can exist multiple times within project element and each one of them represents a single stage. In the above build.xml, we have compile target element which contains two tasks, one - and the other which builds java files.

The other target element 'compress' is dependent upon compile target element. It creates a jar file which includes all the .class files in current directory.

The echo tasks just display messages on console.

how-is-ant-property-task-used?

2011-06-02T17:49:00.000+05:30

In order to to set the Ant properties, the task is used. Once property value is set, it cannot be changed. It means they are immutable.In order to set a property to a specific value, the name and value pair is used.

Example

If you want to set a property to a location then name/location assignment is used.
To use the properties surround them with ${}.

Example

A build.xml as shown in following code box displays how effectively property tasks can be used within a build.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
37
38
39
40
41
42
43
44
45
46
47
48
49
50

what-are-design-patterns-and-why-one-needs-them?

2011-06-02T17:45:00.002+05:30

A pattern based designing approach is best suited in devising solutions for problems occurring over and over again.The design patterns are language-independent strategies for solving common object-oriented design problems.

When you design, you should have advanced knowledge of such solutions in order to overcome problems that may occur in your system. GoF, Gang-Of-Four,because of the four authors who wrote, Design Patterns: Elements of Reusable Object-Oriented Software(ISBN 0-201-63361-2) is a software engineering book describing recurring solutions to common problems in software design. The book's authors are Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. It is language independent approach of designing systems on the based of patterns.

What-is-singleton-design-pattern?

2011-06-02T17:42:00.000+05:30

The Singleton Design Pattern is a Creational type of design pattern which assures to have only a single instance of a class, as it is necessary sometimes to have just a single instance.The examples can be print spooler,database connection or window manager where you may require only a single object.

In a Singleton design pattern,there is a public, static method which provides an access to single possible instance of the class.The constructor can either be private or protected.

public class SingletonClass {
private static SingletonClass instance = null;
protected SingletonClass() {
// can not be instantiated.
}
public static SingletonClass getInstance() {
if(instance == null) {
instance = new SingletonClass();
}
return instance;
}
}

In the code above the class instance is created through lazy initialization,unless getInstance() method is called,there is no instance created.This is to ensure that instance is created when needed.

public class SingletonInstantiator {
public SingletonInstantiator() {
SingletonClass instance = SingletonClass.getInstance();
SingletonClass anotherInstance =
new SingletonClass();
...
}
}

In snippet above anotherInstance is created which is a perfectly legal statement as both the classes exist in the same package in this case 'default', as it is not required by an instantiator class to extend SingletonClass to access the protected constructor within the same package.So to avoid even such scenario, the constructor could be made private.

what-is-difference-between-abstract factory and factory method design patterns?

2011-06-02T17:37:00.001+05:30

In order to answer this question we must first understand what are Abstract Factory and Factory Method design patterns.

An Abstract Factory(AF) provides an interface for creating families of related or dependent objects without specifying their concrete classes. you usually have multiple factory implementations. Each factory implementation is responsible for creating objects that are usually in a related hierarchy.

In case of Factory Method(or simply called Factory pattern), generally a key or parameter is provided and method obtains an object of that type.The classic example can be creating a Database Connection Factory which is responsible for providing a vendor specific database connection objects(like Oracle,DB2,MS SQL Server etc.) depending upon the kind of parameter is provided.

AF is very similar to the Factory Method pattern.One difference between the two is that with the Abstract Factory pattern, a class delegates the responsibility of object instantiation to another object via composition whereas the Factory Method pattern uses inheritance and
relies on a subclass to handle the desired object instantiation.

The best example to quote of AF is EJBHome object.When a client composes the home interface and calls a create method to get the component interface. The component interface is the abstract product and the implementation is created by the container. The client composes the abstract factory (home interface) and calls a create method on the abstract factory to create the product.

In nutshell, AF is a creational pattern for the family of objects, whereas the factory method is a way to get one individual member of a family.So in a way, AF uses Factory method.

Explain Adapter Design Pattern in Java

2011-06-02T17:32:00.002+05:30

Adapter design pattern lets unrelated classes communicate and work with each other.It achieves this objective by creating new interfaces for creating compatibility amongst otherwise non communicable classes.

The adapter classes in Java API are WindowAdapter,ComponentAdapter, ContainerAdapter, FocusAdapter, KeyAdapter, MouseAdapter and MouseMotionAdapter.

In case of listener interfaces,whenever a class implements such an interface, one has to implement all of the seven methods.In case of WindowListener interface,it has seven methods.WindowAdapter class implements WindowListener interface and make seven empty implementation. When a class subclasses WindowAdapter class, one may choose the implementation of a method as per one's choice of implementation.

Adapter design pattern is also referred as Wrapper pattern when it is introduced by composition of classes.

Explain Decorator Design Pattern in Java

2011-06-02T17:30:00.000+05:30

Decorator design pattern attaches additional responsibilities or functions, dynamically or statically on an object.One can add new functionalities on an object without affecting other objects enhancing flexibility of an object.

The best example of Decorator pattern in a visual manner can be illustrated from JScrollPane object which can be used to decorate a JTextArea object or a JEditorPane object. The different borders of a window like BevelBorder, CompoundBorder, EtchedBorder TitledBorder etc. are other examples of classes working as decorators existent in Java API.

Decorator pattern can be used in a non-visual fashion. For example, BufferedInputStream, DataInputStream, and CheckedInputStream are decorating objects of FilterInputStream class. These decorators are standard Java API classes.