JAVA J2EE Interview Questions and Answers

JAVA 7 Features

2011-03-13T19:11:00.001+05:30

Virtul Machine

JSR 292: Support for dynamically-typed languages (InvokeDynamic)

VM and language extensions to support the implementation of dynamically-typed languages at performance levels near to that of the Java language itself

Strict class-file checking [NEW]

Per the Java SE 6 specification, class files of version 51 (SE 7) or later must be verified with the typechecking verifier introduced by JSR 202 in Java SE 6; the VM must not fail over to the old inferencing verifier

Language

JSR 334: Small language enhancements (Project Coin)

A set of small language changes intended to simplify common, day-to-day programming tasks:

1. Strings in switch statements

2. Automatic resource management

3. Improved type inference for generic instance creation ("diamond")

4. Simplified varargs method invocation,

5. Better integral literals,

6. Improved exception handling (multi-catch)

Core

Upgrade class-loader architecture

Modifications to the ClassLoader API and implementation to avoid deadlocks in non-hierarchical class-loader topologies

Method to close a URLClassLoader

A method that frees the underlying resources, such as open files, held by a URLClassLoader

Concurrency and collections updates (jsr166y)

A lightweight fork/join framework, flexible and reusable synchronization barriers, transfer queues, a concurrent-reference HashMap, and thread-local pseudo-random number generators

Internationalization

Unicode 6.0

Upgrade the supported version of Unicode to 6.0

Locale enhancement

Upgrade the java.util.Locale class to support IETF BCP 47 and UTR 35 (CLDR/LDML)

Separate user locale and user-interface locale

Upgrade the handling of locales to separate formatting locales from user-interface language locales, as is done on Vista and later versions of Windows

I/O and Networking

JSR 203: More new I/O APIs for the Java platform (NIO.2)

New APIs for filesystem access, scalable asynchronous I/O operations, socket-channel binding and configuration, and multicast datagrams

NIO.2 filesystem provider for zip/jar archives

A fully-functional and supported NIO.2 filesystem provider for zip and jar files

SCTP (Stream Control Transmission Protocol)

An implementation-specific API for the Stream Control Transmission Protocol on Solaris

SDP (Sockets Direct Protocol)

Implementation-specific support for reliable, high-performance network streams over Infiniband connections on Solaris and Linux

Use the Windows Vista IPv6 stack

Upgrade the networking code to use the Windows Vista IPv6 stack, when available, in preference to the legacy Windows stack

TLS 1.2

Add support for TLS 1.2, which was standardized in 2008 as RFC 5246

Security & Cryptography

Elliptic-curve cryptography (ECC)

A portable implementation of the standard Elliptic Curve Cryptographic (ECC) algorithms, so that all Java applications can use ECC out-of-the-box

JDBC

JDBC 4.1

Upgrade to JDBC 4.1 and Rowset 1.1

Client

XRender pipeline for Java 2D

A new Java2D graphics pipeline based upon the X11 XRender extension, which provides access to much of the functionality of modern GPUs

Create new platform APIs for 6u10 graphics features

Create new platform APIs for features originally implemented in the 6u10 release: Translucent and shaped windows, heavyweight/lightweight mixing, and the improved AWT security warning

Nimbus look-and-feel for Swing

A next-generation cross-platform look-and-feel for Swing

Swing JLayer component

Add the SwingLabs JXLayer component decorator to the platform

Web

Update the XML stack

Upgrade the JAXP, JAXB, and JAX-WS APIs to the most recent stable versions

Management

Enhanced JMX Agent and MBeans [NEW]

An implementation-specific enhanced JMX management agent, ported from JRockit, which makes it easier to connect to the platform MBean server through firewalls, together with a richer set of MBeans which expose additional information about the internal operation of the VM

Deferred to JDK 8 or later

JSR 294: Language and VM support for modular programming

Enhancements to the Java language and virtual-machine specifications to support modular programming, at both compile time and run time

JSR 308: Annotations on Java types

An extension to the Java annotation syntax to permit annotations on any occurrence of a type

JSR TBD: Language support for collections

Literal expressions for immutable lists, sets, and maps, and indexing-access syntax for lists and maps

JSR TBD: Project Lambda

Lambda expressions (informally, "closures") and defender methods for the Java programming language

Modularization (Project Jigsaw)

A simple, low-level module system focused upon the goal of modularizing the JDK, and the application of that system to the JDK itself

JSR 296: Swing application framework

An API to define the basic structure of a typical Swing application, thereby eliminating lots of boilerplate code and providing a much-improved initial developer experience

Swing JDatePicker component

Add the SwingLabs JXDatePicker component to the platform

Courtesy: http://openjdk.java.net/projects/jdk7/features/#f353

Singleton - Multiple Users [Thread Safe]

2010-06-03T14:23:00.001+05:30

Following is the way by which we can use Singleton Design pattern for multiple users.

public class Singleton {
         private volatile static Singleton singleton; //volatile is needed so that multiple thread can reconcile the instance
         private Singleton(){
         }

         public static Singleton getSingleton(){ //synchronized keyword has been removed from here
         if(singleton = = null)
         {          //needed because once there is singleton available no need to aquire monitor again & again as it is costly
                synchronized(Singleton.class)
                {
                      //this is needed if two threads are waiting at the monitor at the time when singleton was getting instantiated
                      if(singleton==null)
                      {
                              singleton= new Singleton();
   }
                  }
          }
          return singleton;
    }
}

wait(), notify() and notifyAll()

2010-05-13T14:48:00.001+05:30

The wait(), notify() and notifyAll() methods are used to provide an efficient way for threads to wait for a shared resource. When a thread executes an object's wait() method, it enters the waiting state. It only enters the ready state after another thread invokes the object's notify() or notifyAll() methods.

Volatile Modifiers in Java

2010-05-10T12:29:00.000+05:30

Volatile Modifier

       The volatile modifier requests the Java Virtual Machine to always access the shared copy of the variable so the its most current value is always read. If two or more threads access a member variable, and one or more threads might update that variable’s value, and all of the threads do not use synchronization to read and/or write the variable value, then that member variable must be declared volatile to ensure all threads should get the updated value.
   We will discuss the java volatile modifier using following example.
       In our example, we take two threads Thread T1 and Thread T2 accessing member variable x of class C and here Thread T1 is not using synchronization and Thread T2 uses synchronization. If Thread T2 updates value of variable x from 0 to 1. But if the variable x is not declared as volatile then meanwhile Thread T1 tried to access variable then it will get value of variable x as 0. But as variable x is updated to 1 by Thread T2, To avoid this mess the variable x should be declared as volatile so Thread T1 should get updated value 1.

HashMap vs ConcurrentHashMap

2010-05-06T12:46:00.001+05:30

Both HashMap and ConcurrentHashMap are inherits some characteristics of Hashtable. But they have some prominent differences in context with performance, scalability.

HashMap

Since Java 1.2
Allows null key and value
Poor performance in highly threaded applications
Not much scalable
Throws a ConcurrentModificationException
Faster in non-multi threading applications

ConcurrentHashMap

Since Java 1.5
Doesn't allow null key or value
Better performance in Highly threaded applications
Highly scalable
Do not throw ConcurrentModificationException
Slower in non-multi threading applications

Read value from Java properties

2010-05-05T10:33:00.001+05:30

Here, you will find the source code to read value of the key from properties file. java.util.Properties class extends Hashtable. Properties class creates the properties file which stores key - value pair using Hashtable. To retrieve value from properties file we have to follow following steps.

Create an object of Properties class.
Load properties file using FileInputStream into properties object.
Get value from properties object using getProperty() method passing key as an input.

The below code will help to understand more...

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class PropertiesReadTest {

    public static void main(String[] args) {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("C:\\temp\\test.properties"));
            String value = properties.getProperty("key");
            System.out.println("Value = " + value);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output is shown here in following image

Source code to read content of File

2010-05-04T18:34:00.002+05:30

Here you will find the source code to read the content of file.

Steps

Create the FileReader object using file name as an input to FileReader constructor.
Pass that FileReader object to BufferedReader.
Read the line from BufferedReader object till readline gets null.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReadTest {

    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new FileReader("C:\\temp\\test.txt"));
            String line = "";
            while((line = br.readLine()) != null)
            {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Access file using JSP & Servlets

2010-05-03T15:14:00.003+05:30

Given source code used for accessing file from server using

Servlets

String path = getServletContext( ).getRealPath ("xyz.xml" ) ;
System.out.println ( path ) ;
File file = new File ( path ) ;

JSP
String path = application.getRealPath ("xyz.xml" ) ;
System.out.println ( path ) ;
File file = new File ( path ) ;

In above jsp code, "application" is jsp implicit object.

Java pass by value or pass by reference

2010-04-30T11:06:00.001+05:30

Java manipulates objects by reference, and all object variables are references. However, Java doesn't pass method arguments by reference; it passes them by value.
Java is strictly pass-by-value, exactly as in C.
Java has pointers and is strictly pass-by-value.

Encapsulation in JAVA

2010-04-29T18:42:00.001+05:30

Encapsulation in java means declare instance variables of class as private and access that instance variables using public methods.
Following is the example which shows that Person class having name and age are private instance variables and those are accessed by public getter and setter methods.

public class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

OOPs concepts in JAVA

2010-04-29T18:31:00.002+05:30

Abstraction: Hides certain details and only show the essential features of the object.
Encapsulation: The internal representation of an object is generally hidden from view outside of the object's definition.
Inheritance: Defines relationships among classes in an object-oriented language.
Polymorphism: Define more than one method with the same name.

finally block not executed

2010-04-29T18:04:00.001+05:30

Finally block is always executed except some of the following cases.

If the JVM exits while the try or catch code is being executed, then the finally block may not execute.

e.g. System.exit(0);

If the thread executing the try or catch code is interrupted or killed, the finally block may not execute even though the application as a whole continues.

e.g. Thread.interrupted();

J2EE Design Patterns

2010-04-29T17:54:00.001+05:30

Business Delegate
Composite Entity
Composite View
Data Access Object (DAO)
Fast Lane Reader
Front Controller
Intercepting Filter
Model-View-Controller
Service Locator
Session Facade
Transfer Object
Value List Handler
View Helper

Static vs Transient variables

2010-04-20T18:56:00.000+05:30

Static variables

Static variables are class variables.
Static variables can be serialized.
static modifier applies to static variables.

       class TestClass{
          static int testVariable;
          . . .
      }

Transient variables

Transient variables are member or instance variables of class.
Transient variables can not be serialized.
transient modifier applies to transient variables.

       class TestClass{
          transient int testVariable;
          . . .
      }

JDK 5 Enhancements in Java Language

2010-04-15T14:59:00.003+05:30

1. Generics - This is an enhancement to the type system allows a type or method to operate on objects of various types while providing compile-time type safety. It adds compile-time type safety to the Collections Framework and eliminates the drudgery of casting.

e.g.

Previously

Array List numbers = new ArrayList();

Now in JDK 5.0

Array List<Integer> numbers = new ArrayList<Integer> ();

2. Enhanced for Loop - This new language construct eliminates the drudgery and error-proneness of iterators and index variables when iterating over collections and arrays.

e.g.

Previously

Iterator itr = numbers.iterator();
while (itr.hasNext())

{
Integer element = (Integer)itr.next();
System.out.println (number);

}

Now in JDK 5.0

for (Integer number: numbers)

{

System.out.println (number);

}

3. Autoboxing/Unboxing - This facility eliminates the drudgery of manual conversion between primitive types (such as int, long) and wrapper types (such as Integer, Long).

e.g.

int number = 1;

Previously

Integer number2 = (Integer) number;

Now in JDK 5.0

Integer number2 = number;

4. Typesafe Enums - This flexible object-oriented enumerated type facility allows you to create enumerated types with arbitrary methods and fields. It provides all the benefits of the Typesafe Enum pattern ("Effective Java," Item 21) without the verbosity and the error-proneness.

e.g.

Previously

public static final int SEASON_WINTER = 0;

public static final int SEASON_SPRING = 1;

public static final int SEASON_SUMMER = 2;

public static final int SEASON_FALL = 3;

Now in JDK 5.0

enum Season {WINTER, SPRING, SUMMER, FALL}

5. Varargs - This facility eliminates the need for manually boxing up argument lists into an array when invoking methods that accept variable-length argument lists.

e.g.

Previously

Object[] arguments = {

new Integer(7),

new Date(),

"a disturbance in the Force"

};

String result = MessageFormat.forma("At {1,time} on {1,date}, there was {2} on planet "

+ "{0,number,integer}.", arguments);

Now in JDK 5.0

Using Varargs no need to create object array separately, we can give arguments directy.

String result = MessageFormat.format("At {1,time} on {1,date}, there was {2} on planet "

+ "{0,number,integer}.",

7, new Date(), "a disturbance in the Force");

6. Static Import - This facility lets you avoid qualifying static members with class names without the shortcomings of the "Constant Interface antipattern."

e.g.

Previously

double r = Math.cos(Math.PI * theta);

Now in JDK 5.0

import static java.lang.Math.*;

Once the static members have been imported, they may be used without qualification or class names:

double r = cos(PI * theta);

7. Annotations (Metadata) - This language feature lets you avoid writing boilerplate code under many circumstances by enabling tools to generate it from annotations in the source code. This leads to a "declarative" programming style where the programmer says what should be done and tools emit the code to do it. Also it eliminates the need for maintaining "side files" that must be kept up to date with changes in source files. Instead the information can be maintained in the source file.

Now in JDK 5.0

public @ interface Test{}

Retrieve key from HashMap using value

2010-04-14T17:46:00.001+05:30

Below is the code to retrieve the key from HashMap using value
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class TestClass {

    public static void main(String[] args) {
        Map<Integer, Person> people = new HashMap<Integer, Person>();
        Person person1 = new Person();
        person1.setName("Mack");
        person1.setPost("Dev");

        Person person2 = new Person();
        person2.setName("John");
        person2.setPost("Dev");

        people.put(1, person1);
        people.put(2, person2);

        Set<Entry<Integer, Person>> peopleSet = people.entrySet();
        for (Entry<Integer, Person> entry : peopleSet) {
            Integer key = entry.getKey();
            Person value = entry.getValue();
            if (value.equals(person2)) {
                System.out.println("Key = " + key);
            }
        }
    }
}

Servlet Chaining

2010-04-13T18:04:00.003+05:30

Servlet Chaining means the output of one servlet given as a input to another servlet. Servlet Aliasing allows us to invoke more than one servlet in sequence when the URL is opened with a common servlet alias. The output from first Servlet is sent as input to other Servlet and so on. The Output from the last Servlet is sent back to the browser. The entire process is called Servlet Chaining.

How to do Servlet Chaining in Servlet Programming?

Using include
RequestDispatcher rd = req.getRequestDispatcher("SecondServlet");
rd.include(request, response);

Using forward
RequestDispatcher rd = req.getRequestDispatcher("SecondServlet");
rd.forward(request, response);

JDBC driver types

2010-04-12T17:41:00.000+05:30

JDBC drivers are divided into four types.

Type 1: JDBC-ODBC Bridge
Type 2: Native-API/partly Java driver
Type 3: Net-protocol/all-Java driver
Type 4: Native-protocol/all-Java driver

Java Database Connectivity (JDBC)

2010-04-12T17:24:00.001+05:30

JDBC is Java Database Connectivity helps to write java applications using databases.

Steps to use JDBC in java applications as follows

Load the JDBC driver.
Define the connection URL.
Establish the connection.
Create a statement object.
Execute a query or update.
Process the results.
Close the connection.

try {
            Class.forName("driveClassName");
            Connection con = DriverManager.getConnection(
                    "jdbc:driveName:databaseName", "login", "password");

            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM Table");
            while (rs.next()) {
                int a = rs.getInt("column1");
                String b = rs.getString("column2");
                float c = rs.getFloat("column3");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            // close the connection
        }

Serialization and Deserialization

2010-04-12T12:29:00.004+05:30

Serialization is the process of transforming an in-memory object to a byte stream.
An object is serialized by writing it to an ObjectOutputStream.
Serialization Code

           FileOutputStream out = new FileOutputStream("test.txt" );
           ObjectOutputStream oos = new ObjectOutputStream( out );
           oos.writeObject(new String ());
           oos.close ();

Deserialization is the inverse process of reconstructing an object from a byte stream to the same state in which the object was previously serialized.
An object is deserialized by reading it from an ObjectInputStream.
Deserialization Code

FileInputStream in = new FileInputStream( "test.txt" );

ObjectInputStream ois = new ObjectInputStream( in );

String s = (String) ois.readObject();

ois.close();

JAR WAR and EAR Files

2010-04-12T11:48:00.001+05:30

JAR Files (Java Archive):

These files are with the .jar extension.
The .jar files contain the classes, libraries, resources and accessories files like property files.

WAR Files (Web Archive):

These files are with the .war extension.
The war file contains JSP, html, JavaScript and other files for necessary for the development of web applications.
The war file contains the web application that can be deployed on the any servlet/jsp container.

EAR Files:

These files are with the .ear extension.
The .ear file contains the EJB modules of the applications.
The ear file contains the ejb application that can be deployed on the any application server with ejb container.

Difference between customTags and JavaBeans

2010-04-12T08:42:00.001+05:30

JavaBeans are the data handlers of JSP and aid in encapsulating data management logic. They are used for storage Tags on the other hand, aid computational logic related to a particular request.
Tags are thread safe; beans are not. Beans like other separate utility classes, have to be made thread safe by the developers.
Tags are aware of the environment (the page context) in which they execute. Beans are not.
Tags remain in the translation unit.We can think of tags as events occuring in the execution of a JSP page. Beans are object stores that reside outside the translation unit.
Tags can access implicit objects. Beans are cannot.
Tags only have page scope. They are created and destroyed withen a single request and in a single page. They can access other objects in all the scopes, though. Beans, on the other hand. Are themselves objects that reside in different scopes. Therefore, tags can access and manipulte beans, while beans do not access and manipulate tags.
The Tag Extension API designed closely with the concept of a JSP page in mind. They may not be used in other applications. Beans, on the other hand are supposed to be resuable compnents and can be used by other container.
Tags are not persistent objects. Beans have properties, and properties have values. A set of values is called the state of the bean. This state can be persisted via serialization and resued later.

JSP Standard Actions

2010-04-11T12:50:00.001+05:30

JSP standard actions are commands given to the JSP engine. They direct the engine to perform certain tasks during the execution of a page.
e.g. The following line instructs the engine to forward request to another JSP page, welcome.jsp from current JSP page.

<jsp:forward page="welcome.jsp"/>

There are six standard JSP actions:

jsp:include
jsp:forward
jsp:useBean
jsp:setProperty
jsp:getProperty
jsp:plugin

Difference between GET Method and POST Method

2010-04-10T16:45:00.001+05:30

GET Method

Target resource type is Active or passive
Type of data is Text
The amount of data handled by GET Method is not more than 255 characters.
Data is part of the URL and is visible to the user in the URL field of browser.
Data can be cached in the browser's URL History.

POST Method

Target resource type is Active
Type of data is Text as well as Binary
The amount of data handled by POST Method is unlimited.
Data is not a part of the URL and is sent as the request message body. It is not visible to the user in the URL field of browser.
Data is not cached in the browser's URL History.

Difference between abstract class and interface

2010-04-08T14:10:00.001+05:30

What is an Abstract Class?

An abstract class is a special kind of class that cannot be instantiated.So the question is why we need a class that cannot be instantiated? An abstract class is only to be sub-classed (inherited from). In other words, it only allows other classes to inherit from it but cannot be instantiated. The advantage is that it enforces certain hierarchies for all the subclasses. In simple words, it is a kind of contract that forces all the subclasses to carry on the same hierarchies or standards.
A class may inherit only one abstract class.
An abstract class can contain access modifiers for the subs, functions, properties
Fast
An abstract class can have fields and constants defined

What is an Interface?

An interface is not a class. It is an entity that is defined by the word Interface. An interface has no implementation; it only has the signature or in other words, just the definition of the methods without the body. As one of the similarities to Abstract class, it is a contract that is used to define hierarchies for all subclasses or it defines specific set of methods and their arguments. The main difference between them is that a class can implement more than one interface but can only inherit from one abstract class.
A class may inherit several interfaces.
An interface cannot have access modifiers for the subs, functions, properties etc everything is assumed as public
Requires more time to find the actual method in the corresponding classes.
No fields can be defined in interfaces