You are on page 1of 61

Core Java Questions #1

Q: What is the difference between an Interface and an Abstract class?

A: An abstract class can have instance methods that implement a default behavior. An
Interface can only declare constants and instance methods, but cannot implement default
behavior and all methods are implicitly abstract. An interface has all public members and no
implementation. An abstract class is a class which may have the usual flavors of class members
(private, protected, etc.), but has some abstract methods.

Q: What is the purpose of garbage collection in Java, and when is it used?

A: The purpose of garbage collection is to identify and discard objects that are no longer
needed by a program so that their resources can be reclaimed and reused. A Java object is
subject to garbage collection when it becomes unreachable to the program in which it is used.

Q: Describe synchronization in respect to multithreading.

A: With respect to multithreading, synchronization is the capability to control the access of
multiple threads to shared resources. Without synchonization, it is possible for one thread to
modify a shared variable while another thread is in the process of using or updating same shared
variable. This usually leads to significant errors.

Q: Explain different way of using thread?

A: The thread could be implemented by using runnable interface or by inheriting from the
Thread class. The former is more advantageous, 'cause when you are going for multiple
inheritance..the only interface can help.

Q: What are pass by reference and passby value?

A: Pass By Reference means the passing the address itself rather than passing the value.
Passby Value means passing a copy of the value to be passed.

Q: What is HashMap and Map?

A: Map is Interface and Hashmap is class that implements that.

Q: Difference between HashMap and HashTable?

A: The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized
and permits nulls. (HashMap allows null values as key and value whereas Hashtable doesnt
allow). HashMap does not guarantee that the order of the map will remain constant over time.
HashMap is non synchronized and Hashtable is synchronized.

Q: Difference between Vector and ArrayList?

A: Vector is synchronized whereas arraylist is not.

Q: Difference between Swing and Awt?

A: AWT are heavy-weight componenets. Swings are light-weight components. Hence swing
works faster than AWT.

Q: What is the difference between a constructor and a method?

A: A constructor is a member function of a class that is used to create objects of that class. It
has the same name as the class itself, has no return type, and is invoked using the new operator.
A method is an ordinary member function of a class. It has its own name, a return type (which
may be void), and is invoked using the dot operator.

Page 1 of 61
Q: What is an Iterators?
A: Some of the collection classes provide traversal of their contents via a java.util.Iterator
interface. This interface allows you to walk a collection of objects, operating on each object in
turn. Remember when using Iterators that they contain a snapshot of the collection at the time
the Iterator was obtained; generally it is not advisable to modify the collection itself while
traversing an Iterator.

Q: State the significance of public, private, protected, default modifiers both

singly and in combination and state the effect of package relationships on declared
items qualified by these modifiers.
A: public : Public class is visible in other packages, field is visible everywhere (class must be
public too)
private : Private variables or methods may be used only by an instance of the same class that
declares the variable or method, A private feature may only be accessed by the class that owns
the feature.
protected : Is available to all classes in the same package and also available to all subclasses of
the class that owns the protected feature.This access is provided even to subclasses that reside in
a different package from the class that owns the protected feature.
default :What you get by default ie, without any access modifier (ie, public private or
protected).It means that it is visible to all within a particular package.

Q: What is an abstract class?

A: Abstract class must be extended/subclassed (to be useful). It serves as a template. A class
that is abstract may not be instantiated (ie, you may not call its constructor), abstract class may
contain static data. Any class with an abstract method is automatically abstract itself, and must
be declared as such.
A class may be declared abstract even if it has no abstract methods. This prevents it from being

Q: What is static in java?

A: Static means one per class, not one for each object no matter how many instance of a class
might exist. This means that you can use them without creating an instance of a class.Static
methods are implicitly final, because overriding is done based on the type of the object, and
static methods are attached to a class, not an object. A static method in a superclass can be
shadowed by another static method in a subclass, as long as the original method was not
declared final. However, you can't override a static method with a nonstatic method. In other
words, you can't change a static method into an instance method in a subclass.

Q: What is final?
A: A final class can't be extended ie., final class may not be subclassed. A final method can't
be overridden when its class is inherited. You can't change value of a final variable (is a

Q: What if the main method is declared as private?

A: The program compiles properly but at runtime it will give "Main method not public."

Q: What if the static modifier is removed from the signature of the main

Page 2 of 61
A: Program compiles. But at runtime throws an error "NoSuchMethodError".

Q: What if I write static public void instead of public static void?

A: Program compiles and runs properly.

Q: What if I do not provide the String array as the argument to the method?
A: Program compiles but throws a runtime error "NoSuchMethodError".

Q: What is the first argument of the String array in main method?

A: The String array is empty. It does not have any element. This is unlike C/C++ where the
first element by default is the program name.

Q: If I do not provide any arguments on the command line, then the String array
of Main method will be empty of null?
A: It is empty. But not null.

Q: How can one prove that the array is not null but empty?
A: Print args.length. It will print 0. That means it is empty. But if it would have been null
then it would have thrown a NullPointerException on attempting to print args.length.

Q: What environment variables do I need to set on my machine in order to be

able to run Java programs?
A: CLASSPATH and PATH are the two variables.

Q: Can an application have multiple classes having main method?

A: Yes it is possible. While starting the application we mention the class name to be run. The
JVM will look for the Main method only in the class whose name you have mentioned. Hence
there is not conflict amongst the multiple classes having main method.

Q: Can I have multiple main methods in the same class?

A: No the program fails to compile. The compiler says that the main method is already
defined in the class.

Q: Do I need to import java.lang package any time? Why ?

A: No. It is by default loaded internally by the JVM.

Q: Can I import same package/class twice? Will the JVM load the package twice
at runtime?
A: One can import the same package or same class multiple times. Neither compiler nor
JVM complains abt it. And the JVM will internally load the class only once no matter how many
times you import the same class.

Q: What are Checked and UnChecked Exception?

A: A checked exception is some subclass of Exception (or Exception itself), excluding class
RuntimeException and its subclasses.
Making an exception checked forces client programmers to deal with the possibility that the
exception will be thrown. eg, IOException thrown by's read() method•

Page 3 of 61
Unchecked exceptions are RuntimeException and any of its subclasses. Class Error and its
subclasses also are unchecked. With an unchecked exception, however, the compiler doesn't
force client programmers either to catch the
exception or declare it in a throws clause. In fact, client programmers may not even know that
the exception could be thrown. eg, StringIndexOutOfBoundsException thrown by String's
charAt() method• Checked exceptions must be caught at compile time. Runtime exceptions do
not need to be. Errors often cannot be.

Q: What is Overriding?
A: When a class defines a method using the same name, return type, and arguments as a
method in its superclass, the method in the class overrides the method in the superclass.
When the method is invoked for an object of the class, it is the new definition of the method that
is called, and not the method definition from superclass. Methods may be overridden to be more
public, not more private.

Q: What are different types of inner classes?

A: Nested top-level classes, Member classes, Local classes, Anonymous classes
Nested top-level classes- If you declare a class within a class and specify the static modifier, the
compiler treats the class just like any other top-level class.
Any class outside the declaring class accesses the nested class with the declaring class name
acting similarly to a package. eg, outer.inner. Top-level inner classes implicitly have access only
to static variables.There can also be inner interfaces. All of these are of the nested top-level

Member classes - Member inner classes are just like other member methods and member
variables and access to the member class is restricted, just like methods and variables. This
means a public member class acts similarly to a nested top-level class. The primary difference
between member classes and nested top-level classes is that member classes have access to the
specific instance of the enclosing class.

Local classes - Local classes are like local variables, specific to a block of code. Their visibility is
only within the block of their declaration. In order for the class to be useful beyond the
declaration block, it would need to implement a
more publicly available interface.Because local classes are not members, the modifiers public,
protected, private, and static are not usable.

Anonymous classes - Anonymous inner classes extend local inner classes one level further. As
anonymous classes have no name, you cannot provide a constructor

Q: Are the imports checked for validity at compile time? e.g. will the code
containing an import such as java.lang.ABCD compile?
A: Yes the imports are checked for the semantic validity at compile time. The code
containing above line of import will not compile. It will throw an error saying,can not resolve
symbol : class ABCD
location: package io

Q: Does importing a package imports the subpackages as well? e.g. Does

importing com.MyTest.* also import com.MyTest.UnitTests.*?

Page 4 of 61
A: No you will have to import the subpackages explicitly. Importing com.MyTest.* will
import classes in the package MyTest only. It will not import any class in any of it's subpackage.

Q: What is the difference between declaring a variable and defining a variable?

A: In declaration we just mention the type of the variable and it's name. We do not initialize
it. But defining means declaration + initialization.
e.g String s; is just a declaration while String s = new String ("abcd"); Or String s = "abcd"; are
both definitions.

Q: What is the default value of an object reference declared as an instance

A: null unless we define it explicitly.

Q: Can a top level class be private or protected?

A: No. A top level class can not be private or protected. It can have either "public" or no
modifier. If it does not have a modifier it is supposed to have a default access.If a top level class
is declared as private the compiler will complain that the "modifier private is not allowed here".
This means that a top level class can not be private. Same is the case with protected

Q: What type of parameter passing does Java support?

A: In Java the arguments are always passed by value .

Q: Primitive data types are passed by reference or pass by value?

A: Primitive data types are passed by value.

Q: Objects are passed by value or by reference?

A: Java only supports pass by value. With objects, the object reference itself is passed by
value and so both the original reference and parameter copy both refer to the same object .

Q: What is serialization?
A: Serialization is a mechanism by which you can save the state of an object by converting it
to a byte stream.

Q: How do I serialize an object to a file?

A: The class whose instances are to be serialized should implement an interface Serializable.
Then you pass the instance to the ObjectOutputStream which is connected to a fileoutputstream.
This will save the object to a file.

Q: Which methods of Serializable interface should I implement?

A: The serializable interface is an empty interface, it does not contain any methods. So we do
not implement any methods.

Q: How can I customize the seralization process? i.e. how can one have a control
over the serialization process?
A: Yes it is possible to have control over serialization process. The class should implement
Externalizable interface. This interface contains two methods namely readExternal and
writeExternal. You should implement these methods and write the logic for customizing the
serialization process.

Page 5 of 61
Q: What is the common usage of serialization?
A: Whenever an object is to be sent over the network, objects need to be serialized. Moreover
if the state of an object is to be saved, objects need to be serilazed.

Q: What is Externalizable interface?

A: Externalizable is an interface which contains two methods readExternal and
writeExternal. These methods give you a control over the serialization mechanism. Thus if your
class implements this interface, you can customize the serialization process by implementing
these methods.

Q: What happens to the object references included in the object?

A: The serialization mechanism generates an object graph for serialization. Thus it
determines whether the included object references are serializable or not. This is a recursive
process. Thus when an object is serialized, all the included objects are also serialized alongwith
the original obect.

Q: What one should take care of while serializing the object?

A: One should make sure that all the included objects are also serializable. If any of the
objects is not serializable then it throws a NotSerializableException.

Q: What happens to the static fields of a class during serialization?

A: There are three exceptions in which serialization doesnot necessarily read and write to the
stream. These are
1. Serialization ignores static fields, because they are not part of ay particular state state.
2. Base class fields are only hendled if the base class itself is serializable.
3. Transient fields.

Q: Does Java provide any construct to find out the size of an object?
A: No there is not sizeof operator in Java. So there is not direct way to determine the size of
an object directly in Java.
Q: Does importing a package imports the subpackages as well? e.g. Does
importing com.MyTest.* also import com.MyTest.UnitTests.*?
A: Read the system time just before the method is invoked and immediately after method
returns. Take the time difference, which will give you the time taken by a method for execution.
To put it in code...
long start = System.currentTimeMillis ();
method ();
long end = System.currentTimeMillis ();
System.out.println ("Time taken for execution is " + (end - start));
Remember that if the time taken for execution is too small, it might show that it is taking zero
milliseconds for execution. Try it on a method which is big enough, in the sense the one which is
doing considerable amout of processing.

Q: What are wrapper classes?

A: Java provides specialized classes corresponding to each of the primitive data types. These
are called wrapper classes. They are e.g. Integer, Character, Double etc.

Q: Why do we need wrapper classes?

Page 6 of 61
A: It is sometimes easier to deal with primitives as objects. Moreover most of the collection
classes store objects and not primitive data types. And also the wrapper classes provide many
utility methods also. Because of these resons we need wrapper classes. And since we create
instances of these classes we can store them in any of the collection classes and pass them
around as a collection. Also we can pass them around as method parameters where a method
expects an object.

Q: What are checked exceptions?

A: Checked exception are those which the Java compiler forces you to catch. e.g.
IOException are checked Exceptions.

Q: What are runtime exceptions?

A: Runtime exceptions are those exceptions that are thrown at runtime because of either
wrong input data or because of wrong business logic etc. These are not checked by the compiler
at compile time.

Q: What is the difference between error and an exception?

A: An error is an irrecoverable condition occurring at runtime. Such as OutOfMemory error.
These JVM errors and you can not repair them at runtime. While exceptions are conditions that
occur because of bad input etc. e.g. FileNotFoundException will be thrown if the specified file
does not exist. Or a NullPointerException will take place if you try using a null reference. In most
of the cases it is possible to recover from an exception (probably by giving user a feedback for
entering proper values etc.).

Q: How to create custom exceptions?

A: Your class should extend class Exception, or some more specific type thereof.

Q: If I want an object of my class to be thrown as an exception object, what

should I do?
A: The class should extend from Exception class. Or you can extend your class from some
more precise exception type also.
Q: If my class already extends from some other class what should I do if I want
an instance of my class to be thrown as an exception object?
A: One can not do anytihng in this scenarion. Because Java does not allow multiple
inheritance and does not provide any exception interface as well.

Q: What happens to an unhandled exception?

A: One can not do anytihng in this scenarion. Because Java does not allow multiple
inheritance and does not provide any exception interface as well.

Q: How does an exception permeate through the code?

A: An unhandled exception moves up the method stack in search of a matching When an
exception is thrown from a code which is wrapped in a try block followed by one or more catch
blocks, a search is made for matching catch block. If a matching type is found then that block will
be invoked. If a matching type is not found then the exception moves up the method stack and
reaches the caller method. Same procedure is repeated if the caller method is included in a try

Page 7 of 61
catch block. This process continues until a catch block handling the appropriate type of
exception is found. If it does not find such a block then finally the program terminates.

Q: What are the different ways to handle exceptions?

A: There are two ways to handle exceptions,
1. By wrapping the desired code in a try block followed by a catch block to catch the exceptions.
2. List the desired exceptions in the throws clause of the method and let the caller of the method
hadle those exceptions.

Q: Q: What is the basic difference between the 2 approaches to exception

handling...1> try catch block and 2> specifying the candidate exceptions in the
throws clause?
When should you use which approach?
A: In the first approach as a programmer of the method, you urself are dealing with the
exception. This is fine if you are in a best position to decide should be done in case of an
exception. Whereas if it is not the responsibility of the method to deal with it's own exceptions,
then do not use this approach. In this case use the second approach. In the second approach we
are forcing the caller of the method to catch the exceptions, that the method is likely to throw.
This is often the approach library creators use. They list the exception in the throws clause and
we must catch them. You will find the same approach throughout the java libraries we use.

Q: Is it necessary that each try block must be followed by a catch block?

A: It is not necessary that each try block must be followed by a catch block. It should be
followed by either a catch block OR a finally block. And whatever exceptions are likely to be
thrown should be declared in the throws clause of the method.

Q: If I write return at the end of the try block, will the finally block still execute?
A: Yes even if you write return as the last statement in the try block and no exception occurs,
the finally block will execute. The finally block will execute and then the control return.

Q: If I write System.exit (0); at the end of the try block, will the finally block still
A: No in this case the finally block will not execute because when you say System.exit (0); the
control immediately goes out of the program, and thus finally never executes

Q: How are Observer and Observable used?

A: Objects that subclass the Observable class maintain a list of observers. When an
Observable object is updated it invokes the update() method of each of its observers to notify the
observers that it has changed state. The Observer interface is implemented by objects that
observe Observable objects.

Q: What is synchronization and why is it important?

A: With respect to multithreading, synchronization is the capability to control
the access of multiple threads to shared resources. Without synchronization, it is possible for one
thread to modify a shared object while another thread is in the process of using or updating that
object's value. This often leads to significant errors.

Page 8 of 61
Q: How does Java handle integer overflows and underflows?
A: It uses those low order bytes of the result that can fit into the size of the type allowed by
the operation.

Q: Does garbage collection guarantee that a program will not run out of
A: Garbage collection does not guarantee that a program will not run out of memory. It is
possible for programs to use up memory resources faster than they are garbage collected. It is
also possible for programs to create objects that are not subject to garbage collection
Q: What is the difference between preemptive scheduling and time slicing?
A: Under preemptive scheduling, the highest priority task executes until it enters the waiting
or dead states or a higher priority task comes into existence. Under time slicing, a task executes
for a predefined slice of time and then reenters the pool of ready tasks. The scheduler then
determines which task should execute next, based on priority and other factors.

Q: When a thread is created and started, what is its initial state?

A: A thread is in the ready state after it has been created and started.

Q: What is the purpose of finalization?

A: The purpose of finalization is to give an unreachable object the opportunity to perform
any cleanup processing before the object is garbage collected.

Q: What is the Locale class?

A: The Locale class is used to tailor program output to the conventions of a particular
geographic, political, or cultural region

Q: What is the difference between a while statement and a do statement?

A: A while statement checks at the beginning of a loop to see whether the next loop iteration
should occur. A do statement checks at the end of a loop to see whether the next iteration of a
loop should occur. The do statement will always execute the body of a loop at least once.

Q: What is the difference between static and non-static variables?

A: A static variable is associated with the class as a whole rather than with specific instances
of a class. Non-static variables take on unique values with each object instance.

Q: How are this() and super() used with constructors?

A: Othis() is used to invoke a constructor of the same class. super() is used to invoke a
superclass constructor.

Q: What are synchronized methods and synchronized statements?

A: Synchronized methods are methods that are used to control access to an object. A thread
only executes a synchronized method after it has acquired the lock for the method's object or
class. Synchronized statements are similar to synchronized methods. A synchronized statement
can only be executed after a thread has acquired the lock for the object or class referenced in the
synchronized statement.

Page 9 of 61
Q: What is daemon thread and which method is used to create the daemon
A: 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.

Q: Can applets communicate with each other?

A: At this point in time applets may communicate with other applets running in the same
virtual machine. If the applets are of the same class, they can communicate via shared static
variables. If the applets are of different classes, then each will need a reference to the same class
with static variables. In any case the basic idea is to pass the information back and forth through
a static variable.

An applet can also get references to all other applets on the same page using the getApplets()
method of java.applet.AppletContext. Once you\'ve got a reference to an applet, you can
communicate with it by using its public members.

It is conceivable to have applets in different virtual machines that talk to a server somewhere on
the Internet and store any data that needs to be serialized there. Then, when another applet
needs this data, it could connect to this same server. Implementing this is non-trivial.

Q: What are the steps in the JDBC connection?

A: While making a JDBC connection we go through the following steps :

Step 1 : Register the database driver by using :

Class.forName(\" driver classs for that specific database\" );
Step 2 : Now create a database connection using :
Connection con = DriverManager.getConnection(url,username,password);
Step 3: Now Create a query using :
Statement stmt = Connection.Statement(\"select * from TABLE NAME\");
Step 4 : Exceute the query :

Q: How does a try statement determine which catch clause should be used to
handle an exception?
A: When an exception is thrown within the body of a try statement, the catch clauses of the
try statement are examined in the order in which they appear. The first catch clause that is
capable of handling the exceptionis executed. The remaining catch clauses are ignored.
Q: Can an unreachable object become reachable again?
A: An unreachable object may become reachable again. This can happen when the object's
finalize() method is invoked and the object performs an operation which causes it to become
accessible to reachable objects.

Q: What method must be implemented by all threads?

A: All tasks must implement the run() method, whether they are a subclass of Thread or
implement the Runnable interface.

Q: What are synchronized methods and synchronized statements?

A: Synchronized methods are methods that are used to control access to an object. A thread
only executes a synchronized method after it has acquired the lock for the method's object or

Page 10 of 61
class. Synchronized statements are similar to synchronized methods. A synchronized statement
can only be executed after a thread has acquired the lock for the object or class referenced in the
synchronized statement.

Q: What is Externalizable?
A: Externalizable is an Interface that extends Serializable Interface. And sends data into
Streams in Compressed Format. It has two methods, writeExternal(ObjectOuput out) and
readExternal(ObjectInput in)

Q: What modifiers are allowed for methods in an Interface?

A: Only public and abstract modifiers are allowed for methods in interfaces.

Q: What are some alternatives to inheritance?

A: Delegation is an alternative to inheritance. Delegation means that you include an instance
of another class as an instance variable, and forward messages to the instance. It is often safer
than inheritance because it forces you to think about each message you forward, because the
instance is of a known class, rather than a new class, and because it doesn't force you to accept
all the methods of the super class: you can provide only the methods that really make sense. On
the other hand, it makes you write more code, and it is harder to re-use (because it is not a

Q: What does it mean that a method or field is "static"?

A: Static variables and methods are instantiated only once per class. In other words they are
class variables, not instance variables. If you change the value of a static variable in a particular
object, the value of that variable changes for all instances of that class.
Static methods can be referenced with the name of the class rather than the name of a particular
object of the class (though that works too). That's how library methods like System.out.println()
work out is a static field in the java.lang.System class.

Q: What is the difference between preemptive scheduling and time slicing?

A: Under preemptive scheduling, the highest priority task executes until it enters the waiting
or dead states or a higher priority task comes into existence. Under time slicing, a task executes
for a predefined slice of time and then reenters the pool of ready tasks. The scheduler then
determines which task should execute next, based on priority and other factors.

Q: What is the catch or declare rule for method declarations?

A: If a checked exception may be thrown within the body of a method, the method must
either catch the exception or declare it in its throws clause.

Core Java Questions #2

Q1. How could Java classes direct program messages to the system console, but
error messages, say to a file?

Page 11 of 61
A. The class System has a variable out that represents the standard output, and the variable err
that represents the standard error device. By default, they both point at the system console. This
how the standard output could be re-directed:
Stream st = new Stream(new FileOutputStream("output.txt")); System.setErr(st);

* Q2. What's the difference between an interface and an abstract class?

A. An abstract class may contain code in method bodies, which is not allowed in an interface.
With abstract classes, you have to inherit your class from it and Java does not allow multiple
inheritance. On the other hand, you can implement multiple interfaces in your class.

* Q3. Why would you use a synchronized block vs. synchronized method?

A. Synchronized blocks place locks for shorter periods than synchronized methods.

* Q4. Explain the usage of the keyword transient?

A. This keyword indicates that the value of this member variable does not have to be serialized
with the object. When the class will be de-serialized, this variable will be initialized with a default
value of its data type (i.e. zero for integers).

* Q5. How can you force garbage collection?

A. You can't force GC, but could request it by calling System.gc(). JVM does not guarantee that
GC will be started immediately.

* Q6. How do you know if an explicit object casting is needed?

A. If you assign a superclass object to a variable of a subclass's data type, you need to do explicit
casting. For example:
Object a; Customer b; b = (Customer) a;

When you assign a subclass to a variable having a supeclass type, the casting is performed

* Q7. 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.

* Q8. Can you write a Java class that could be used both as an applet as well as an

A. Yes. Add a main() method to the applet.

* Q9. What's the difference between constructors and other methods?

Page 12 of 61
A. Constructors must have the same name as the class and can not return a value. They are only
called once while regular methods could be called many times.

* Q10. Can you call one constructor from another if a class has multiple

A. Yes. Use this() syntax.

* Q11. Explain the usage of Java packages.

A. This is a way to organize files when a project consists of multiple modules. It also helps
resolve naming conflicts when different packages have classes with the same names. Packages
access level also allows you to protect data from being used by the non-authorized classes.

* Q12. If a class is located in a package, what do you need to change in the OS

environment to be able to use it?

A. You need to add a directory or a jar file that contains the package directories to the
CLASSPATH environment variable. Let's say a class Employee belongs to a package;
and is located in the file c:\dev\com\xyz\hr\ In this case, you'd need to add
c:\dev to the variable CLASSPATH. If this class contains the method main(), you could test it
from a command prompt window as follows:

* Q13. What's the difference between J2SDK 1.5 and J2SDK 5.0?

A.There's no difference, Sun Microsystems just re-branded this version.

* Q14. What would you use to compare two String variables - the operator == or the
method equals()?

A. I'd use the method equals() to compare the values of the Strings and the == to check if two
variables point at the same instance of a String object.

* Q15. Does it matter in what order catch statements for FileNotFoundException

and IOExceptipon are written?

A. Yes, it does. The FileNoFoundException is inherited from the IOException. Exception's

subclasses have to be caught first.

* Q16. Can an inner class declared inside of a method access local variables of this

A. It's possible if these variables are final.

* Q17. What can go wrong if you replace && with & in the following code:
String a=null; if (a!=null && a.length()>10) {...}
A. A single ampersand here would lead to a NullPointerException.

* Q18. What's the main difference between a Vector and an ArrayList

Page 13 of 61
A. Java Vector class is internally synchronized and ArrayList is not.

* Q19. When should the method invokeLater()be used?

A. This method is used to ensure that Swing components are updated through the event-
dispatching thread.
* Q20. How can a subclass call a method or a constructor defined in a superclass?

A. Use the following syntax: super.myMethod(); To call a constructor of the superclass, just
write super(); in the first line of the subclass's constructor.

Core Java Questions #3

Question: What is transient variable?

Answer: Transient variable can't be serialize. For example if a variable is declared as transient in
a Serializable class and the class is written to an ObjectStream, the value of the variable can't be
written to the stream instead when the class is retrieved from the ObjectStream the value of the
variable becomes null.

Question: Name the containers which uses Border Layout as their default layout?
Answer: Containers which uses Border Layout as their default are: window, Frame and Dialog

Question: What do you understand by Synchronization?

Answer: Synchronization is a process of controlling the access of shared resources by the
multiple threads in such a manner that only one thread can access one resource at a time. In non
synchronized multithreaded application, it is possible for one thread to modify a shared object
while another thread is in the process of using or updating the object's value. Synchronization
prevents such type of data corruption.
E.g. Synchronizing a function:
public synchronized void Method1 () {
// Appropriate method-related code.
E.g. Synchronizing a block of code inside a function:
public myFunction (){
synchronized (this) {
// Synchronized code here.

Question: What is Collection API?

Answer: The Collection API is a set of classes and interfaces that support operation on
collections of objects. These classes and interfaces are more flexible, more powerful, and more
regular than the vectors, arrays, and hashtables if effectively replaces.
Example of classes: HashSet, HashMap, ArrayList, LinkedList, TreeSet and TreeMap.
Example of interfaces: Collection, Set, List and Map.

Page 14 of 61
Question: Is Iterator a Class or Interface? What is its use?
Answer: Iterator is an interface which is used to step through the elements of a Collection.

Question: What is similarities/difference between an Abstract class and Interface?

Answer: Differences are as follows:
Interfaces provide a form of multiple inheritance. A class can extend only one other class.
Interfaces are limited to public methods and constants with no implementation. Abstract classes
can have a partial implementation, protected parts, static methods, etc.
A Class may implement several interfaces. But in case of abstract class, a class may extend only
one abstract class.
Interfaces are slow as it requires extra indirection to to find corresponding method in in the
actual class. Abstract classes are fast.

Neither Abstract classes or Interface can be instantiated.

Question: How to define an Abstract class?

Answer: A class containing abstract method is called Abstract class. An Abstract class can't be
Example of Abstract class:
abstract class testAbstractClass {
protected String myString;
public String getMyString() {
return myString;
public abstract string anyAbstractFunction();

Question: How to define an Interface?

Answer: In Java Interface defines the methods but does not implement them. Interface can
include constants. A class that implements the interfaces is bound to implement all the methods
defined in Interface.
Emaple of Interface:

public interface sampleInterface {

public void functionOne();

public long CONSTANT_ONE = 1000;


Question: Explain the user defined Exceptions?

Answer: User defined Exceptions are the separate Exception classes defined by the user for
specific purposed. An user defined can created by simply sub-classing it to the Exception class.
This allows custom exceptions to be generated (using throw) and caught in the same way as
normal exceptions.
class myCustomException extends Exception {
// The class simply has to exist to be an exception

Page 15 of 61
Question: Explain the new Features of JDBC 2.0 Core API?
Answer: The JDBC 2.0 API includes the complete JDBC API, which includes both core and
Optional Package API, and provides inductrial-strength database computing capabilities.
New Features in JDBC 2.0 Core API:

Scrollable result sets- using new methods in the ResultSet interface allows programmatically
move the to particular row or to a position relative to its current position
JDBC 2.0 Core API provides the Batch Updates functionality to the java applications.
Java applications can now use the ResultSet.updateXXX methods.
New data types - interfaces mapping the SQL3 data types
Custom mapping of user-defined types (UTDs)
Miscellaneous features, including performance hints, the use of character streams, full precision
for java.math.BigDecimal values, additional security, and support for time zones in date, time,
and timestamp values.

Question: Explain garbage collection?

Answer: Garbage collection is one of the most important feature of Java. Garbage collection is
also called automatic memory management as JVM automatically removes the unused
variables/objects (value is null) from the memory. User program cann't directly free the object
from memory, instead it is the job of the garbage collector to automatically free the objects that
are no longer referenced by a program. Every class inherits finalize() method from
java.lang.Object, the finalize() method is called by garbage collector when it determines no more
references to the object exists. In Java, it is good idea to explicitly assign null into a variable
when no more in use. I Java on calling System.gc() and Runtime.gc(), JVM tries to recycle the
unused objects, but there is no guarantee when all the objects will garbage collected.

Question: How you can force the garbage collection?

Answer: Garbage collection automatic process and can't be forced.

Question: What is OOPS?

Answer: OOP is the common abbreviation for Object-Oriented Programming.

Question: Describe the principles of OOPS.

Answer: There are three main principals of oops which are called Polymorphism, Inheritance
and Encapsulation.

Question: Explain the Encapsulation principle.

Answer: Encapsulation is a process of binding or wrapping the data and the codes that operates
on the data into a single entity. This keeps the data safe from outside interface and misuse. One
way to think about encapsulation is as a protective wrapper that prevents code and data from
being arbitrarily accessed by other code defined outside the wrapper.

Question: Explain the Inheritance principle.

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

Question: Explain the Polymorphism principle.

Answer: The meaning of Polymorphism is something like one name many forms. Polymorphism
enables one entity to be used as as general category for different types of actions. The specific

Page 16 of 61
action is determined by the exact nature of the situation. The concept of polymorphism can be
explained as "one interface, multiple methods".

Question: Explain the different forms of Polymorphism.

Answer: From a practical programming viewpoint, polymorphism exists in three distinct forms
in Java:
Method overloading
Method overriding through inheritance
Method overriding through the Java interface

Question: What are Access Specifiers available in Java?

Answer: Access specifiers are keywords that determines the type of access to the member of a
class. These are:

Question: Describe the wrapper classes in Java.

Answer: Wrapper class is wrapper around a primitive data type. An instance of a wrapper class
contains, or wraps, a primitive value of the corresponding type.

Following table lists the primitive types and the corresponding wrapper classes:

Primitive Wrapper
boolean java.lang.Boolean
byte java.lang.Byte
char java.lang.Character
double java.lang.Double
float java.lang.Float
int java.lang.Integer
long java.lang.Long
short java.lang.Short
void java.lang.Void

Question: Read the following program:

public class test {

public static void main(String [] args) {
int x = 3;
int y = 1;
if (x = y)
System.out.println("Not equal");

Page 17 of 61
What is the result?
A. The output is 摘 qual・br> B. The output in 哲 ot Equal・br> C. An error at " if (x = y)"
causes compilation to fall.
D. The program executes but no output is show on console.
Answer: C

Java Collection Interview Questions

Q: What is the Collections API?
A: The Collections API is a set of classes and interfaces that support operations on collections
of objects.

Q: What is the List interface?

A: The List interface provides support for ordered collections of objects.

Q: What is the Vector class?

A: The Vector class provides the capability to implement a growable array of objects.

Q: What is an Iterator interface?

A: The Iterator interface is used to step through the elements of a Collection .

Q: Which java.util classes and interfaces support event handling?

A: The EventObject class and the EventListener interface support event processing.

Q: What is the GregorianCalendar class?

A: The GregorianCalendar provides support for traditional Western calendars

Q: What is the Locale class?

A: The Locale class is used to tailor program output to the conventions of a particular
geographic, political, or cultural region .

Q: What is the SimpleTimeZone class?

A: The SimpleTimeZone class provides support for a Gregorian calendar .

Q: What is the Map interface?

A: The Map interface replaces the JDK 1.1 Dictionary class and is used associate keys with

Q: What is the highest-level event class of the event-delegation model?

A: The java.util.EventObject class is the highest-level class in the event-delegation class

Q: What is the Collection interface?

A: The Collection interface provides support for the implementation of a mathematical bag -
an unordered collection of objects that may contain duplicates.

Page 18 of 61
Q: What is the Set interface?
A: The Set interface provides methods for accessing the elements of a finite mathematical
set. Sets do not allow duplicate elements.

Q: What is the typical use of Hashtable?

A: Whenever a program wants to store a key value pair, one can use Hashtable.

Q: I am trying to store an object using a key in a Hashtable. And some other

object already exists in that location, then what will happen? The existing object
will be overwritten? Or the new object will be stored elsewhere?
A: The existing object will be overwritten and thus it will be lost.

Q: What is the difference between the size and capacity of a Vector?

A: The size is the number of elements actually stored in the vector, while capacity is the
maximum number of elements it can store at a given instance of time.

Q: Can a vector contain heterogenous objects?

A: Yes a Vector can contain heterogenous objects. Because a Vector stores everything in
terms of Object.

Q: Can a ArrayList contain heterogenous objects?

A: Yes a ArrayList can contain heterogenous objects. Because a ArrayList stores everything
in terms of Object.

Q: What is an enumeration?
A: An enumeration is an interface containing methods for accessing the underlying data
structure from which the enumeration is obtained. It is a construct which collection classes
return when you request a collection of all the objects stored in the collection. It allows
sequential access to all the elements stored in the collection.

Q: Considering the basic properties of Vector and ArrayList, where will you use
Vector and where will you use ArrayList?
A: The basic difference between a Vector and an ArrayList is that, vector is synchronized
while ArrayList is not. Thus whenever there is a possibility of multiple threads accessing the
same instance, one should use Vector. While if not multiple threads are going to access the same
instance then use ArrayList. Non synchronized data structure will give better performance than
the synchronized one.

Q: Can a vector contain heterogenous objects?

A: Yes a Vector can contain heterogenous objects. Because a Vector stores everything in
terms of Object.

Java Collections API Design FAQ

General Interface
Why don't you support immutability directly in the core collection interfaces so
that you can do away with optional operations (and

Page 19 of 61
This is the most controversial design decision in the whole API. Clearly, static (compile time)
type checking is highly desirable, and is the norm in Java. We would have supported it if we
believed it were feasible. Unfortunately, attempts to achieve this goal cause an explosion in the
size of the interface hierarchy, and do not succeed in eliminating the need for runtime exceptions
(though they reduce it substantially).

Doug Lea, who wrote a popular Java collections package that did reflect mutability distinctions
in its interface hierarchy, no longer believes it is a viable approach, based on user experience
with his collections package. In his words (from personal correspondence) "Much as it pains me
to say it, strong static typing does not work for collection interfaces in Java."

To illustrate the problem in gory detail, suppose you want to add the notion of modifiability to
the Hierarchy. You need four new interfaces: ModifiableCollection, ModifiableSet,
ModifiableList, and ModifiableMap. What was previously a simple hierarchy is now a messy
heterarchy. Also, you need a new Iterator interface for use with unmodifiable Collections, that
does not contain the remove operation. Now can you do away with
UnsupportedOperationException? Unfortunately not.

Consider arrays. They implement most of the List operations, but not remove and add. They are
"fixed-size" Lists. If you want to capture this notion in the hierarchy, you have to add two new
interfaces: VariableSizeList and VariableSizeMap. You don't have to add VariableSizeCollection
and VariableSizeSet, because they'd be identical to ModifiableCollection and ModifiableSet, but
you might choose to add them anyway for consistency's sake. Also, you need a new variety of
ListIterator that doesn't support the add and remove operations, to go along with unmodifiable
List. Now we're up to ten or twelve interfaces, plus two new Iterator interfaces, instead of our
original four. Are we done? No.

Consider logs (such as error logs, audit logs and journals for recoverable data objects). They are
natural append-only sequences, that support all of the List operations except for remove and set
(replace). They require a new core interface, and a new iterator.

And what about immutable Collections, as opposed to unmodifiable ones? (i.e., Collections that
cannot be changed by the client AND will never change for any other reason). Many argue that
this is the most important distinction of all, because it allows multiple threads to access a
collection concurrently without the need for synchronization. Adding this support to the type
hierarchy requires four more interfaces.

Now we're up to twenty or so interfaces and five iterators, and it's almost certain that there are
still collections arising in practice that don't fit cleanly into any of the interfaces. For example,
the collection-views returned by Map are natural delete-only collections. Also, there are
collections that will reject certain elements on the basis of their value, so we still haven't done
away with runtime exceptions.

When all was said and done, we felt that it was a sound engineering compromise to sidestep the
whole issue by providing a very small set of core interfaces that can throw a runtime exception.

Won't programmers have to surround any code that calls optional operations with a try-catch
clause in case they throw an UnsupportedOperationException?

Page 20 of 61
It was never our intention that programs should catch these exceptions: that's why they're
unchecked (runtime) exceptions. They should only arise as a result of programming errors, in
which case, your program will halt due to the uncaught exception.

Why isn't there a core interface for "bags" (AKA multisets)?

The Collection interface provides this functionality. We are not providing any public
implementations of this interface, as we think that it wouldn't be used frequently enough to "pull
its weight." We occasionally return such Collections, which are implemented easily atop
AbstractCollection (for example, the Collection returned by Map.values).

Why don't you provide for "gating functions" that facilitate the implementation of
type-safe collections?
We are extremely sympathetic to the desire for type-safe collections. Rather than adding a
"band-aid" to the framework that enforces type-safety in an ad hoc fashion, the framework has
been designed to mesh with all of the parameterized-types proposals currently being discussed.
In the event that parameterized types are added to the language, the entire collections
framework will support compile-time type-safe usage, with no need for explicit casts.
Unfortunately, this won't happen in the the 1.2 release. In the meantime, people who desire
runtime type safety can implement their own gating functions in "wrapper" collections
surrounding JDK collections.

Why didn't you use "Beans-style names" for consistency?

While the names of the new collections methods do not adhere to the "Beans naming
conventions", we believe that they are reasonable, consistent and appropriate to their purpose. It
should be remembered that the Beans naming conventions do not apply to the JDK as a whole;
the AWT did adopt these conventions, but that decision was somewhat controversial. We suspect
that the collections APIs will be used quite pervasively, often with multiple method calls on a
single line of code, so it is important that the names be short. Consider, for example, the Iterator
methods. Currently, a loop over a collection looks like this:

for (Iterator i = c.iterator(); i.hasNext(); )


Everything fits neatly on one line, even if the Collection name is a long expression. If we named
the methods "getIterator", "hasNextElement" and "getNextElement", this would no longer be the
case. Thus, we adopted the "traditional" JDK style rather than the Beans style.

Collection Interface
Why doesn't Collection extend Cloneable and Serializable?
Many Collection implementations (including all of the ones provided by the JDK) will have a
public clone method, but it would be mistake to require it of all Collections. For example, what
does it mean to clone a Collection that's backed by a terabyte SQL database? Should the method
call cause the company to requisition a new disk farm? Similar arguments hold for serializable.

If the client doesn't know the actual type of a Collection, it's much more flexible and less error
prone to have the client decide what type of Collection is desired, create an empty Collection of

Page 21 of 61
this type, and use the addAll method to copy the elements of the original collection into the new

Why don't you provide an "apply" method in Collection to apply a given method
("upcall") to all the elements of the Collection?
This is what is referred to as an "Internal Iterator" in the "Design Patterns" book (Gamma et al.).
We considered providing it, but decided not to as it seems somewhat redundant to support
internal and external iterators, and Java already has a precedent for external iterators (with
Enumerations). The "throw weight" of this functionality is increased by the fact that it requires a
public interface to describe upcalls.

Why didn't you provide a "Predicate" interface, and related methods (e.g., a
method to find the first element in the Collection satisfying the predicate)?
It's easy to implement this functionality atop Iterators, and the resulting code may actually look
cleaner as the user can inline the predicate. Thus, it's not clear whether this facility pulls its
weight. It could be added to the Collections class at a later date (implemented atop Iterator), if
it's deemed useful.

Why don't you provide a form of the addAll method that takes an Enumeration (or
an Iterator)?
Because we don't believe in using Enumerations (or Iterators) as "poor man's collections." This
was occasionally done in prior releases, but now that we have the Collection interface, it is the
preferred way to pass around abstract collections of objects.

Why don't the concrete implementations in the JDK have Enumeration (or
Iterator) constructors?
Again, this is an instance of an Enumeration serving as a "poor man's collection" and we're
trying to discourage that. Note however, that we strongly suggest that all concrete
implementations should have constructors that take a Collection (and create a new Collection
with the same elements).

Why don't you provide an Iterator.add method?

The semantics are unclear, given that the contract for Iterator makes no guarantees about the
order of iteration. Note, however, that ListIterator does provide an add operation, as it does
guarantee the order of the iteration.

List Interface
Why don't you rename the List interface to Sequence; doesn't "list" generally
suggest "linked list"? Also, doesn't it conflict with java.awt.List?
People were evenly divided as to whether List suggests linked lists. Given the implementation
naming convention, <Implementation><Interface>, there was a strong desire to keep the core
interface names short. Also, several existing names (AbstractSequentialList, LinkedList) would
have been decidedly worse if we changed List to Sequence. The naming conflict can be dealt with
by the following incantation:

Page 22 of 61
import java.util.*;
import java.awt.*;
import java.util.List; // Dictates interpretation of "List"

Why don't you rename List's set method to replace, to avoid confusion with Set.
It was decided that the "set/get" naming convention was strongly enough enshrined in the
language that we'd stick with it.

Map Interface
Why doesn't Map extend Collection?
This was by design. We feel that mappings are not collections and collections are not mappings.
Thus, it makes little sense for Map to extend the Collection interface (or vice versa).

If a Map is a Collection, what are the elements? The only reasonable answer is "Key-value pairs",
but this provides a very limited (and not particularly useful) Map abstraction. You can't ask what
value a given key maps to, nor can you delete the entry for a given key without knowing what
value it maps to.

Collection could be made to extend Map, but this raises the question: what are the keys? There's
no really satisfactory answer, and forcing one leads to an unnatural interface.

Maps can be viewed as Collections (of keys, values, or pairs), and this fact is reflected in the three
"Collection view operations" on Maps (keySet, entrySet, and values). While it is, in principle,
possible to view a List as a Map mapping indices to elements, this has the nasty property that
deleting an element from the List changes the Key associated with every element before the
deleted element. That's why we don't have a map view operation on Lists.

Iterator Interface
Why doesn't Iterator extend Enumeration?
We view the method names for Enumeration as unfortunate. They're very long, and very
frequently used. Given that we were adding a method and creating a whole new framework, we
felt that it would be foolish not to take advantage of the opportunity to improve the names. Of
course we could support the new and old names in Iterator, but it doesn't seem worthwhile.

Why don't you provide an Iterator.peek method that allows you to look at the next
element in an iteration without advancing the iterator?
It can be implemented atop the current Iterators (a similar pattern to We believe that its use would be rare enough that it isn't worth
including in the interface that everyone has to implement.

Why did you write a new collections framework instead of adopting JGL (a
preexisting collections package from ObjectSpace, Inc.) into the JDK?

Page 23 of 61
If you examine the goals for our Collections framework (in the Overview), you'll see that we are
not really "playing in the same space" as JGL. Quoting from the "Design Goals" Section of the
Java Collections Overview: "Our main design goal was to produce an API that was reasonably
small, both in size, and (more importantly) in 'conceptual weight.'"

JGL consists of approximately 130 classes and interfaces; its main goal was consistency with the
C++ Standard Template Library (STL). This was not one of our goals. Java has traditionally
stayed away from C++'s more complex features (e.g., multiple inheritance, operator
overloading). Our entire framework, including all infrastructure, contains approximately 25
classes and interfaces.

While this may cause some discomfort for some C++ programmers, we feel that it will be good
for Java in the long run. As the Java libraries mature, they inevitably grow, but we are trying as
hard as we can to keep them small and manageable, so that Java continues to be an easy, fun
language to learn and to use.

Why don't you eliminate all of the methods and classes that return "views"
(Collections backed by other collection-like objects). This would greatly reduce
Given that we provide core collection interfaces behind which programmers can "hide" their own
implementations, there will be aliased collections whether the JDK provides them or not.
Eliminating all views from the JDK would greatly increase the cost of common operations like
making a Collection out of an array, and would do away with many useful facilities (like
synchronizing wrappers). One view that we see as being particularly useful is List.subList. The
existence of this method means that people who write methods taking List on input do not have
to write secondary forms taking an offset and a length (as they do for arrays).

Why don't you provide for "observable" collections that send out Events when
they're modified?
Primarily, resource constraints. If we're going to commit to such an API, it has to be something
that works for everyone, that we can live with for the long haul. We may provide such a facility
some day. In the meantime, it's not difficult to implement such a facility on top of the public

JSP Questions
Q: What is a output comment?
A: A comment that is sent to the client in the viewable page source.The JSP engine handles
an output comment as uninterpreted HTML text, returning the comment in the HTML output
sent to the client. You can see the comment by viewing the page source from your Web browser.
JSP Syntax
<!-- comment [ <%= expression %> ] -->

Example 1
<!-- This is a commnet sent to client on
<%= (new java.util.Date()).toLocaleString() %>

Page 24 of 61
Displays in the page source:
<!-- This is a commnet sent to client on January 24, 2004 -->

Q: What is a Hidden Comment?

A: A comments that documents the JSP page but is not sent to the client. The JSP engine
ignores a hidden comment, and does not process any code within hidden comment tags. A
hidden comment is not sent to the client, either in the displayed JSP page or the HTML page
source. The hidden comment is useful when you want to hide or "comment out" part of your JSP
You can use any characters in the body of the comment except the closing --%> combination. If
you need to use --%> in your comment, you can escape it by typing --%\>.
JSP Syntax
<%-- comment --%>
<%@ page language="java" %>
<head><title>A Hidden Comment </title></head>
<%-- This comment will not be visible to the colent in the page source --%>

Q: What is a Expression?
A: An expression tag contains a scripting language expression that is evaluated, converted to
a String, and inserted where the expression appears in the JSP file. Because the value of an
expression is converted to a String, you can use an expression within text in a JSP file. Like
<%= someexpression %>
<%= (new java.util.Date()).toLocaleString() %>
You cannot use a semicolon to end an expression

Q: What is a Declaration?
A: A declaration declares one or more variables or methods for use later in the JSP source
A declaration must contain at least one complete declarative statement. You can declare any
number of variables or methods within one declaration tag, as long as they are separated by
semicolons. The declaration must be valid in the scripting language used in the JSP file.

<%! somedeclarations %>

<%! int i = 0; %>
<%! int a, b, c; %>

Q: What is a Scriptlet?
A: A scriptlet can contain any number of language statements, variable or method
declarations, or expressions that are valid in the page scripting language.Within scriptlet tags,
you can
1.Declare variables or methods to use later in the file (see also Declaration).

2.Write expressions valid in the page scripting language (see also Expression).

Page 25 of 61
3.Use any of the JSP implicit objects or any object declared with a <jsp:useBean> tag.
You must write plain text, HTML-encoded text, or other JSP tags outside the scriptlet.
Scriptlets are executed at request time, when the JSP engine processes the client request. If the
scriptlet produces output, the output is stored in the out object, from which you can display it.

Q: What are implicit objects? List them?

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. The
implicit objects re listed below
• request
• response
• pageContext
• session
• application
• out
• config
• page
• 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.

Q: What are the different scope valiues for the <jsp:useBean>?

A: The different scope values for <jsp:useBean> are
1. page
2. request

Q: Explain the life-cycle mehtods in JSP?

A: THe generated servlet class for a JSP page implements the HttpJspPage interface of the
javax.servlet.jsp package. Hte HttpJspPage interface extends the JspPage interface which inturn
extends the Servlet interface of the javax.servlet package. the generated servlet class thus
implements all the methods of the these three interfaces. The JspPage interface declares only
two mehtods - jspInit() and jspDestroy() that must be implemented by all JSP pages regardless
of the client-server protocol. However the JSP specification has provided the HttpJspPage
interfaec specifically for the JSp pages serving HTTP requests. This interface declares one
method _jspService().
The jspInit()- The container calls the jspInit() to initialize te servlet instance.It is called before
any other method, and is called only once for a servlet instance.
The _jspservice()- The container calls the _jspservice() for each request, passing it the request
and the response objects.

Page 26 of 61
The jspDestroy()- The container calls this when it decides take the instance out of service. It is
the last method called n the servlet instance.

Q: How do I prevent the output of my JSP or Servlet pages from being cached by
the browser?
A: You will need to set the appropriate HTTP header attributes to prevent the dynamic
content output by the JSP page from being cached by the browser. Just execute the following
scriptlet at the beginning of your JSP pages to prevent them from being cached at the browser.
You need both the statements to take care of some of the older browser versions.
response.setHeader("Cache-Control","no-store"); //HTTP 1.1
response.setHeader("Pragma\","no-cache"); //HTTP 1.0
response.setDateHeader ("Expires", 0); //prevents caching at the proxy server

Q: How does JSP handle run-time exceptions?

A: You can use the errorPage attribute of the page directive to have uncaught run-time
exceptions automatically forwarded to an error processing page. For example:
<%@ page errorPage=\"error.jsp\" %> redirects the browser to the JSP page error.jsp if an
uncaught exception is encountered during request processing. Within error.jsp, if you indicate
that it is an error-processing page, via the directive: <%@ page isErrorPage=\"true\" %>
Throwable object describing the exception may be accessed within the error page via the
exception implicit object. Note: You must always use a relative URL as the value for the
errorPage attribute.

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 do I use a scriptlet to initialize a newly instantiated bean?

A: A jsp:useBean action may optionally have a body. If the body is specified, its contents will
be automatically invoked when the specified bean is instantiated. Typically, the body will contain
scriptlets or jsp:setProperty tags to initialize the newly instantiated bean, although you are not
restricted to using those alone.
The following example shows the “today” property of the Foo bean initialized to the current date
when it is instantiated. Note that here, we make use of a JSP expression within the
jsp:setProperty action.

<jsp:useBean id="foo" class="com.Bar.Foo" >

Page 27 of 61
<jsp:setProperty name="foo" property="today"
value="<%=java.text.DateFormat.getDateInstance().format(new java.util.Date()) %>" / >
<%-- scriptlets calling bean setter methods go here --%>
</jsp:useBean >

Q: How can I prevent the word "null" from appearing in my HTML input text
fields when I populate them with a resultset that has null values?
A: You could make a simple wrapper function, like
String blanknull(String s) {
return (s == null) ? \"\" : s;
then use it inside your JSP form, like
<input type="text" name="lastName" value="<%=blanknull(lastName)% >" >

Q: What's a better approach for enabling thread-safe servlets and JSPs?

SingleThreadModel Interface or Synchronization?
A: Although the SingleThreadModel technique is easy to use, and works well for low volume
sites, it does not scale well. If you anticipate your users to increase in the future, you may be
better off implementing explicit synchronization for your shared data. The key however, is to
effectively minimize the amount of code that is synchronzied so that you take maximum
advantage of multithreading.
Also, note that SingleThreadModel is pretty resource intensive from the server\'s perspective.
The most serious issue however is when the number of concurrent requests exhaust the servlet
instance pool. In that case, all the unserviced requests are queued until something becomes free -
which results in poor performance. Since the usage is non-deterministic, it may not help much
even if you did add more memory and increased the size of the instance pool.

Q: How can I enable session tracking for JSP pages if the browser has disabled
A: We know that 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.

Consider the following example, in which two JSP files, say hello1.jsp and hello2.jsp, interact
with each other. Basically, we create a new session within hello1.jsp and place an object within
this session. The user can then traverse to hello2.jsp by clicking on the link present within the
page. Within hello2.jsp, we simply extract the object that was earlier placed in the session and
display its contents. Notice that we invoke the encodeURL() within hello1.jsp on the link used to
invoke hello2.jsp; if cookies are disabled, the session ID is automatically appended to the URL,

Page 28 of 61
allowing hello2.jsp to still retrieve the session object. Try this example first with cookies enabled.
Then disable cookie support, restart the brower, and try again. Each time you should see the
maintenance of the session across pages. Do note that to get this example to work with cookies
disabled at the browser, your JSP engine has to support URL rewriting.
<%@ page session=\"true\" %>
Integer num = new Integer(100);
String url =response.encodeURL("hello2.jsp");
<a href=\'<%=url%>\'>hello2.jsp</a>
<%@ page session="true" %>
Integer i= (Integer )session.getValue("num");
out.println("Num value in session is " + i.intValue());
Q: What is the difference b/w variable declared inside a declaration part and
variable declared in scriplet part?
A: Variable declared inside declaration part is treated as a global variable.that means after
convertion jsp file into servlet that variable will be in outside of service method or it will be
declared as instance variable.And the scope is available to complete jsp and to complete in the
converted servlet class.where as if u declare a variable inside a scriplet that variable will be
declared inside a service method and the scope is with in the service method.

Q: Is there a way to execute a JSP from the comandline or from my own

A: There is a little tool called JSPExecutor that allows you to do just that. The developers
(Hendrik Schreiber <> & Peter Rossbach <>) aim was not to write
a full blown servlet engine, but to provide means to use JSP for generating source code or
reports. Therefore most HTTP-specific features (headers, sessions, etc) are not implemented, i.e.
no reponseline or header is generated. Nevertheless you can use it to precompile JSP for your

Struts Questions
Q: What is Struts?
A: The core of the Struts framework is a flexible control layer based on standard technologies
like Java Servlets, JavaBeans, ResourceBundles, and XML, as well as various Jakarta Commons
packages. Struts encourages application architectures based on the Model 2 approach, a
variation of the classic Model-View-Controller (MVC) design paradigm.
Struts provides its own Controller component and integrates with other technologies to provide
the Model and the View. For the Model, Struts can interact with standard data access
technologies, like JDBC and EJB, as well as most any third-party packages, like Hibernate,
iBATIS, or Object Relational Bridge. For the View, Struts works well with JavaServer Pages,
including JSTL and JSF, as well as Velocity Templates, XSLT, and other presentation systems.

Page 29 of 61
The Struts framework provides the invisible underpinnings every professional web application
needs to survive. Struts helps you create an extensible development environment for your
application, based on published standards and proven design patterns.
Q: What is Jakarta Struts Framework?
A: Jakarta Struts is open source implementation of MVC (Model-View-Controller) pattern
for the development of web based applications. Jakarta Struts is robust architecture and can be
used for the development of application of any size. Struts framework makes it much easier to
design scalable, reliable Web applications with Java.

Q: What is ActionServlet?
A: The class org.apache.struts.action.ActionServlet is the called the ActionServlet. In the the
Jakarta Struts Framework this class plays the role of controller. All the requests to the server
goes through the controller. Controller is responsible for handling all the requests.
Q: How you will make available any Message Resources Definitions file to the
Struts Framework Environment?
A: T Message Resources Definitions file are simple .properties files and these files contains
the messages that can be used in the struts project. Message Resources Definitions files can be
added to the struts-config.xml file through <message-resources /> tag.
<message-resources parameter=\"MessageResources\" />.

Q: What is Action Class?

A: The Action Class is part of the Model and is a wrapper around the business logic. 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. In the Action Class all the
database/business processing are done. It is advisable to perform all the database related stuffs
in the Action Class. The ActionServlet (commad) passes the parameterized class to Action Form
using the execute() method. The return type of the execute method is ActionForward which is
used by the Struts Framework to forward the request to the file as per the value of the returned
ActionForward object.

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?

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. Struts Framework emits the
java scripts and it can be used validate the form data on the client browser. Server side validation
of form can be accomplished by sub classing your From Bean with DynaValidatorForm class.
The Validator framework was developed by David Winterfeldt as third-party add-on to Struts.
Now the Validator framework is a part of Jakarta Commons project and it can be used with or
without Struts. The Validator framework comes integrated with the Struts Framework and can
be used without doing any extra settings.

Q: Give the Details of XML files used in Validator Framework?

A: The Validator Framework uses two XML configuration files validator-rules.xml and
validation.xml. The validator-rules.xml defines the standard validation routines, these are

Page 30 of 61
reusable and used in validation.xml. to define the form specific validations. The validation.xml
defines the validations applied to a form bean.

Q: How you will display validation fail errors on jsp page?

A: Following tag displays all the errors:

Q: How you will enable front-end validation based on the xml in validation.xml?
A: The <html:javascript> tag to allow front-end validation based on the xml in
validation.xml. For example the code: <html:javascript formName=\"logonForm\"
dynamicJavascript=\"true\" staticJavascript=\"true\" /> generates the client side java script for
the form \"logonForm\" as defined in the validation.xml file. The <html:javascript> when added
in the jsp file generates the client site validation script.
Q: How to get data from the velocity page in a action class?
A: We can get the values in the action classes by using data.getParameter(\"variable name
defined in the velocity page\");

Question: What is RequestProcessor and RequestDispatcher?

Answer: The controller is responsible for intercepting and translating user input into actions to
be performed by the model. The controller is responsible for selecting the next view based on
user input and the outcome of model operations. The Controller receives the request from the
browser, invoke a business operation and coordinating the view to return to the client.

The controller is implemented by a java servlet, this servlet is centralized point of control for the
web application. In struts framework the controller responsibilities are implemented by several
different components like
The ActionServlet Class
The RequestProcessor Class
The Action Class

The ActionServlet extends the javax.servlet.http.httpServlet class. The ActionServlet class is not
abstract and therefore can be used as a concrete controller by your application.
The controller is implemented by the ActionServlet class. All incoming requests are mapped to
the central controller in the deployment descriptor as follows.

All request URIs with the pattern *.do are mapped to this servlet in the deployment descriptor as

A request URI that matches this pattern will have the following form.

Page 31 of 61
The preceding mapping is called extension mapping, however, you can also specify path
mapping where a pattern ends with /* as shown below.
A request URI that matches this pattern will have the following form.
The class org.apache.struts.action.requestProcessor process the request from the controller. You
can sublass the RequestProcessor with your own version and modify how the request is

Once the controller receives a client request, it delegates the handling of the request to a helper
class. This helper knows how to execute the business operation associated with the requested
action. In the Struts framework this helper class is descended of org.apache.struts.action.Action
class. It acts as a bridge between a client-side user action and business operation. The Action
class decouples the client request from the business model. This decoupling allows for more than
one-to-one mapping between the user request and an action. The Action class also can perform
other functions such as authorization, logging before invoking business operation. the Struts
Action class contains several methods, but most important method is the execute() method.
public ActionForward execute(ActionMapping mapping,
ActionForm form, HttpServletRequest request, HttpServletResponse response) throws
The execute() method is called by the controller when a request is received from a client. The
controller creates an instance of the Action class if one doesn’t already exist. The strut
framework will create only a single instance of each Action class in your application.

Action are mapped in the struts configuration file and this configuration is loaded into memory
at startup and made available to the framework at runtime. Each Action element is represented
in memory by an instance of the org.apache.struts.action.ActionMapping class . The
ActionMapping object contains a path attribute that is matched against a portion of the URI of
the incoming request.
path= "/somerequest"
<forward name="Success" path="/action/xys" redirect="true"/>
<forward name="Failure" path="/somejsp.jsp" redirect="true"/>
Once this is done the controller should determine which view to return to the client. The execute
method signature in Action class has a return type org.apache.struts.action.ActionForward class.
The ActionForward class represents a destination to which the controller may send control once
an action has completed. Instead of specifying an actual JSP page in the code, you can
declaratively associate as action forward through out the application. The action forward are
specified in the configuration file.

Page 32 of 61
path= "/somerequest"
<forward name="Success" path="/action/xys" redirect="true"/>
<forward name="Failure" path="/somejsp.jsp" redirect="true"/>
The action forward mappings also can be specified in a global section, independent of any
specific action mapping.
<forward name="Success" path="/action/somejsp.jsp" />
<forward name="Failure" path="/someotherjsp.jsp" />

public interface RequestDispatcher

Defines an object that receives requests from the client and sends them to any resource (such as
a servlet, HTML file, or JSP file) on the server. The servlet container creates the
RequestDispatcher object, which is used as a wrapper around a server resource located at a
particular path or given by a particular name.
This interface is intended to wrap servlets, but a servlet container can create RequestDispatcher
objects to wrap any type of resource.


public RequestDispatcher getRequestDispatcher(java.lang.String path)

Returns a RequestDispatcher object that acts as a wrapper for the resource located at the given
path. A RequestDispatcher object can be used to forward a request to the resource or to include
the resource in a response. The resource can be dynamic or static.
The pathname must begin with a "/" and is interpreted as relative to the current context root.
Use getContext to obtain a RequestDispatcher for resources in foreign contexts. This method
returns null if the ServletContext cannot return a RequestDispatcher.

path - a String specifying the pathname to the resource
a RequestDispatcher object that acts as a wrapper for the resource at the specified path
See Also:
RequestDispatcher, getContext(java.lang.String)


public RequestDispatcher getNamedDispatcher(java.lang.String name)

Returns a RequestDispatcher object that acts as a wrapper for the named servlet.

Page 33 of 61
Servlets (and JSP pages also) may be given names via server administration or via a web
application deployment descriptor. A servlet instance can determine its name using
This method returns null if the ServletContext cannot return a RequestDispatcher for any

name - a String specifying the name of a servlet to wrap
a RequestDispatcher object that acts as a wrapper for the named servlet
See Also:
RequestDispatcher, getContext(java.lang.String), ServletConfig.getServletName()

Question: Why cant we overide create method in StatelessSessionBean?

Answer: From the EJB Spec : - A Session bean's home interface defines one or morecreate(...)
methods. Each create method must be named create and must match one of the ejbCreate
methods defined in the enterprise Bean class. The return type of a create method must be the
enterprise Bean's remote interface type. The home interface of a stateless session bean must
have one create method that takes no arguments.

Question: Is struts threadsafe?Give an example?

Answer: Struts is not only thread-safe but thread-dependant. The response to a request is
handled by a light-weight Action object, rather than an individual servlet. Struts instantiates
each Action class once, and allows other requests to be threaded through the original object. This
core strategy conserves resources and provides the best possible throughput. A properly-
designed application will exploit this further by routing related operations through a single

Question: Can we Serialize static variable?

Answer: Serialization is the process of converting a set of object instances that contain
references to each other into a linear stream of bytes, which can then be sent through a socket,
stored to a file, or simply manipulated as a stream of data. Serialization is the mechanism used
by RMI to pass objects between JVMs, either as arguments in a method invocation from a client
to a server or as return values from a method invocation. In the first section of this book, There
are three exceptions in which serialization doesnot necessarily read and write to the stream.
These are
1. Serialization ignores static fields, because they are not part of any particular object's state.
2. Base class fields are only handled if the base class itself is serializable.
3. Transient fields. There are four basic things you must do when you are making a class
serializable. They are:
Implement the Serializable interface.
Make sure that instance-level, locally defined state is serialized properly.
Make sure that superclass state is serialized properly.
Override equals( )and hashCode( ).
it is possible to have control over serialization process. The class should implement
Externalizable interface. This interface contains two methods namely readExternal and
writeExternal. You should implement these methods and write the logic for customizing the
serialization process .... (Source:

Page 34 of 61
Question: What are the uses of tiles-def.xml file, file,
validation.xml file?
Answer: tiles-def.xml is is an xml file used to configure tiles with the struts application. You can
define the layout / header / footer / body content for your View. See more at

The file is used to configure the message (error/ other messages) for
the struts applications.

The file validation.xml is used to declare sets of validations that should be applied to Form
Beans. Fpr more information please visit

Question: What is the difference between perform() and execute() methods?

Answer: Perform method is the method which was deprecated in the Struts Version 1.1. In
Struts 1.x, Action.perform() is the method called by the ActionServlet. This is typically where
your business logic resides, or at least the flow control to your JavaBeans and EJBs that handle
your business logic. As we already mentioned, to support declarative exception handling, the
method signature changed in perform. Now execute just throws Exception. Action.perform() is
now deprecated; however, the Struts v1.1 ActionServlet is smart enough to know whether or not
it should call perform or execute in the Action, depending on which one is available.

Question: What are the various Struts tag libraries?

Answer: Struts is very rich framework and it provides very good and user friendly way to
develop web application forms. Struts provide many tag libraries to ease the development of web
applications. These tag libraries are:
* Bean tag library - Tags for accessing JavaBeans and their properties.
* HTML tag library - Tags to output standard HTML, including forms, text boxes, checkboxes,
radio buttons etc..
* Logic tag library - Tags for generating conditional output, iteration capabilities and flow
* Tiles or Template tag library - For the application using tiles
* Nested tag library - For using the nested beans in the application

Question: What do you understand by DispatchAction?

Answer: DispatchAction is an action that comes with Struts 1.1 or later, that lets you combine
Struts actions into one class, each with their own method. The
org.apache.struts.action.DispatchAction class allows multiple operation to mapped to the
different functions in the same Action class.
For example:
A package might include separate RegCreate, RegSave, and RegDelete Actions, which just
perform different operations on the same RegBean object. Since all of these operations are
usually handled by the same JSP page, it would be handy to also have them handled by the same
Struts Action.
A very simple way to do this is to have the submit button modify a field in the form which
indicates which operation to perform.

<html:hidden property="dispatch" value="error"/>

<SCRIPT>function set(target) {document.forms[0].dispatch.value=target;}</SCRIPT>
<html:submit onclick="set('save');">SAVE</html:submit>

Page 35 of 61
<html:submit onclick="set('create');">SAVE AS NEW</html:submitl>
<html:submit onclick="set('delete);">DELETE</html:submit>

Then, in the Action you can setup different methods to handle the different operations, and
branch to one or the other depending on which value is passed in the dispatch field.

String dispatch = myForm.getDispatch();

if ("create".equals(dispatch)) { ...
if ("save".equals(dispatch)) { ...

The Struts Dispatch Action [org.apache.struts.actions] is designed to do exactly the same thing,
but without messy branching logic. The base perform method will check a dispatch field for you,
and invoke the indicated method. The only catch is that the dispatch methods must use the same
signature as perform. This is a very modest requirement, since in practice you usually end up
doing that anyway.

To convert an Action that was switching on a dispatch field to a DispatchAction, you simply need
to create methods like this

public ActionForward create(

ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException { ...

public ActionForward save(

ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException { ...

Cool. But do you have to use a property named dispatch? No, you don't. The only other step is to
specify the name of of the dispatch property as the "parameter" property of the action-mapping.
So a mapping for our example might look like this:


If you wanted to use the property "o" instead, as in o=create, you would change the mapping to


Page 36 of 61

Again, very cool. But why use a JavaScript button in the first place? Why not use several buttons
named "dispatch" and use a different value for each?

You can, but the value of the button is also its label. This means if the page designers want to
label the button something different, they have to coordinate the Action programmer.
Localization becomes virtually impossible. (Source:

Question: How Struts relates to J2EE?

Answer: Struts framework is built on J2EE technologies (JSP, Servlet, Taglibs), but it is itself
not part of the J2EE standard.

Question: What is Struts actions and action mappings?

Answer: A Struts action is an instance of a subclass of an Action class, which implements a
portion of a Web application and whose perform or execute method returns a forward.

An action can perform tasks such as validating a user name and password.

An action mapping is a configuration file entry that, in general, associates an action name with
an action. An action mapping can contain a reference to a form bean that the action can use, and
can additionally define a list of local forwards that is visible only to this action.

An action servlet is a servlet that is started by the servlet container of a Web server to process a
request that invokes an action. The servlet receives a forward from the action and asks the
servlet container to pass the request to the forward's URL. An action servlet must be an instance
of an org.apache.struts.action.ActionServlet class or of a subclass of that class. An action servlet
is the primary component of the controller.

Servlets Questions
Q: Explain the life cycle methods of a Servlet.
A: The javax.servlet.Servlet interface defines the three methods known as life-cycle method.
public void init(ServletConfig config) throws ServletException
public void service( ServletRequest req, ServletResponse res) throws ServletException,
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.

Page 37 of 61
Q: What is the difference between the getRequestDispatcher(String path)
method of javax.servlet.ServletRequest interface and javax.servlet.ServletContext
A: The getRequestDispatcher(String path) method of javax.servlet.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 javax.servlet.ServletContext interface cannot

accepts relative paths. All path must sart with a "/" and are interpreted as relative to curent
context root.

Q: Explain the directory structure of a web application.

A: The directory structure of a web application consists of two parts.
A private directory called WEB-INF
A public resource directory which contains public resource folder.

WEB-INF folder consists of

1. web.xml
2. classes directory
3. lib directory

Q: What are the common mechanisms used for session tracking?

A: Cookies
SSL sessions
URL- rewriting

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 preinitialization of a servlet?

A: A container doesnot initialize the servlets ass soon as it starts up, it initializes a servlet
when it receives a request for that servlet first time. This is called lazy loading. The servlet
specification defines the <load-on-startup> element, which can be specified in the deployment
descriptor to make the servlet container load and initialize the servlet as soon as it starts up. The
process of loading a servlet before any request comes in is called preloading or preinitializing a

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

A: A doGet() method is limited with 2k of data to be sent, and doPost() method doesn't have
this limitation. A request string for doGet() looks like the following:
doPost() method call doesn't need a long text tail after a servlet name in a request. All
parameters are stored in a request itself, not in a request string, and it's impossible to guess the
data transmitted to a servlet only looking at a request string.

Page 38 of 61
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: 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.

SQL (DB) Questions

Q: What is SQL?
A: SQL stands for 'Structured Query Language'.

Q: What is SELECT statement?

A: The SELECT statement lets you select a set of values from a table in a database. The
values selected from the database table would depend on the various conditions that are
specified in the SQL query.

Q: How can you compare a part of the name rather than the entire name?
A: SELECT * FROM people WHERE empname LIKE '%ab%'
Would return a recordset with records consisting empname the sequence 'ab' in empname .

Q: What is the INSERT statement?

A: The INSERT statement lets you insert information into a database.

Q: How do you delete a record from a database?

A: Use the DELETE statement to remove records or any particular column values from a

Q: How could I get distinct entries from a table?

A: The SELECT statement in conjunction with DISTINCT lets you select a set of distinct
values from a table in a database. The values selected from the database table would of course
depend on the various conditions that are specified in the SQL query. Example
SELECT DISTINCT empname FROM emptable

Q: How to get the results of a Query sorted in any order?

A: You can sort the results and return the sorted results to your program by using ORDER
BY keyword thus saving you the pain of carrying out the sorting yourself. The ORDER BY
keyword is used for sorting.

SELECT empname, age, city FROM emptable ORDER BY empname

Page 39 of 61
Q: How can I find the total number of records in a table?
A: You could use the COUNT keyword , example


Q: What is GROUP BY?

A: The GROUP BY keywords have been added to SQL because aggregate functions (like
SUM) return the aggregate of all column values every time they are called. Without the GROUP
BY functionality, finding the sum for each individual group of column values was not possible.

Q: What is the difference among "dropping a table", "truncating a table" and

"deleting all records" from a table.
A: Dropping : (Table structure + Data are deleted), Invalidates the dependent objects
,Drops the indexes
Truncating: (Data alone deleted), Performs an automatic commit, Faster than delete
Delete : (Data alone deleted), Doesn’t perform automatic commit

Q: What are the Large object types suported by Oracle?

A: Blob and Clob.

Q: Difference between a "where" clause and a "having" clause.

A: Having clause is used only with group functions whereas Where is not used with.

Q: What's the difference between a primary key and a unique key?

A: Both primary key and unique enforce uniqueness of the column on which they are
defined. But by default primary key creates a clustered index on the column, where are unique
creates a nonclustered index by default. Another major difference is that, primary key doesn't
allow NULLs, but unique key allows one NULL only.

Q: What are cursors? Explain different types of cursors. What are the
disadvantages of cursors? How can you avoid cursors?
A: Cursors allow row-by-row prcessing of the resultsets.
Types of cursors: Static, Dynamic, Forward-only, Keyset-driven. See books online for more
Disadvantages of cursors: Each time you fetch a row from the cursor, it results in a network
roundtrip, where as a normal SELECT query makes only one rowundtrip, however large the
resultset is. Cursors are also costly because they require more resources and temporary storage
(results in more IO operations). Furthere, there are restrictions on the SELECT statements that
can be used with some types of cursors.
Most of the times, set based operations can be used instead of cursors.

Q: What are triggers? How to invoke a trigger on demand?

A: Triggers are special kind of stored procedures that get executed automatically when an
INSERT, UPDATE or DELETE operation takes place on a table.
Triggers can't be invoked on demand. They get triggered only when an associated action
(INSERT, UPDATE, DELETE) happens on the table on which they are defined.
Triggers are generally used to implement business rules, auditing. Triggers can also be used to
extend the referential integrity checks, but wherever possible, use constraints for this purpose,
instead of triggers, as constraints are much faster.

Page 40 of 61
Q: What is a join and explain different types of joins.
A: Joins are used in queries to explain how different tables are related. Joins also let you
select data from a table depending upon data from another table.
Types of joins: INNER JOINs, OUTER JOINs, CROSS JOINs. OUTER JOINs are further

Q: What is a self join?

A: Self join is just like any other join, except that two instances of the same table will be
joined in the query.

Spring Interview Questions

Q. Explain DI or IOC pattern?
A: Dependency injection (DI) is a programming design pattern and architectural model,
sometimes also referred to as inversion of control or IOC, although technically speaking,
dependency injection specifically refers to an implementation of a particular form of IOC.
Dependancy Injection describes the situation where one object uses a second object to provide a
particular capacity. For example, being passed a database connection as an argument to the
constructor instead of creating one internally. The term "Dependency injection" is a misnomer,
since it is not a dependency that is injected, rather it is a provider of some capability or resource
that is injected. There are three common forms of dependency injection: setter-, constructor-
and interface-based injection. Dependency injection is a way to achieve loose coupling. Inversion
of control (IOC) relates to the way in which an object obtains references to its dependencies. This
is often done by a lookup method. The advantage of inversion of control is that it decouples
objects from specific lookup mechanisms and implementations of the objects it depends on. As a
result, more flexibility is obtained for production applications as well as for testing.

Q. What are the different IOC containers available?

A. Spring is an IOC container. Other IOC containers are HiveMind, Avalon, PicoContainer.

Q. What are the different types of dependency injection. Explain with examples.
A: There are two types of dependency injection: setter injection and constructor injection.
Setter Injection: Normally in all the java beans, we will use setter and getter method to set and
get the value of property as follows:

public class namebean {

String name;

public void setName(String a) {

name = a; }

public String getName() {

return name; }

We will create an instance of the bean 'namebean' (say bean1) and set property as
bean1.setName("tom"); Here in setter injection, we will set the property 'name' in spring
configuration file as showm below:

<bean id="bean1" class="namebean">

Page 41 of 61
<property name="name" >
The subelement <value> sets the 'name' property by calling the set method as setName("tom");
This process is called setter injection.
To set properties that reference other beans <ref>, subelement of <property> is used as shown
<bean id="bean1" class="bean1impl">
<property name="game">
<ref bean="bean2"/>
<bean id="bean2" class="bean2impl" />

Constructor injection: For constructor injection, we use constructor with parameters as shown

public class namebean {

String name;
public namebean(String a) {
name = a;

We will set the property 'name' while creating an instance of the bean 'namebean' as namebean
bean1 = new namebean("tom");

Here we use the <constructor-arg> element to set the the property by constructor injection as
<bean id="bean1" class="namebean">
<value>My Bean Value</value>

Q. What is spring? What are the various parts of spring framework? What are the
different persistence frameworks which could be used with spring?
A. Spring is an open source framework created to address the complexity of enterprise
application development. One of the chief advantages of the Spring framework is its layered
architecture, which allows you to be selective about which of its components you use while also
providing a cohesive framework for J2EE application development. The Spring modules are built
on top of the core container, which defines how beans are created, configured, and managed, as
shown in the following figure. Each of the modules (or components) that comprise the Spring
framework can stand on its own or be implemented jointly with one or more of the others. The
functionality of each component is as follows:

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

Page 42 of 61
separate an application’s configuration and dependency specification from the actual application

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 AOP? How does it relate with IOC? What are different tools to utilize
A: 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. AOP and IOC are complementary technologies in that both apply a modular approach
to complex problems in enterprise application development. In a typical object-oriented
development approach you might implement logging functionality by putting logger statements
in all your methods and Java classes. In an AOP approach you would instead modularize the
logging services and apply them declaratively to the components that required logging. The
advantage, of course, is that the Java class doesn't need to know about the existence of the
logging service or concern itself with any related code. As a result, application code written using
Spring AOP is loosely coupled. The best tool to utilize AOP to its capability is AspectJ. However
AspectJ works at he byte code level and you need to use AspectJ compiler to get the aop features
built into your compiled code. Nevertheless AOP functionality is fully integrated into the Spring

Page 43 of 61
context for transaction management, logging, and various other features. In general any AOP
framework control aspects in three possible ways:

Joinpoints: Points in a program's execution. For example, joinpoints could define calls to specific
methods in a class

Pointcuts: Program constructs to designate joinpoints and collect specific context at those points

Advices: Code that runs upon meeting certain conditions. For example, an advice could log a
message before executing a joinpoint

Q. What are the advantages of spring framework?

1. Spring has layed architecture. Use what you need and leave you don't need now.
2. Spring Enables POJO Programming. There is no behind the scene magic here. POJO
programming enables continous integration and testability.
3. Dependency Injection and Inversion of Control Simplifies JDBC (Read the first question.)
4. Open source and no vendor lock-in.

Q. Can you name a tool which could provide the initial ant files and directory
structure for a new spring project.?
A: Appfuse or equinox.

Q. Explain BeanFactory in spring?

A: Bean factory is an implementation of the factory design pattern and its function is to create
and dispense beans. As the bean factory knows about many objects within an application, it is
able to create association between collaborating objects as they are instantiated. This removes
the burden of configuration from the bean and the client. There are several implementation of
BeanFactory. The most useful one is "org.springframework.beans.factory.xml.XmlBeanFactory"
It loads its beans based on the definition contained in an XML file. To create an
XmlBeanFactory, pass a InputStream to the constructor. The resource will provide the XML to
the factory. BeanFactory factory = new XmlBeanFactory(new FileInputStream("myBean.xml"));

This line tells the bean factory to read the bean definition from the XML file. The bean definition
includes the description of beans and their properties. But the bean factory doesn't instantiate
the bean yet. To retrieve a bean from a 'BeanFactory', the getBean() method is called. When
getBean() method is called, factory will instantiate the bean and begin setting the bean's
properties using dependency injection. myBean bean1 = (myBean)factory.getBean("myBean");

Q. Explain the role of ApplicationContext in spring?

A. While Bean Factory is used for simple applications, the Application Context is spring's more
advanced container. Like 'BeanFactory' it can be used to load bean definitions, wire beans
together and dispense beans upon request. It also provide

1) A means for resolving text messages, including support for internationalization.

2) A generic way to load file resources.
3) Events to beans that are registered as listeners.

Page 44 of 61
Because of additional functionality, 'Application Context' is preferred over a BeanFactory. Only
when the resource is scarce like mobile devices, 'BeanFactory' is used. The three commonly used
implementation of 'Application Context' are

1. 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");

2. 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");

3. XmlWebApplicationContext : It loads context definition from an XML file contained within a

web application.

Q. How does Spring supports DAO in hibernate?

A. Spring’s HibernateDaoSupport class is a convenient super class for Hibernate DAOs. It has
handy methods you can call to get a Hibernate Session, or a SessionFactory. The most
convenient method is getHibernateTemplate(), which returns a HibernateTemplate. This
template wraps Hibernate checked exceptions with runtime exceptions, allowing your DAO
interfaces to be Hibernate exception-free.

public class UserDAOHibernate extends HibernateDaoSupport {

public User getUser(Long id) {

return (User) getHibernateTemplate().get(User.class, id);
public void saveUser(User user) {
if (log.isDebugEnabled()) {
log.debug(“userId set to: “ + user.getID());
public void removeUser(Long id) {
Object user = getHibernateTemplate().load(User.class, id);

Q. How is a typical spring implementation look like?

A. For a typical Spring Application we need the following files

1. An interface that defines the functions.

Page 45 of 61
2. An Implementation that contains properties, its setter and getter methods, functions etc.,
3. A XML file called Spring configuration file.
4. Client program that uses the function.

Q. How do you define hibernate mapping file in spring?

A. Add the hibernate mapping file entry in mapping resource inside Spring’s
applicationContext.xml file in the web/WEB-INF directory.

<property name="mappingResources">

Q. How do you configure spring in a web application?

A. It is very easy to configure any J2EE-based web application to use Spring. At the very least,
you can simply add Spring’s ContextLoaderListener to your web.xml file:


Q. Can you have xyz.xml file instead of applicationcontext.xml?

A. ContextLoaderListener is a ServletContextListener that initializes when your webapp starts
up. By default, it looks for Spring’s configuration file at WEB-INF/applicationContext.xml. You
can change this default value by specifying a <context-param> element named
“contextConfigLocation.” Example:




Q. How do you configure your database driver in spring?

A. Using datasource "org.springframework.jdbc.datasource.DriverManagerDataSource".

<bean id="dataSource"
<property name="driverClassName">

Page 46 of 61
<property name="url">
<property name="username"><value>sa</value></property>
<property name="password"><value></value></property>

Q. How can you configure JNDI instead of datasource in spring

A. Using "org.springframework.jndi.JndiObjectFactoryBean". Example:

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">

<property name="jndiName">

EJB Interview Questions

Q: What are the different kinds of enterprise beans?
A: Different kind of enterrise beans are Stateless session bean, Stateful session bean, Entity
bean, Message-driven bean...........

Q: What is Session Bean?

A: A session bean is a non-persistent object that implements some business logic running on
the server. One way to think of a session object...........

Q: What is Entity Bean?

A: The entity bean is used to represent data in the database. It provides an object-oriented
interface to ...........
Q: What are the methods of Entity Bean?
A: An entity bean consists of 4 groups of methods, create methods...........

Q: What is the difference between Container-Managed Persistent (CMP) bean

and Bean-Managed Persistent(BMP) ?
A: Container-managed persistence (CMP) and bean-managed persistence (BMP). With CMP,
the container manages the persistence of the entity bean............

Q: What are the callback methods in Entity beans?

A: Callback methods allows the container to notify the bean of events in
its life cycle. The callback methods are defined in the javax.ejb.EntityBean interface............

Q: What is software architecture of EJB?

A: Session and Entity EJBs consist of 4 and 5 parts respectively, a remote interface...........

Q: Can Entity Beans have no create() methods?

A: Yes. In some cases the data is inserted NOT using Java application,...........

Page 47 of 61
Q: What is bean managed transaction?
A: If a developer doesn't want a Container to manage transactions, it's possible to implement
all database operations manually...........

Q: What are transaction attributes?

A: The transaction attribute specifies how the Container must manage transactions for a
method when a client invokes the method via the enterprise bean’s home or...........

Q: What are transaction isolation levels in EJB?

A: Transaction_read_uncommitted , Transaction_read_committed ,

Q: How EJB Invocation happens?

A: Step 1: Retrieve Home Object reference from Naming Service via JNDI.
step 2: Return Home Object reference to the client.
step 3: Create me a new EJB Object through Home Object interface.
step 4: Create EJB Object from the Ejb Object
step 5: Return EJB Object reference to the client.
step 6: Invoke business method using EJB Object reference.
step 7: Delegate request to Bean (Enterprise Bean).

Q: Is it possible to share an HttpSession between a JSP and EJB? What happens

when I change a value in the HttpSession from inside an EJB?

A: You can pass the HttpSession as parameter to an EJB method, only if all objects in session
are serializable.This has to be consider as ?passed-by-value", that means that it?s read-only in
the EJB. If anything is altered from inside the EJB, it won?t be reflected back to the HttpSession
of the Servlet Container.The ?pass-by-reference? can be used between EJBs Remote Interfaces,
as they are remote references. While it IS possible to pass an HttpSession as a parameter to an
EJB object, it is considered to be ?bad practice ? in terms of object oriented design. This is
because you are creating an unnecessary coupling between back-end objects (ejbs) and front-end
objects (HttpSession). Create a higher-level of abstraction for your ejb?s api. Rather than passing
the whole, fat, HttpSession (which carries with it a bunch of http semantics), create a class that
acts as a value object (or structure) that holds all the data you need to pass back and forth
between front-end/back-end. Consider the case where your ejb needs to support a non-http-
based client. This higher level of abstraction will be flexible enough to support it.

Q: The EJB container implements the EJBHome and EJBObject classes. For every
request from a unique client, does the container create a separate instance of the
generated EJBHome and EJBObject classes?

A: The EJB container maintains an instance pool. The container uses these instances for the EJB
Home reference irrespective of the client request. while refering the EJB Object classes the
container creates a separate instance for each client request. The instance pool maintainence is
up to the implementation of the container. If the container provides one, it is available otherwise
it is not mandatory for the provider to implement it. Having said that, yes most of the container

Page 48 of 61
providers implement the pooling functionality to increase the performance of the application
server. The way it is implemented is again up to the implementer.

Q: Can the primary key in the entity bean be a Java primitive type such as int?

A: The primary key can't be a primitive type--use the primitive wrapper classes, instead. For
example, you can use java.lang.Integer as the primary key class, but not int (it has to be a class,
not a primitive)

Q: Can you control when passivation occurs?

A: The developer, according to the specification, cannot directly control when passivation occurs.
Although for Stateful Session Beans, the container cannot passivate an instance that is inside a
transaction. So using transactions can be a a strategy to control passivation.

The ejbPassivate() method is called during passivation, so the developer has control over what to
do during this exercise and can implement the require optimized logic.

Some EJB containers, such as BEA WebLogic, provide the ability to tune the container to
minimize passivation calls.

Taken from the WebLogic 6.0 DTD -"The passivation-strategy can be either "default" or
"transaction". With the default setting the container will attempt to keep a working set of beans
in the cache. With the "transaction" setting, the container will passivate the bean after every
transaction (or method call for a non-transactional invocation).

Q: What is the advantage of using Entity bean for database operations, over
directly using JDBC API to do database operations? When would I use one over the

A: Entity Beans actually represents the data in a database. It is not that Entity Beans replaces
JDBC API. There are two types of Entity Beans Container Managed and Bean Mananged. In
Container Managed Entity Bean - Whenever the instance of the bean is created the container
automatically retrieves the data from the DB/Persistance storage and assigns to the object
variables in bean for user to manipulate or use them. For this the developer needs to map the
fields in the database to the variables in deployment descriptor files (which varies for each

In the Bean Managed Entity Bean - The developer has to specifically make connection, retrive
values, assign them to the objects in the ejbLoad() which will be called by the container when it
instatiates a bean object. Similarly in the ejbStore() the container saves the object values back
the the persistance storage. ejbLoad and ejbStore are callback methods and can be only invoked
by the container. Apart from this, when you use Entity beans you dont need to worry about
database transaction handling, database connection pooling etc. which are taken care by the ejb
container. But in case of JDBC you have to explicitly do the above features. what suresh told is
exactly perfect. ofcourse, this comes under the database transations, but i want to add this. the
great thing about the entity beans of container managed, whenever the connection is failed
during the transaction processing, the database consistancy is mantained automatically. the

Page 49 of 61
container writes the data stored at persistant storage of the entity beans to the database again to
provide the database consistancy. where as in jdbc api, we, developers has to do manually.

Q: What is EJB QL?

A: EJB QL is a Query Language provided for navigation across a network of enterprise beans and
dependent objects defined by means of container managed persistence. EJB QL is introduced in
the EJB 2.0 specification. The EJB QL query language defines finder methods for entity beans
with container managed persistenceand is portable across containers and persistence managers.
EJB QL is used for queries of two types of finder methods: Finder methods that are defined in
the home interface of an entity bean and which return entity objects. Select methods, which are
not exposed to the client, but which are used by the Bean Provider to select persistent values that
are maintained by the Persistence Manager or to select entity objects that are related to the
entity bean on which the query is defined.

Q: Brief description about local interfaces?

A: EEJB was originally designed around remote invocation using the Java Remote Method
Invocation (RMI) mechanism, and later extended to support to standard CORBA transport for
these calls using RMI/IIOP. This design allowed for maximum flexibility in developing
applications without consideration for the deployment scenario, and was a strong feature in
support of a goal of component reuse in J2EE.

Many developers are using EJBs locally -- that is, some or all of their EJB calls are between
beans in a single container.

With this feedback in mind, the EJB 2.0 expert group has created a local interface mechanism.
The local interface may be defined for a bean during development, to allow streamlined calls to
the bean if a caller is in the same container. This does not involve the overhead involved with
RMI like marshalling etc. This facility will thus improve the performance of applications in
which co-location is planned.

Local interfaces also provide the foundation for container-managed relationships among entity
beans with container-managed persistence.

Q: What are the special design care that must be taken when you work with local

A: EIt is important to understand that the calling semantics of local interfaces are different from
those of remote interfaces. For example, remote interfaces pass parameters using call-by-value
semantics, while local interfaces use call-by-reference.

This means that in order to use local interfaces safely, application developers need to carefully
consider potential deployment scenarios up front, then decide which interfaces can be local and
which remote, and finally, develop the application code with these choices in mind.

While EJB 2.0 local interfaces are extremely useful in some situations, the long-term costs of
these choices, especially when changing requirements and component reuse are taken into
account, need to be factored into the design decision.

Page 50 of 61
Q: What happens if remove( ) is never invoked on a session bean?

A: In case of a stateless session bean it may not matter if we call or not as in both cases nothing is
done. The number of beans in cache is managed by the container.

In case of stateful session bean, the bean may be kept in cache till either the session times out, in
which case the bean is removed or when there is a requirement for memory in which case the
data is cached and the bean is sent to free pool.

Q: What is the difference between Message Driven Beans and Stateless Session

A: In several ways, the dynamic creation and allocation of message-driven bean instances
mimics the behavior of stateless session EJB instances, which exist only for the duration of a
particular method call. However, message-driven beans are different from stateless session EJBs
(and other types of EJBs) in several significant ways:

Message-driven beans process multiple JMS messages asynchronously, rather than processing a
serialized sequence of method calls.

Message-driven beans have no home or remote interface, and therefore cannot be directly
accessed by internal or external clients. Clients interact with message-driven beans only
indirectly, by sending a message to a JMS Queue or Topic.

Note: Only the container directly interacts with a message-driven bean by creating bean
instances and passing JMS messages to those instances as necessary.

The Container maintains the entire lifecycle of a message-driven bean; instances cannot be
created or removed as a result of client requests or other API calls.

Q: How can I call one EJB from inside of another EJB?

A: EJBs can be clients of other EJBs. It just works. Use JNDI to locate the Home Interface of the
other bean, then acquire an instance reference, and so forth.

Q: What is an EJB Context?

A: EJBContext is an interface that is implemented by the container, and it is also a part of the
bean-container contract. Entity beans use a subclass of EJBContext called EntityContext. Session
beans use a subclass called SessionContext. These EJBContext objects provide the bean class
with information about its container, the client using the bean and the bean itself. They also
provide other functions. See the API docs and the spec for more details.

Q: The EJB container implements the EJBHome and EJBObject classes. For every
request from a unique client, does the container create a separate instance of the
generated EJBHome and EJBObject classes?

A: The EJB container maintains an instance pool. The container uses these instances for the EJB
Home reference irrespective of the client request. While refering the EJB Object classes the

Page 51 of 61
container creates a separate instance for each client request. The instance pool maintainence is
up to the implementation of the container. If the container provides one, it is available otherwise
it is not mandatory for the provider to implement it. Having said that, yes most of the container
providers implement the pooling functionality to increase the performance of the application
server. The way it is implemented is again up to the implementer.

JMS Questions

Q: What is JMS?

A: JMS is an acronym used for Java Messaging Service. It is Java's answer to creating software
using asynchronous messaging. It is one of the official specifications of the J2EE technologies
and is a key technology.

Q: How JMS is different from RPC?

A: In RPC the method invoker waits for the method to finish execution and return the control
back to the invoker. Thus it is completely synchronous in nature. While in JMS the message
sender just sends the message to the destination and continues it's own processing. The sender
does not wait for the receiver to respond. This is asynchronous behavior.

Q: What are the advantages of JMS?

A: JMS is asynchronous in nature. Thus not all the pieces need to be up all the time for the
application to function as a whole. Even if the receiver is down the MOM will store the messages
on it's behalf and will send them once it comes back up. Thus at least a part of application can
still function as there is no blocking.

Q: Are you aware of any major JMS products available in the market?

A: IBM's MQ Series is one of the most popular product used as Message Oriented Middleware.
Some of the other products are SonicMQ, iBus etc. Weblogic application server also comes with
built in support for JMS messaging.

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 is the difference between topic and queue?

A: A topic 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

Page 52 of 61
Q: What is the role of JMS in enterprise solution development?

A: JMS is typically used in the following scenarios

1. Enterprise Application Integration: - Where a legacy application is integrated with a new
application via messaging.
2. B2B or Business to Business: - Businesses can interact with each other via messaging because
JMS allows organizations to cooperate without tightly coupling their business systems.
3. Geographically dispersed units: - JMS can ensure safe exchange of data amongst the
geographically dispersed units of an organization.
4. One to many applications: - The applications that have to push data in packet to huge number
of clients in a one-to-many fashion are good candidates for the use JMS. Typical such
applications are Auction Sites, Stock Quote Services etc.

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
the received 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 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 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.

Page 53 of 61
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

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 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: With point-to-point message passing the sending application/client establishes a named

message queue in the JMS broker/server and sends messages to this queue. The receiving client
registers with the broker to receive messages posted to this queue. There is a one-to-one
relationship between the sending and receiving clients.

Q: Can two different JMS services talk to each other? For instance, if A and B are
two different JMS providers, can Provider A send messages directly to Provider B?
If not, then can a subscriber to Provider A act as a publisher to Provider B?

A: The answers are no to the first question and yes to the second. The JMS specification does not
require that one JMS provider be able to send messages directly to another provider. However,
the specification does require that a JMS client must be able to accept a message created by a
different JMS provider, so a message received by a subscriber to Provider A can then be

Page 54 of 61
published to Provider B. One caveat is that the publisher to Provider B is not required to handle
a JMSReplyTo header that refers to a destination that is specific to Provider A.

Q: What is the advantage of persistent message delivery compared to nonpersistent


A: If the JMS server experiences a failure, for example, a power outage, any message that it is
holding in primary storage potentially could be lost. With persistent storage, the JMS server logs
every message to secondary storage. (The logging occurs on the front end, that is, as part of
handling the send operation from the message producing client.) The logged message is removed
from secondary storage only after it has been successfully delivered to all consuming clients .

Q: Give an example of using the publish/subscribe model.

A: JMS can be used to broadcast shutdown messages to clients connected to the Weblogic server
on a module wise basis. If an application has six modules, each module behaves like a subscriber
to a named topic on the server.

Q: Why doesn't the JMS API provide end-to-end synchronous message delivery and
notification of delivery?

A: Some messaging systems provide synchronous delivery to destinations as a mechanism for

implementing reliable applications. Some systems provide clients with various forms of delivery
notification so that the clients can detect dropped or ignored messages. This is not the model
defined by the JMS API.

JMS API messaging provides guaranteed delivery via the once-and-only-once delivery semantics
of PERSISTENT messages. In addition, message consumers can insure reliable processing of
messages by using either CLIENT_ACKNOWLEDGE mode or transacted sessions. This achieves
reliable delivery with minimum synchronization and is the enterprise messaging model most
vendors and developers prefer.

The JMS API does not define a schema of systems messages (such as delivery notifications). If an
application requires acknowledgment of message receipt, it can define an application-level
acknowledgment message.

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
Object Messages ? Group of serialize able java object
Bytes Message ? Stream of uninterrupted bytes

Q: How is a java object message delivered to a non-java Client?

A: It is according to the specification that the message sent should be received in the same
format. A non-java client cannot receive a message in the form of java object. The provider in
between handles the conversion of the data type and the message is transferred to the other end.

Page 55 of 61
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.

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 core JMS-related objects required for each JMS-enabled

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
• 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)

J2EE Questions

Question: What is J2EE?

Answer: J2EE Stands for Java 2 Enterprise Edition. J2EE is an environment for developing and
deploying enterprise applications. J2EE specification is defined by Sun Microsystems Inc. The
J2EE platform is one of the best platform for the development and deployment of enterprise
applications. The J2EE platform is consists of a set of services, application programming
interfaces (APIs), and protocols, which provides the functionality necessary for developing
multi-tiered, web-based applications. You can download the J2EE SDK and development tools

Question: What do you understand by a J2EE module?

Answer: A J2EE module is a software unit that consists of one or more J2EE components of the
same container type along with one deployment descriptor of that type. J2EE specification
defines four types of modules:
a) EJB
b) Web
c) application client and

Page 56 of 61
d) resource adapter

In the J2EE applications modules can be deployed as stand-alone units. Modules can also be
assembled into J2EE applications.

Question: Tell me something about J2EE component?

Answer: J2EE component is a self-contained functional software unit supported by a container
and configurable at deployment time. The J2EE specification defines the following J2EE
Application clients and applets are components that run on the client.

Java servlet and JavaServer Pages (JSP) technology components are Web components that run
on the server.

Enterprise JavaBeans (EJB) components (enterprise beans) are business components that run
on the server.
J2EE components are written in the Java programming language and are compiled in the same
way as any program in the language. The difference between J2EE components and "standard"
Java classes is that J2EE components are assembled into a J2EE application, verified to be well
formed and in compliance with the J2EE specification, and deployed to production, where they
are run and managed by the J2EE server or client container.
Source: J2EE v1.4 Glossary

Question: What are the contents of web module?

Answer: A web module may contain:
a) JSP files
b) Java classes
c) gif and html files and
d) web component deployment descriptors

Question: Differentiate between .ear, .jar and .war files.

Answer: These files are simply zipped file using java jar tool. These files are created for different
purposes. Here is the description of these files:
.jar files: These files are with the .jar extenstion. The .jar files contains the libraries, resources
and accessories files like property files.
.war files: These files are with the .war extension. The war file contains the web application that
can be deployed on the any servlet/jsp container. The .war file contains jsp, html, javascript and
other files for necessary for the development of web applications.
.ear files: The .ear file contains the EJB modules of the application.

Question: What is the difference between Session Bean and Entity Bean?
Session Bean: Session is one of the EJBs and it represents a single client inside the Application
Server. Stateless session is easy to develop and its efficient. As compare to entity beans session
beans require few server resources.

A session bean is similar to an interactive session and is not shared; it can have only one client,
in the same way that an interactive session can have only one user. A session bean is not
persistent and it is destroyed once the session terminates.

Page 57 of 61
Entity Bean: An entity bean represents persistent global data from the database. Entity beans
data are stored into database.

Question: Why J2EE is suitable for the development distributed multi-tiered

enterprise applications?
Answer: The J2EE platform consists of multi-tiered distributed application model. J2EE
applications allows the developers to design and implement the business logic into components
according to business requirement. J2EE architecture allows the development of multi-tired
applications and the developed applications can be installed on different machines depending on
the tier in the multi-tiered J2EE environment . The J2EE application parts are:

a) Client-tier components run on the client machine.

b) Web-tier components run on the J2EE server.
c) Business-tier components run on the J2EE server and the
d) Enterprise information system (EIS)-tier software runs on the EIS servers

Question: Why do understand by a container?

Answer: Normally, thin-client multi-tiered applications are hard to write because they involve
many lines of intricate code to handle transaction and state management, multithreading,
resource pooling, and other complex low-level details. The component-based and platform-
independent J2EE architecture makes J2EE applications easy to write because business logic is
organized into reusable components. In addition, the J2EE server provides underlying services
in the form of a container for every component type. Because you do not have to develop these
services yourself, you are free to concentrate on solving the business problem at hand (Source: ).

In short containers are the interface between a component and the low-level platform specific
functionality that supports the component. The application like Web, enterprise bean, or
application client component must be assembled and deployed on the J2EE container before

Question: What are the services provided by a container?

Answer: The services provided by container are as follows:
a) Transaction management for the bean
b) Security for the bean
c) Persistence of the bean
d) Remote access to the bean
e) Lifecycle management of the bean
f) Database-connection pooling
g) Instance pooling for the bean

Question: What are types of J2EE clients?

Answer: J2EE clients are the software that access the services components installed on the J2EE
container. Following are the J2EE clients:
a) Applets
b) Java-Web Start clients
c) Wireless clients
d) Web applications
Question: What is Deployment Descriptor?

Page 58 of 61
Answer: A deployment descriptor is simply an XML(Extensible Markup Language) file with the
extension of .xml. Deployment descriptor describes the component deployment settings.
Application servers reads the deployment descriptor to deploy the components contained in the
deployment unit. For example ejb-jar.xml file is used to describe the setting of the EJBs.

Question: What do you understand by JTA and JTS?

Answer: JTA stands for Java Transaction API and JTS stands for Java Transaction Service. JTA
provides a standard interface which allows the developers to demarcate transactions in a manner
that is independent of the transaction manager implementation. The J2EE SDK uses the JTA
transaction manager to implement the transaction. The code developed by developers does not
calls the JTS methods directly, but only invokes the JTA methods. Then JTA internally invokes
the JTS routines. JTA is a high level transaction interface used by the application code to control
the transaction.

Question: What is JAXP?

Answer: The Java API for XML Processing (JAXP) enables applications to parse and transform
XML documents independent of a particular XML processing implementation. JAXP or Java
API for XML Parsing is an optional API provided by Javasoft. It provides basic functionality for
reading, manipulating, and generating XML documents through pure Java APIs. It is a thin and
lightweight API that provides a standard way to seamlessly integrate any XML-compliant parser
with a Java application.
More at

Question: What is J2EE Connector architecture?

Answer: J2EE Connector Architecture (JCA) is a Java-based technology solution for connecting
application servers and enterprise information systems (EIS) as part of enterprise application
integration (EAI) solutions. While JDBC is specifically used to connect Java EE applications to
databases, JCA is a more generic architecture for connection to legacy systems (including
databases). JCA was developed under the Java Community Process as JSR 16 (JCA 1.0) and JSR
112 (JCA 1.5). As of 2006, the current version of JCA is version 1.5. The J2EE Connector API is
used by J2EE tools developers and system integrators to create resource adapters. Home page
for J2EE Connector architecture

Question: What is difference between Java Bean and Enterprise Java Bean?
Answer: Java Bean as is a plain java class with member variables and getter setter methods. Java
Beans are defined under JavaBeans specification as Java-Based software component model
which includes the features like introspection, customization, events, properties and
Enterprise JavaBeans or EJBs for short are Java-based software components that comply with
Java's EJB specification. EJBs are delpoyed on the EJB container and executes in the EJB
container. EJB is not that simple, it is used for building distributed applications. Examples of
EJB are Session Bean, Entity Bean and Message Driven Bean. EJB is used for server side
programming whereas java bean is a client side. Bean is only development but the EJB is
developed and then deploy on EJB Container.

Question: What is the difference between JTS and JTA?

Answer: In any J2EE application transaction management is one of the most crucial
requirements of the application. Given the complexity of today's business requirements,
transaction processing occupies one of the most complex segments of enterprise level distributed
applications to build, deploy and maintain. JTS specifies the implementation of a Java

Page 59 of 61
transaction manager. JTS specifies the implementation of a Transaction Manager which
supports the Java Transaction API (JTA) 1.0 This transaction manager supports the JTA, using
which application servers can be built to support transactional Java applications. Internally the
JTS implements the Java mapping of the OMG OTS 1.1 specifications. The Java mapping is
specified in two packages: org.omg.CosTransactions and org.omg.CosTSPortability. The JTS
thus provides a new architecture for transactional application servers and applications, while
complying to the OMG OTS 1.1 interfaces internally. This allows the JTA compliant applications
to interoperate with other OTS 1.1 complaint applications through the standard IIOP. Java-based
applications and Java-based application servers access transaction management functionality via
the JTA interfaces. The JTA interacts with a transaction management implementation via JTS.
Similarly, the JTS can access resources via the JTA XA interfaces or can access OTS-enabled
non-XA resources. JTS implementations can interoperate via CORBA OTS interfaces.

The JTA specifies an architecture for building transactional application servers and defines a set
of interfaces for various components of this architecture. The components are: the application,
resource managers, and the application server. The JTA specifies standard interfaces for Java-
based applications and application servers to interact with transactions, transaction managers,
and resource managers JTA transaction management provides a set of interfaces utilized by an
application server to manage the beginning and completion of transactions. Transaction
synchronization and propagation services are also provided under the domain of transaction

In the Java transaction model, the Java application components can conduct transactional
operations on JTA compliant resources via the JTS. The JTS acts as a layer over the OTS. The
applications can therefore initiate global transactions to include other OTS transaction
managers, or participate in global transactions initiated by other OTS compliant transaction

Question: Can Entity Beans have no create() methods?

Answer: Entity Beans can have no create() methods. Entity Beans have no create() method,
when entity bean is not used to store the data in the database. In this case entity bean is used to
retrieve the data from database.

Question: What are the call back methods in Session bean?

Answer: Callback methods are called by the container to notify the important events to the beans
in its life cycle. The callback methods are defined in the javax.ejb.EntityBean interface.The
callback methods example are ejbCreate(), ejbPassivate(), and ejbActivate().

Question: What is bean managed transaction?

Answer: In EJB transactions can be maintained by the container or developer can write own
code to maintain the transaction. If a developer doesn’t want a Container to manage
transactions, developer can write own code to maintain the database transaction.

Question: What are transaction isolation levels in EJB?

Answer: Thre are four levels of transaction isolation are:
* Uncommitted Read
* Committed Read
* Repeatable Read
* Serializable
The four transaction isolation levels and the corresponding behaviors are described below:

Page 60 of 61
Isolation Level Dirty Read Non-Repeatable Read Phantom Read
Read Uncommitted Possible Possible Possible
Read Committed Not possible Possible Possible
Repeatable Read Not possible Not possible Possible
Serializable Not possible Not possible Not possible

Page 61 of 61