URL'S

http://www.leepoint.net/notes-java/index.html
http://java2s.com/
http://www.studiesinn.com/topic-details/9/37.html
http://ajaxtraining.blogspot.com/

Interface

We use interface to achieve polymorphism. In simple english, the users of your class will have a reference of the interface rather than the class which actually implement that method. This is an object oriented principle that enforce 'keeping the concerns separate' and 'program to super class/interface rather than sub class'. For example: assuming Calculator is an interface, the users of your controller are allowed to call getCalculator to get it. Now, for users, the point of contact is 'Calculator', they shouldn't be interested which class actually implemented the Calculator interface to provide the logic.
public Calculator getCalculator() {
return new BasicCalculator();
}
In future version, you can change the logic, and your users will not be bothered, for example, in an overridden method:
public Calculator getCalculator()
{return new EnhancedCalculator();}
Take an example of T.V, you will see that the remote control is the Interface to your T.V functions. If some Functions are subjected to change/enhanced there should be no effect on the interface/remote control in this example.
Plus if you don't want to expose your logic to some one, (means you don't some one to share your code) you can give him you interface, a standard way to use your logic.

"Interface is like defining some protocol.
When you start building some module or package you must code it into some proper manner so if someone else wants to update or work on it, its working is clear for them. Means it should be generic code. So instead of starting whole thing into single class, you thing about some generic methods, constants your module needed, without thinking of its implementation. So here comes the concept of Interface and Abstract Classes.
When you start implementing method define in Interface you start working with classes which implementing your interface. "

Tricky Questions

1)Can I get Session object from servlet or jsp to simple java class?
2)What is a singleton class?
3)What is the difference between sendRedirect and forward in servlet ?
4)What happened if i clone a singleton object?
5)What is the difference between PrintWriter and JspWriter class?
6)Can I call a static variable with object?
7)What are the collection framework hibernate supports?
8)How to get variable value from javascript in to jsp page?
9)What is the difference between pageContext and SevletContext?
10)Why java doesnot support multiple inheritance?
11) Can we use a ResultSet object after closing the Connection??
Actually not, but you can use RowSet in connectionless mode
12) By default java will import java.lang
println() is the method of class PrintStream and in the package java.io.*
Why how we are able to use println() without importing java.io.*
we dont use println() directly :P , instead we use System.out.println() where out is a final static member of type PrintStream in System class, and System class imports java.io.* for us so we need not bother to import java.io package.
11) Explain Memory leak in java ?
12) Write a program of Dead Lock condition in java .
13) What is the difference between sleep(1000) and wait(1000) ?
15) What is delegation in Java?

Marker Interface and Reflection Mechanism

Marker Interface
The marker interface is just an empty interface. Its purpose is to "mark". That is, a class is suppose to contain certain capability so it "marks" itself with a marker interface -- for example a class capable of cloning itself marks itself with 'Cloneable' interface. Its just a way of Object Oriented Programming. A certain framework (for example RMI) will only deal with classes which are "mark" with their required interfaces (for example Remote).
Reflection Mechanism
Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts on objects, within security restrictions. The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class.
Ex.
import java.lang.reflect.*;
class B
{
private int val=10;
}
class A
{
public static void main(String[] args) throws Exception
{
B bob=new B();
Field fld=bob.getClass().getDeclaredField("val");fld.setAccessible(true);
System.out.println("value:"+fld.getInt(bob));}}

why EJB is only in appserver

EJB specs are part of Java Enterprise specifications. An App server implements JEE specifications, hence an EJB container is part of an app server. An EJB utilizes several other JEE components hence it usually does not exist as stand alone container.

There were some efforts to implement EJB as standalone container (just like JSP/Servlet container), but it wasn't successful.

Eclipse Shortcuts - Some really useful ones

I am trying to categorize them below:
Shortcuts for moving through members of a class:
Ctrl + Shift + Up Arrow Key — > It allows you to move one member up, that is if you have a large methods, and would like to move between methods this shortcut is very useful, rather then scrolling you can use this shortcut to move up the hierarchy in your class file, it jumps one member (including variables and methods) up.
Ctrl + Shift+ Down Arrow Key — > It allows you to move one member down, that is if you have a large methods, and would like to move between methods this shortcut is very useful, rather then scrolling you can use this shortcut to move down the hierarchy in your class file, it jumps one member (including variables and methods) down.
Ctrl+ F3 — > This one will pop up a window where you can see all the members of the class , and you can even type in the name of the member variable you are looking for, in a large class file having dozens of method and member variables, this shortcut should be your favorites weapon.
Shortcuts for closing files in Eclipse:
Ctrl + W — > It closes the current file on which you are working.
Ctrl + Shift + W — > Use this with caution , as it closes all the files in the editor at a single go.
Ctrl + F4 — > It closes the current file on which you are working, same as that of Ctrl + W.
Ctrl + Shift + F4 — > Use this with caution , as it closes all the files in the editor at a single go, same as that of Ctrl+ Shift + W. Depends on you choice which one to use.
Shortcuts for saving files in Eclipse:
Ctrl + S– > It is use for saving the current file on which you are working.
Ctrl + Shift + S — > It is used to save all the files in the editor which are open. (A good one if you have edited multiple files)
Shortcuts for Finding and moving around quickly:
Ctrl + L– > It takes you to the line number you specify, again one of the best shortcuts.
Ctrl + K — > Find Next, this is very useful, if you have something in search already using this will make you move around to the next search criteria.
Ctrl + Shift + K– > Find Previous, this will allow you to search backwards.
Shortcuts for Editing (Deleting) :
Ctrl + D– > Used for deleting a line.
Ctrl + Delete — > Used for deleting next word.
Ctrl + Backspace — > Used for deleting previous word.
Ctrl + Shift + Delete — > Delete to end of line.

What is scoped memory and why java uses it?

In java, a frequent occurence of a common phenomenon related to memory management is creation and destruction of temporary objects. What are java temporary objects? For example in java, when two strings are concatenated, a StringBuffer object is created. As two Java String objects cannot be added directly (immutable property), a helper object StringBuffer is used to construct a resultant java String object. This StringBuffer object is a temporary object, which is of no direct interest to the programmer. Most of the programming constructs are built in this type of model. Result of it is there are lot of garbage left behind.
Now the question is, what happens to the temporary java object and such garbage after the intended operation completes? Will it be saved for the life time of the program, or JVM (java virtual machine) or what is the underlying policy to destroy it? In automatic memory management the hassles of allocating and deallocating memory is no more a part of programmer’s job in java. But the downside of it is you never know, when an object will be freed. The java garbage collector (GC) doesnot provide any defined time boundaries.
This is where the java scoped memory concept comes into picture. Scoped memory concept is declaring to the JVM that, I am going to use this much amount of memory and those can be freed after this period. That is defining a boundary and bringing predictability. This predictability is needed the most for real time programming. Where you need to be certain about the cycles, time and cost of the operation.
In java scoped memory, the memory is preallocated for the task. This will ensure that the program will not get struck in the mid of operation because of memory resource shortage and constraints. Memory is deallocated and freed when the associated task gets completed. Therefore the recycling process of the memory is fast. But, all the objects related to that task and comes under that designated scope will disappear. If some objects are needed for future reference then that particular object needs to be associated to a different memory mechanism.
This is one of the latest feature in java adding power to the real-time java implementation. For more detail look into the Sun Java Real-Time System (Java RTS). It is Sun’s commercial implementation of the Real-Time Specification for Java (JSR-001).

Why not declare a constructor in servlet?

Technically you can define constructors in servlet. But, the declared constructor cannot access the ServletConfig object or throw a ServletException.
Then why is it not customary to declare a constructor in a servlet? Because the init() method is used to perform servlet initialization. In JDK 1.0 (servlet were written in this version), constructors for dynamically loaded Java classes such as servlets cannot accept arguments. Therefore init() was used to initialize by passing the implemented object of ServletConfig interface and other needed parameters.
Also, Java constructors cannot be declared in interfaces. So, javax.servlet.Servlet interface cannot have a constructor that accepts a ServletConfig parameter. To overcome this, init() method is used for initialization instead of declaring a constructor.

Serialization

Serialization is used to persist the state of an object into any permanent storage device (or) serialization is the technique of transporting objects over a data stream. It involves serializing of the object's state i.e. packing the data state of the object into bytes and then sending them over a stream to a reciever.
To make a class or a bean serializable we hv to implement either the java.io.Serializable interface, or the java.io.Externalizable interface. As long as one class in a class's inheritance hierarchy implements Serializable or Externalizable, that class is serializable.
transient 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).

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).THE ROLE OF SERIALIZATION IN EJB-------->A big part of EJB is that it is a framework for underlying RMI: remote method invocation. You’re invoking methods remotely from JVM space ‘A’ on objects which are in JVM space ‘B’ – possibly running on another machine on the network. To make this happen, all arguments of each method call must have their current state plucked out of JVM ‘A’ memory, flattened into a byte stream which can be sent over a TCP/IP network connection, and then deserialized for reincarnation on the other end in JVM ‘B’ where the actual method call takes place. If the method has a return value, it is serialized up for streaming back to JVM A. Thus the requirement that all EJB methods arguments and return values must be serializable. The easiest way to do this is to make sure all your classes implement java.io.Serializable.

http://en.wikipedia.org/wiki/Serialization

Explain typical Bean life cycle in Spring Bean Factory Container.

The following steps talk about throw light on how a bean life cycle is inside a bean factory container:
The bean's definition is found by the bean factory container from the XML file and instantiates the bean.
The Spring framework populates all of the properties as specified in the bean definition using DI.
If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean's ID.
If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.
If there are any BeanPostProcessors associated with the bean, their postProcessBeforeInitialization() methods will be called.
If an init-method is specified for the bean, it will be called.
Finally, if there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.

JDBC Problems and how does Spring framework help to resolve them?

JDBC helps in accessing underlying RDBMS but it sometimes be quite cumbersome to use them and in following situations it become problematic:
-You have to ensure that ResultSets, Statements and (most importantly) Connections are closed after use. Hence correct use of JDBC results in a lot of code which is a common source of errors. Connection leaks can quickly bring applications down under load.
-The SQLException does not provide much information about what actually the probelm is as JDBC does not offer an exception hierarchy, but throws SQLException in response to all errors.The meaning of these values varies among databases.
Spring addresses these problems in two ways:
-By providing APIs that move tedious and error-prone exception handling out of application code into the framework. The framework takes care of all exception handling; application code can concentrate on issuing the appropriate SQL and extracting results.
-By providing a meaningful exception hierarchy for your application code to work with in place of SQLException. When Spring first obtains a connection from a DataSource it examines the metadata to determine the database product. It uses this knowledge to map SQLExceptions to the correct exception in its own hierarchy descended from org.springframework.dao.DataAccessException. Thus your code can work with meaningful exceptions, and need not worry about proprietary SQLState or error codes. Spring's data access exceptions are not JDBC-specific, so your DAOs are not necessarily tied to JDBC because of the exceptions they may throw.

Aspect Oriented Programming and how is it related with Spring?

Aspect Oriented Programming(AOP) is a paradigm of developmental approach which is based on:-separation of concerns encompasses breaking down a program in parts which overlap in functionality as little as possible.-cross-cutting concerns is how modules,classes,procedures intersect each other and defy concern like encapsulation-advancement in modularization.An AOP language consists of crosscutting expressions that encapsulate the concern in one place. AspectJ has a number of such expressions and encapsulates them in a special class, an aspect.An aspect can-change the behavior of the base code (the non-aspect part of a program) by applying advice(additional behavior) at various joint points (points in a program) specified by query called a point cut (that detects whether a given join point matches).-make structural changes to other classes, like adding members or parents.Spring implements AOP using -dynamic proxies (where an interface exists) or-CGLIB byte code generation at runtime (which enables proxying of classes). It works well in any application server and standalone environment so there is no vebdor dependency.-Spring can use AOP for declarative transaction management eliminating the need of EJB conatiner or JTA for achieving the same.-Spring AOP supports method interception and both stateful (one instance per advised object) and stateless interceptors (one instance for all advice).-Spring AOP can be used to implement application-specific aspects also.It all depends upon how much comfortable you are with Aspect concepts rather Spring AOP capabilities.-Spring AOP integrates transparently with the Spring BeanFactory concept.

Inversion of Control/Dependency Injection

Spring is an Inversion of Control container through its bean factory concept.IoC helps in loose coupling of the code .Spring is most closely identified with a flavor of Inversion of Control known as Dependency Injection(DI)--a name coined by Martin Fowler, Rod Johnson and the PicoContainer team in late 2003.DI is an old concept which caught the fancy of Java EE community not so long ago.DI is quite useful in test driven development and avoiding dependencies on other collaborating objects helps in building unit tests of objects behavior that is under test.
It follows famous Hollywood principle "Don't call me.I will call you". IoC moves the responsibility for making things happen into the framework, and away from application code. Whereas your code calls a traditional class library, an IoC framework calls your code. It segregates the calling mechanism of methods from actual implementation.
Dependency Injection is a form of IoC.In DI an object uses the other object to provide a specific functionality.It removes explicit dependence on container APIs.The ordinary Java methods are used for injecting dependencies by collaborating objects or configuration values into application object instances. With Dependency Injection the container figures out that a component needs an X object, and provides it to it at runtime. The container does this figuring out based on method signatures (usually JavaBean properties or constructors) and, possibly, configuration data such as XML.
DI can be accomplished either by Setter Injection or Constructor Injection and Spring supports both.
Some advantages of DI:
-No need for look up code at runtime, hence simpler to write and maintain. JavaBean setter method or constructors arguments are used to introduce DI in Spring.
-Easier testing of JavaBeans through JUnits.
-Spring framework provides strongly typed dependencies which a developer needs not be bothered about and type mismatches are raised as errors when the framework configures the application.
-With a DI approach, dependencies are explicit, and evident in constructor or JavaBean properties.
-Spring is non invasive that means using it won't invade your code with dependency on its APIs.No dependency on container APIs of most business objects. Any third party code or any POJO can be introduced as a Spring Bean.
-Spring BeanFactories are very lightweight,can be used inside applets, as well as standalone Swing applications,work fine withing EJB containers as well.

Hibernate Mapping Cheat Sheet

http://ndpsoftware.com/HibernateMappingCheatSheet.html