JAVA INTERVIEW QUESTIONS

JAVA: Singleton Pattern - Concept and 7 Most Popular Implementation Style

noreply@blogger.com (Anijit Sarkar) — Mon, 10 Feb 2014 07:27:00 +0000

Singleton in one of the most popular yet controversial design pattern, in the world of object oriented programming. It's one of those patterns, that every developer comes to know first and again it's one of of those patterns, that even experience developers get confused with it's proper implementation style. So, over here, we will first take a deeper look on the concept of Singleton design pattern and then we will discuss all the popular implementation styles of Singleton in java with suitable examples.
This post is a little bit bigger than usual. So please be patient, because it's worth reading.

Concept

Singleton is a software design pattern to limit the instantiation of a class to one, which will be globally accessible. That means it’s a technique by which a class only have one instance/object and this object can be accessed globally. It is a part of Gang of Four design pattern and it comes under creational design patterns.

Applications, often needs to create single instance of a class, and that instance will be used throughout the application. Examples like logging, database access, etc. We could pass such an instance from method to method, or we can also assign it to each object in the application. But, that will create lots of complexity. On the other hand, we could use a single instance to communicate with a class. Hence, the class could create and manage a single instance of its own. And when needed, just talk to that class.

Principles of Singleton

Therefore, the principles of Singleton design pattern are -
1. The implementing class should have only one instance.
2. Access point of this single instance should be global.

Example of Singleton class in Java: One of the most popular singleton examples is java.lang.Runtime class. It’s a singleton class, you can’t initialize this class, but you can get the instance by calling getRuntime() method.

Structure

So, what will be the structure of a singleton class?

Well, it should contain the following properties:

1. It should have a private static member of the class.

2. The constructor should be private, so that, no one from outside can initialize this class.

3. A public static method which will expose the private member of the class to the outer world.

What if we use static class instead of Singleton?

Now, question may come, what if we use a static class instead of a Singleton class?

Well, there are some advantages of using Singleton over static class.
1. Static class can only have static members, where in Singleton pattern implemented class can have non-static members.
2. A Singleton class can implement interfaces as well as extend classes but a static class can extend classes, without inheriting their instance members.
3. A static class can’t be a top level class. It should be always nested class. That means, under some non-static class. Because, by definition static means that it belongs to a class it is in.
4. We can clone an object of a Singleton class, but in static class, that is not possible.
5. Again, Singleton supports the features like polymorphism while, for a static class it’s not possible.
6. Singleton classes can also supports the lazy loading facility, which is not supported in a static class.

Implementation Styles

In Java programming language, Singleton pattern can be archive by different implementation style. Each has some pros and corns. One single style is not suitable for every situation. So I think you should know, all of them, and use it as per your requirement.

Now, we are going to discuss about some of the most popular implementation style.

7 most popular implementation style of singleton design pattern in java:

Simple Lazy Initialization:

The lazy initialization singleton implementation style initializes the instance of a singleton class when it’s first being used. That means, the private static instance, (that is described in Structure) is initialized not during the class load, but during its first use. Lazy initialization is very helpful, when is object cost of a singleton class is high, i.e., it may take lots of time or memory.
It's only loaded, when it's actually being used.

Simple Lazy Initialization is the most basic style for lazy loading. It's good for the newbies to understand the concept and structure of Singleton pattern.The concept of this style is to declare the private static instance of the class by setting the initial value as null during class load, keeping the actual initialization for the first call. That means, the actual initialization of the single instance of the class is only happening when for the first time the class has been called.

Let’s take a look on the below example. The class LazyInitializationThreadUnsafe is a singleton class, which contains a counter, every time called gives you a sequential incremental number.
Example: Class LazyInitializationThreadUnsafe

package interview.question.java.singleton;

/**

* The class LazyInitializationThreadUnsafe is Singleton Class suitable for

* single thread application. This class also provides a public method named

* counter() which will always returns integer type sequenced counter value

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public class LazyInitializationThreadUnsafe {

* The integer type counter will hold the value of the counter. The scope of

* this field is private, so its only accessible via the counter method.

* It's static so that only one copy of this variable will be available

* within the memory.

private static int counter = 0;

* The static private member instance of type LazyInitializationThreadUnsafe

* Class will hold the single instance of this class.

private static LazyInitializationThreadUnsafe instance = null;

* The constructor of the LazyInitializationThreadUnsafe class is in private

* scope so that, no one can initialize this class.

private LazyInitializationThreadUnsafe() {

System.out

.println("LazyInitializationThreadUnsafe.LazyInitializationThreadUnsafe()");

}

* The method getInstance() will return the only instance of the class

* LazyInitializationThreadUnsafe. It will initialize the object if the

* instance is null by accessing the private constructor of this class.

public static LazyInitializationThreadUnsafe getInstance() {

if (instance == null) {

instance = new LazyInitializationThreadUnsafe();

}

return instance;

}

* This sample method will increase the counter by 1 and returns its value.

public int counter() {

counter++;

System.out.println("LazyInitializationThreadUnsafe.counter()");

return counter;

}

Here, we are first declaring the class instance as null.

private static LazyInitializationThreadUnsafe instance = null;

Now, when globally accessible getInstance() is called,
1. it will check if the instance is null or not.
2. if null initialize it.
3. return the instance.

if (instance == null) {

instance = new LazyInitializationThreadUnsafe();

}

So, it will be initialize only for the first time the getInstance() method has been called.

But, this style is not thread safe. Its only good for single threaded environment.

Life cycle:

• Initializes during first use.

• Destroyed at application shutdown.

Pros:

• It supports lazy initialization, so it will only been loaded to the memory when it’s actually needed for the first time.

Corns:

• It’s preferable only on single thread environment.

Thread Safe Lazy Initialization:

The concept of this style is same as other lazy initialization style; the only difference with the previous lazy initialization style is its thread safe.

Let’s take a look on an example. The below class LazyInitializationThreadSafe is a thread safe lazy initialization style.
Example: Class LazyInitializationThreadSafe

package interview.question.java.singleton;

/**

* The class LazyInitializationThreadSafe is Singleton Class suitable for

* multithreaded application.

* This class also provides a public method named counter()

* which will always returns integer type sequenced counter value

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public class LazyInitializationThreadSafe {

* The integer type counter will hold the

* value of the counter.

* The scope of this field is private, so its

* only accessible via the counter method.

* It's static so that only one copy of this variable

* will be available within the memory.

Private static int counter = 0;

* The static private member instance of type LazyInitializationThreadSafe

* Class will hold the single instance of this class.

private static LazyInitializationThreadSafe instance = null;

* The constructor of the LazyInitializationThreadSafe class is in

* private scope so that, no one can initialize this class.

private LazyInitializationThreadSafe() {

System.out

.println("LazyInitializationThreadSafe.LazyInitializationThreadSafe()");

}

* The static method getInstance() will return the only instance

* of the class LazyInitializationThreadSafe.

* It will initialize the object if the

* instance is null by accessing the private constructor

* of this class.

* The method getInstance() is synchronized to make it thread safe.

public static synchronized LazyInitializationThreadSafe getInstance() {

if (instance == null) {

instance = new LazyInitializationThreadSafe();

}

return instance;

}

* This sample method will increase the counter

* by 1 and returns its value.

public int counter() {

counter++;

System.out.println("LazyInitializationThreadSafe.counter()");

return counter;

}

Now, in this class you will find only one difference from the previous example (Class LazyInitializationThreadUnsafe), that is, I use the synchronized Now, in this class getInstance() method. That means, concurrent threads will use this method in atomic way. Thus, it’s safe from concurrent usage of this method by multiple threads. And it becomes thread safe.

Life cycle:

• Initializes during first use.
• Destroyed at application shutdown.

Pros:

• Thread safe
• It uses lazy loading so it’s been initialized during its actual usage.

Corns:

• A bit slower that not thread safe style, the getInstance() goes through synchronized method. So it’s locking the resource every time you call it.

Double Check Locking:

Another technique to implement thread safe lazy initialization is double check locking. This concept will work fine in Java 5 or above. This concept is introduced to optimize the thread safe lazy initialization style of the Singleton pattern, which locks the resources, every time you try to get the instance of the class using a public scoped method.

Let’s see in details by the example class DoubleCheckLock.
Example: Class DoubleCheckLock

package interview.question.java.singleton;

/**

* The class DoubleCheckLock is Singleton Class which implements the double

* check lock style. This class also provides a public method named counter()

* which will always returns integer type sequenced counter value

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public class DoubleCheckLock {

* The static private member instance of type DoubleCheckLock Class will

* hold the single instance of this class.

private static volatile DoubleCheckLock instance = null;

* The integer type counter will hold the value of the counter. The scope of

* this field is private, so its only accessible via the counter method.

* It's static so that only one copy of this variable will be available

* within the memory.

private static int counter = 0;

* The constructor of the DoubleCheckLock class is in private

* scope so that, no one can initialize this class.

private DoubleCheckLock() {

System.out.println("DoubleCheckLock.DoubleCheckLock()");

}

* The method getInstance() will return the only instance of the class

* DoubleCheckLock. It will initialize the object if the instance is null by

* accessing the private constructor of this class.

public static DoubleCheckLock getInstance() {

if (instance == null) {

synchronized (DoubleCheckLock.class) {

if (instance == null) {

instance = new DoubleCheckLock();

}

return instance;

}

* This sample method will increase the counter by 1 and returns its value.

public int counter() {

counter++;

System.out.println("DoubleCheckLock.counter()");

returncounter;

}

Now, over here if you see, you will find the difference is in technique of initializing the instance inside getInstance() method.

if (instance == null) {

synchronized (DoubleCheckLock.class) {

if (instance == null) {

instance = new DoubleCheckLock();

}

Here, what we are doing is,

1. Checking if the instance has been initialized or not.

2. If not, creating locks by using synchronized.

3. Again checking if the instance is already initialized or not.

4. If still not, then initializing the instance of the class.

This is been introduced as in previous example (class LazyInitializationThreadSafe), we always locking the method getInstance(), every time it’s been called. While, it’s only need when its initializing the instance.

You can also see that, we use the volatile keyword, when declaring the instance of the class. That’s, to inform the JVM that writes to the field should always be synchronously flushed to memory, and that reads of the field should always read from memory.

Life cycle:

• Initializes during first use.

• Destroyed at application shutdown.

Pros:

• Thread safe style.

• Doing lazy loading.

• Performance wise it’s faster than Thread safe lazy initialization as its only locking during initialization.

Corns:

• Code complexity.
• Should only use in java 5 or above.

Early or Eager Initialization

Early or eager initialization style is to initialize the instance of a singleton class during class loading. This style is very effective, if the instance is not that costly. In this technique, the instance of the class has been initialized during its declaration and marked with final keyword, so that it can’t be modified. One more benefit of using this style is, it’s totally thread safe.

Let us see by using an example singleton class EagerInitialization.
Example: Class EagerInitialization

package interview.question.java.singleton;

/**

* The class EagerInitialization is Singleton Class which implements

* the Eager Initialization style suitable for both single

* threaded or multithreaded application.

* This class also provides a public method named counter()

* which will always returns integer type sequenced counter value

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public class EagerInitialization {

* The integer type counter will hold the

* value of the counter.

* The scope of this field is private, so its

* only accessible via the counter method.

* It's static so that only one copy of this variable

* will be available within the memory.

private static int counter = 0;

* The static private member instance of type EagerInitialization

* Class will hold the single instance of this class.

private static final EagerInitialization INSTANCE = new EagerInitialization();

* The constructor of the EagerInitialization class is in

* private scope so that, no one can initialize this class.

private EagerInitialization() {

System.out.println("EagerInitialization.EagerInitialization()");

}

* The static method getInstance() will return the only instance

* of the class EagerInitialization.

public static EagerInitialization getInstance() {

return INSTANCE;

}

* This sample method will increase the counter

* by 1 and returns its value.

public int counter() {

counter++;

System.out.println("EagerInitialization.counter()");

return counter;

}

In this example, you can see its simply initializing the instance during declaration under private static final clause. And returns it via a public static method getInstance().

Life cycle:

• Initializes during class load.
• Destroyed at application shutdown.

Pros:

• Thread safe.
• Performance wise, faster than lazy initialization, as it’s not locking any resource by synchronized.
• The instance is final, so scope of redefining, thus, no scope of multiple instance.

Corns:

• Initializes during class load, so it is occupying memory, even when it’s not required.

Static block initialization

Static block initializing is another style of early initialization. The only difference is you are initializing the instance of the class under a static block with error checking.

Now, try it with this example class StaticBlockInitialization.
Example: Class StaticBlockInitialization

package interview.question.java.singleton;

/**

* The class StaticBlockInitialization is Singleton Class which implements the

* Static Block Initialization style. This class also provides a public method

* named counter() which will always returns integer type sequenced counter

* value

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public class StaticBlockInitialization {

* The integer type counter will hold the value of the counter. The scope of

* this field is private, so its only accessible via the counter method.

* It's static so that only one copy of this variable will be available

* within the memory.

private static int counter;

* The static private member instance of type StaticBlockInitialization

* Class will hold the single instance of this class.

private static final StaticBlockInitialization INSTANCE;

* Initializing static members under static block

static {

try {

INSTANCE = new StaticBlockInitialization();

counter = 0;

} catch (Exception e) {

throw new RuntimeException(e.getMessage(), e);

}

* The constructor of the StaticBlockInitialization class is in private

* scope so that, no one can initialize this class.

private StaticBlockInitialization() {

System.out

.println("StaticBlockInitialization.StaticBlockInitialization()");

}

* The static method getInstance() will return the only instance of the

* classStaticBlockInitialization.

public static StaticBlockInitialization getInstance() {

return INSTANCE;

}

* This sample method will increase the counter by 1 and returns its value.

public int counter() {

counter++;

System.out.println("StaticBlockInitialization.counter()");

return counter;

}

Here, you can see we are initializing the instance of the class under a static block. And we are also doing it under try catch block, to provide an error check during initialization.

Life cycle:

• Initializes during class load.
• Destroyed at application shutdown.

Pros:

Corns:

• Initializes during class load, so it is occupying memory, even when it’s not required.

Demand Holder Idiom by Bill Pugh

Again back to lazy initialization style, but this time, back with a better way of use lazy implementation. Demon holder idiom is written by an American computer scientist Bill Pugh. The concept with this pattern is to declare and initialize the instance as private static final under a static inner class.

Let’s see with the example class DemandHolderIdiom.
Example: Class DemandHolderIdiom

package interview.question.java.singleton;

/**

* The class DemandHolderIdiom is Singleton Class which implements the Demand

* Holder Idiom style. This class also provides a public method named counter()

* which will always returns integer type sequenced counter value.

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public class DemandHolderIdiom {

* The integer type counter will hold the value of the counter. The scope of

* this field is private, so its only accessible via the counter method.

* It's static so that only one copy of this variable will be available

* within the memory.

private static int counter = 0;

* The constructor of the DemandHolderIdiom class is in private scope so

* that, no one can initialize this class.

private DemandHolderIdiom() {

System.out.println("DemandHolderIdiom.DemandHolderIdiom()");

}

* The class SingletonInstanceHolder is a private class which only contains

* single instance of the class DemandHolderIdiom

private static class SingletonInstanceHolder {

* The static private member instance of type SingletonInstanceHolder

* Class will hold the single instance of this class.

public static final DemandHolderIdiom INSTANCE = new DemandHolderIdiom();

}

* The static method getInstance() will return the only instance of the

* classDemandHolderIdiom, which is declared under SingletonInstanceHolder

* class.

public static DemandHolderIdiom getInstance() {

returnSingletonInstanceHolder.INSTANCE;

}

* This sample method will increase the counter by 1 and returns its value.

publicint counter() {

counter++;

System.out.println("DemandHolderIdiom.counter()");

returncounter;

}

Over here, you can see, the instance of the singleton class has been declared and initialized under a static inner class SingletonInstanceHolder. And when getInstance() is called, it’s the return the instance under the inner class.

Now, the question is, how is Domain Holder Idiom working as lazy initialization style?

The answer is, when the class DemandHolderIdiom is loaded, it goes through initialization of only the static fields. Since it doesn’t have any static variable to initialize, SingletonInstanceHolder is not loaded during class loading. So, when it will initialize? Well, it will only loaded when the JVM thinks that SingletonInstanceHolder must be executed. And that is only when this inner class has been called from the getInstance() method for the first time. Now, when this inner class is loaded, all its static variables are also loaded. So the instance is also initialized by executing the private constructor of the outer class. You can also read Java Language Specification (JLS) for more details about class loading and initialization. As the class initialization phase is guaranteed by the JLS to be serial, i.e., non-concurrent, so no further synchronization is required in the static getInstance() method during loading and initialization.

Life cycle:

• Initializes during first use.

• Destroyed at application shutdown.

Pros:

• Thread safe.

• Lazy loading.

• No need of resource locking to make it thread safe. Thus, performance is also good.

Corns:

• No such disadvantage as far. Still, it should be used when you need the lazy loading facility. Else, early loading is simple to understand and use.

Using enum by Joshua Bloch

Another technique to create singleton is by using Enum. Well Enum is introduced in Java 5, so it’s applicable in java 5 or higher versions. A computer scientist Joshua Bloch claims that "a single-element enum type is the best way to implement a singleton" in his book Effective Java [2nd edition]. Enum is thread safe and serialization.
Let’s see an implementation with an enum UsingEnum.
Example: Enum UsingEnum

package interview.question.java.singleton;

/**

* The enumUsingEnum is defined to behave as Singleton . It also provides a

* public method named counter() which will always returns integer type

* sequenced counter value.

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public enum UsingEnum {

Instance;

* The integer type counter will hold the value of the counter. The scope of

* this field is private, so its only accessible via the counter method.

* It's static so that only one copy of this variable will be available

* within the memory.

private static int counter = 0;

* This sample method will increase the counter by 1 and returns its value.

public int counter() {

counter++;

System.out.println("UsingEnum.counter()");

return counter;

}

Here, you can see the code is very simple.

public enum UsingEnum {

Instance;

}

By this only your singleton is created. So, don’t even need any locking for thread safety. Enum also supports serialization. But it is unable to extend any class [read more for details].

Life cycle:

• Initializes during first use.
• Destroyed at application shutdown.

Pros:

• Thread safe.
• Supports serialization.
• No locking is needed, so performance is better.
• Code simplicity.

Corns:

• Available from java 5
• Unable to extend any class.

Test Class to execute all Singleton Examples

Now, it’s time to test the all above singleton classes. For that, we have a Test class, which simple calls all the above classes twice, to see if its initializing once or more, by using a loop.

package interview.question.java.singleton;

/**

* The class Test will call all the singleton classes to test.

* @author Java Interview Questions [http://interviewquestionjava.blogspot.com]

**/

public class Test {

public static void main(String[] args) {

for (int i = 0; i< 2; i++) {

//LasyInitializationThreadUnsafe

LasyInitializationThreadUnsafelasyInitializationSingleThread = LasyInitializationThreadUnsafe

.getInstance();

System.out.println(lasyInitializationSingleThread.counter());

//LasyInitializationThreadSafe

LasyInitializationThreadSafelasyInitializationThreadSafe = LasyInitializationThreadSafe

.getInstance();

System.out.println(lasyInitializationThreadSafe.counter());

//DoubleCheckLock

DoubleCheckLockdoubleCheckLock = DoubleCheckLock.getInstance();

System.out.println(doubleCheckLock.counter());

//EagerInitialization

EagerInitializationeagerInitialization = EagerInitialization

.getInstance();

System.out.println(eagerInitialization.counter());

//StaticBlockInitialization

StaticBlockInitializationstaticBlockInitialization = StaticBlockInitialization

.getInstance();

System.out.println(staticBlockInitialization.counter());

//DemandHolderIdiom

DemandHolderIdiomdemandHolderIdiom = DemandHolderIdiom

.getInstance();

System.out.println(demandHolderIdiom.counter());

//UsingEnum

System.out.println(UsingEnum.Instance.counter());

System.out.println("\n\n");

}

Output:

Now, from the output it’s clear that, all the singleton classes have been initialized for one time.

LasyInitializationThreadUnsafe.LasyInitializationThreadUnsafe()

LasyInitializationThreadUnsafe.counter()

LasyInitializationThreadSafe.LasyInitializationThreadSafe()

LasyInitializationThreadSafe.counter()

DoubleCheckLock.DoubleCheckLock()

DoubleCheckLock.counter()

EagerInitialization.EagerInitialization()

EagerInitialization.counter()

StaticBlockInitialization.StaticBlockInitialization()

StaticBlockInitialization.counter()

DemandHolderIdiom.DemandHolderIdiom()

DemandHolderIdiom.counter()

UsingEnum.counter()

LasyInitializationThreadUnsafe.counter()

LasyInitializationThreadSafe.counter()

DoubleCheckLock.counter()

EagerInitialization.counter()

StaticBlockInitialization.counter()

DemandHolderIdiom.counter()

UsingEnum.counter()

Conclusion

Well, after discussing all the implementation styles, we may think the Enum Singleton Style and Domain Holder Idiom are the most smarter ways to implement Singleton pattern in java. But that doesn't mean other styles are irrelevant. Styles like Simple Lazy Initialization Style and Early Initialization are very good for learning phase. Because you can get the concept and structure of a singleton class very clearly form these patterns. And remember java.lang.Runtime uses Early Initialization too.

Therefore, when it comes to Singleton Implementation style, choose wisely and code smartly.

Anijit Sarkar

FRAMEWORK: ORM – Object Relational Mapping

noreply@blogger.com (Anijit Sarkar) — Mon, 13 Jan 2014 21:26:00 +0000

ORM (Object Relational Mapping) is a programming concept of a mapping between Object Oriented Programming and Relational Database. It’s the technique to frame the components of Relational Database to Object Oriented Programming, to do CRUD operations. It creates an object oriented representation of a relational database, so that developers can push or pop data to database as an object.

Databases are designed on the basis of Mathematical principle where as programming languages like Java, C++, C# are based on Object Oriented Programming principle. Objects have behavior and attribute, it’s good on business modeling where on the other hand database is only deals with large amount of data. Now due to this conceptual deference, in real life scenario, database transactions become unmanageable, when we are dealing with large amount of data transaction. So to bridge this difference, ORM is introduced. It’s the process of mapping tables to class objects, so that data transactions could be easier.

Pros:

Create classes replicating database tables, in programming language side, so that programs can interacts with objects not direct tables.
Provides APIs for normal CRUD (Create Read Update Delete) operations, so no need to write queries for that.
Some provides query language which is database independent.
Provision to interact with multiple databases.
Helps to manage business logic easily when dealing with big amount of data, and lots of database transaction.

Corns:

No need to use when your application doesn't involve much database interaction.
Little bit heavier than native database connectivity.

JAVA: Data Types Conversion Chart

noreply@blogger.com (Anijit Sarkar) — Fri, 10 Jan 2014 21:43:00 +0000

In Java Programming Language, we must declare a variable name and type, before using it. The data type of a variable defines the the type of value it will contain. Java supports total 8 types of primitive data types. The name of this data types are all reserved as keywords.
Among which, 1) byte, 2) short, 3) int & 4) long can store integer values of different range.
5) float and 6) double can store floating numbers of different range.
7) boolean can store only true/false. It is used as flag, to perform boolean operation.
8) char can store a single 16-bit Unicode character of range from '\u0000' (0) to '\uffff' (65,535).
Apart from these, Java also provides a String data type which is defined as a Class (java.lang.String). It can contains alpha numeric values.

byte

Type: Integer (8-bit signed two's complement integer).
Range: from -128 [-2^(8-1)] to 127 [(2^(8-1))-1].
Memory: 1 byte
Default Value : 0
Example: byte b = 0;

short

Type: Integer (16-bit signed two's complement integer).
Range: from -32768 [-2^(16-1)] to 32767 [(2^(16-1))-1].
Memory: 2 bytes
Default Value : 0
Example: short s = 0;

int

Type: Integer (32-bit signed two's complement integer).
Range: from -2147483648 [-2^(32-1)] to 2147483647 [(2^(32-1))-1].
Memory: 4 bytes
Default Value : 0
Example: int i = 0;

long

Type: Integer (64-bit signed two's complement integer).
Range: from -9223372036854775808 [-2^(64-1)] to 9223372036854775807 [(2^(64-1))-1].
Memory: 8 bytes
Default Value : 0L
Example: long l = 0L;

float

Type: Float (Single precision 32-bit IEEE 754 floating point).
Range: from 1.4E-45F to 3.4028235E+38F.
Memory: 4 bytes
Default Value : 0.0f
Example: float f = 0f;

double

Type: Float (Single precision 64-bit IEEE 754 floating point).
Range: from 4.9E-324D to 1.7976931348623157E+308D.
Memory: 8 bytes
Default Value : 0.0d
Example: double d = 0d;

boolean

Type: boolean (boolean flag - true / false).
Range: NA.
Memory: virtual machine dependent
Default Value : false
Example: boolean b = false;

char

Type: Character (a single 16-bit Unicode character).
Range: from '\u0000' (0) to '\uffff' (65535).
Memory: 2 bytes
Default Value : '\u0000'
Example: char c = '\u0000';

String

Type: String Character (a class can store alpha numeric value).
Range: NA
Memory: NA
Default Value : null
Example: String s = "Hello World";

Anijit Sarkar

JAVA: Overloading and Overriding

noreply@blogger.com (Anijit Sarkar) — Sun, 15 Sep 2013 20:54:00 +0000

Overloading:

Overloading is a popular technique of object oriented programming. It allows you to define a method with same name but with different parameters list.

Java identifies method by its name and signature. So, if the combination of method name and signature is unique, the compiler doesn’t have any issue to identify it. When you use overloaded methods, the java compile will automatically identifies the right version of the method by number and/or types of passing parameters. But you can’t declare more than one method with same name and passing parameters. The compiler doesn’t consider return types when validating uniqueness of a method. That means you can’t have two methods with same name and passing parameters with different return type.

Java allows both method and constructor overloading. Let’s see this with an example.

Code:

package com.interview.question.java;

public class OverloadingDemo {

/**

* This class demonstrates overloading in java

* @author http://interviewquestionjava.blogspot.com

**/

private int a;

/* constructor overloading */

public OverloadingDemo(){

}

public OverloadingDemo(int a){

this.a = a;

}

/* method overloading */

public int add(int num){

a +=num;

return a;

}

public int add(String str){

a+= Integer.valueOf(str);

return a;

}

public int add(int num1, int num2){

a += num1;

a += num2;

return a;

}

/* test overloading */

public static void main(String[] args) {

OverloadingDemo objOverloadingDemo1 = new OverloadingDemo();

OverloadingDemo objOverloadingDemo2 = new OverloadingDemo(5);

System.out.println(objOverloadingDemo1.add(5));

System.out.println(objOverloadingDemo1.add("3"));

System.out.println(objOverloadingDemo1.add(3, 5));

System.out.println("-----");

System.out.println(objOverloadingDemo2.add(5));

System.out.println(objOverloadingDemo2.add("3"));

System.out.println(objOverloadingDemo2.add(3, 5));

}

Output:

-----

Here, in this class OverloadingDemo we defined two constructors with different signatures, and three methods with same name but different number and/or types of passing parameters.

Overriding:

Overriding is the technique of inheriting a class and redefining the behaviors of the super class. That means, when you define a method in subclass with the same signature (name, plus the number and the type of its parameters) and return type as in the superclass, then you are overriding the method of the superclass in your subclass, and the technique is known as method overriding.

In method overriding, method name, method input parameters and return types in subclass should be same in superclass. It can only modify the behaviors. It can return a subtype of the original return type defined in superclass, and this technique is known as covariant return type [Java 1.5 or above support this]. For example, suppose the return type in superclass is java.util.Map, you can change it to java.util.HashMap in subclass, as HashMap is a subtype of Map.

You can also use @Override annotation [which is available in Java 1.5 or above] to tell the compiler that you are trying to override a method in the superclass. And, fof any reason, if the compile is unable to detect that method, it will generate an error.

In method overriding in java, you can level up the access level but you can’t level it down. That means, if a method is declared as protected in superclass, it can be set as public is subclass but not as private.

If a method is declared as final, it can’t be overridden.

Now let’s see with an example.

Code:

Super Class :

package com.interview.question.java;

import java.util.HashMap;

import java.util.Map;

public class SuperClass {

/**

* This is a sample class

* @author http://interviewquestionjava.blogspot.com

**/

/* the return type of this method is Map and in subclass it will be changed to HashMap */

public Map methodForcovariant(){

Map map = new HashMap();

return map;

}

/* sample method which willbe overridden in subclass */

public void sampleMethod(){

System.out.println("SuperClass.sampleMethod()");

}

/* the specifier of this method willbe changed to public from protected in its subclass */

protected void protectedMethod(){

System.out.println("SuperClass.protectedMethod()");

}

/* this method can't be overridden as it's declare as final */

public final void finalMethod(){

System.out.println("SuperClass.finalMethod()");

}

Sub Class:

package com.interview.question.java;

import java.util.HashMap;

import java.util.Map;

public class OverridingDemo extends SuperClass{

/**

* This class demonstrates overriding by extending SuperClass

* @author http://interviewquestionjava.blogspot.com

**/

/* Overriding with covariant return type :

* the return type of this method is modified to its subtype which is allowed in method overriding */

@Override

public HashMap methodForcovariant(){

HashMap hmp = new HashMap();

return hmp;

}

/* Overriding:

* overriding the method SuperClass.sampleMethod() */

@Override

public void sampleMethod(){

System.out.println("OverridingDemo.sampleMethod()");

}

/* Overriding access specifier:

* the specifier of this method is changed to public from protected */

@Override

public void protectedMethod(){

System.out.println("OverridingDemo.protectedMethod()");

}

public static void main(String[] args) {

SuperClass objSuperClass = new SuperClass();

SuperClass objOverridingDemo = new OverridingDemo();

objSuperClass.sampleMethod();

objOverridingDemo.sampleMethod();

}

Output:

SuperClass.sampleMethod()

OverridingDemo.sampleMethod()

Here, we have used 4 methods:

methodForcovariant() – it shows the change of return type to its subtype during method overriding.

sampleMethod() – it shows method overriding in normal way.

protectedMethod() – it shows method overriding by leveling up access specifiers.

finalMethod() – it shows we can’t override methods declared as final.

JAVA: Deserializing an Object from File

noreply@blogger.com (Anijit Sarkar) — Tue, 13 Aug 2013 20:58:00 +0000

To deserialize an object from file, first get the serialized data from the file using FileInputStream. In case if you want to know how to serialize an object to file please check this article serialize an object to a file. Pass the FileInputStream object through ObjectInputStream. Now, get the object from ObjectInputStream using the API readObject().

Example:

Suppose we have a file named sampleClass.ser which contains the data of a serialized object of class SampleClass. Please check this post to create this file. Where SampleClass is a normal pojo class with 4 variables, among which 1 is declared as transient, that means, protected from serialization.

Class SampleClass :

package com.interview.question.java;

public class SampleClass implements java.io.Serializable{

/**

* Sample serialized class.

* @author http://interviewquestionjava.blogspot.com

**/

private static final long serialVersionUID = 1L;

private String strName;

private String strAddress;

private String strUsername;

/**

* we declared the variable strPassword as transient.

* So, it will be shield from serialization.

**/

private transient String strPassword;

public String getStrName() {

return strName;

}

public void setStrName(String strName) {

this.strName = strName;

}

public String getStrAddress() {

return strAddress;

}

public void setStrAddress(String strAddress) {

this.strAddress = strAddress;

}

public String getStrUsername() {

return strUsername;

}

public void setStrUsername(String strUsername) {

this.strUsername = strUsername;

}

public String getStrPassword() {

return strPassword;

}

public void setStrPassword(String strPassword) {

this.strPassword = strPassword;

}

Now, during serialization of the object of this SampleClass, we set the following values.

objSampleClass.setStrName("Ashoka Maurya");

objSampleClass.setStrAddress("Magadha");

objSampleClass.setStrUsername("Chakravartin");

objSampleClass.setStrPassword("Ashokavadana");

Now, we execute the DeserializeFileToObject class, to deserialize the object of SampleClass.

Class DeserializeFileToObject :

package com.interview.question.java;

import java.io.FileInputStream;

import java.io.ObjectInputStream;

public class DeserializeFileToObject {

/**

* This class deserializes data from a file

* sampleClass.ser to an Object of SampleClass

* @author http://interviewquestionjava.blogspot.com

**/

public static void main(String[] args) {

SampleClass objSampleClass = null;

try

{

FileInputStream objFileInputStream = new FileInputStream("src/com/interview/question/java/sampleClass.ser");

ObjectInputStream objInputStream = new ObjectInputStream(objFileInputStream);

objSampleClass = (SampleClass)objInputStream.readObject();

objInputStream.close();

objFileInputStream.close();

System.out.println("======================= Deserialized Data =======================");

System.out.println("strName : "+objSampleClass.getStrName());

System.out.println("strAddress : "+objSampleClass.getStrAddress());

System.out.println("strUsername : "+objSampleClass.getStrUsername());

System.out.println("strPassword : "+objSampleClass.getStrPassword());

System.out.println("=================================================================");

}

catch (Exception e)

{

e.printStackTrace();

}

Output :

======================= Deserialized Data =======================

strName : Ashoka Maurya

strAddress : Magadha

strUsername : Chakravartin

strPassword : null

=================================================================

Here, we can see, we get all the data from the deserialized object except strPassword, as it is decleared as transient.

JAVA: Keyword: abstract

noreply@blogger.com (Anijit Sarkar) — Sun, 11 Aug 2013 11:01:00 +0000

abstract:

This is used to define a class or a method as an abstract operation. When a method is declared as abstract, that means, the method where it is declared (within the class) have no body of the method rather the method can be overridden, through inheritance and define it's body.
When a class contains any abstract method, it must be declared as abstract.
An abstract class cannot be final.
An abstract method cannot be final, static nor native.

Code:

package com.interview.question.java;

abstract class SampleAbstractClass {

/**

* Sample abstract class.

* @author http://interviewquestionjava.blogspot.com

// Sample abstract method.

public abstract void sampleabstractmethod() ;

public void sampleNormalMethod(){

System.out.println("SampleAbstractClass.sampleNormalMethod()");

}

public class TestAbstractClass{

/**

* Sample class to call SampleAbstractClass.

* @author http://interviewquestionjava.blogspot.com

public static void main(String[] args) {

SampleAbstractClass objSampleAbstractClass = newSampleAbstractClass() {

@Override

public void sampleabstractmethod() {

System.out

.println("TestAbstractClass.main(...).new SampleAbstractClass() {...}.sampleabstractmethod()");

}

};

objSampleAbstractClass.sampleabstractmethod();

}

Output:

TestAbstractClass.main(...).new SampleAbstractClass() {...}.sampleabstractmethod()

SQL: OR Command

noreply@blogger.com (Anijit Sarkar) — Sun, 17 Mar 2013 16:58:00 +0000

In SQL, we have seen the use of AND command, to set multiple condition when performing a database transaction. But when we use AND, that means it's a mandatory condition. The transaction will provide output, only when all the conditions will be satisfied. But, what about an optional condition? Do SQL have any provision for that? The Answer is yes. SQL Do have command named OR to set optional condition.

Syntax: SELECT [column_name] FROM [table_name] WHERE [condition_1] OR [condition_2];

Here, output will come if [condition_1] OR [condition_2] OR both satisfied. That means, it is SELECT [column_name] FROM [table_name] WHERE [condition_1] OR [condition_2] OR both applied.

Example:

Again, we will use the same table, to see the usage of OR command.
Table Name:
Employee Details ( employee_details)
Column Names:
Employee ID ( emp_id),
Employee Name (emp_name),
Employee Address (emp_address) and
Employee Role: (emp_role).

Table: employee_details

Now, using OR command, we will SELECT those tuple, WHERE emp_role is 'Developer' or 'Business Analyst'.
So, the query will be :

SELECT * FROM employee_details WHERE emp_role = 'Developer' OR emp_role = 'Business Analyst';

Result:

SQL: AND Command

noreply@blogger.com (Anijit Sarkar) — Thu, 28 Feb 2013 19:01:00 +0000

In SQL, we have, seen that, we can add conditions by using WHERE command, during any SELECT, UPDATE or DELETE operation. Now, what about multiple conditions? For that, SQL provides to add multiple condition by using AND command. it can be used as many times as you want.

Syntax: SELECT [column_name] FROM [table_name] WHERE [condition_1] AND [condition_2];

[Note: AND means mandatory condition, that means, the operation has to always fulfill the criteria provied under AND block. ]

Example:

Again, use the same table, we will see the usage of AND command.
Employee Details ( employee_details), which contains
Employee ID ( emp_id),
Employee Name (emp_name),
Employee Address (emp_address) and
Employee Role: (emp_role).

Table: employee_details

Now, using AND command, we will SELECT those tuple, WHERE emp_role is 'Developer' and emp_address is 'Park Street, Kolkata'.
So, the query will be :

SELECT * FROM employee_details WHERE emp_role = 'Developer' AND emp_address = 'Park Street, Kolkata';

Result:

In this way, we can use multiple conditions on an RDBMS operation.

SQL: WHERE Command

noreply@blogger.com (Anijit Sarkar) — Fri, 22 Feb 2013 19:10:00 +0000

In SQL,when ever you want to SELECT some data, or UPDATE or DELETE some information from a Table, you needs to provide some condition, on basis of which operation will be performed. It's not necessary to SELECT, UPDATE or DELETE all data from a table or view. So, condition is necessary to filter the data when performing an operation on database. The basic structure of of WHERE conditions is :

Syntax: SELECT [column_name] FROM [table_name] WHERE [condition]

Example:

Again, we will see the same table
Employee Details ( employee_details), which contains
Employee ID ( emp_id),
Employee Name (emp_name),
Employee Address (emp_address) and
Employee Role: (emp_role).

Table: employee_details

Now, from this table, if a situation ariser, where we have to just select the information of the developers, the we have to set some condition on our SELECT query, so that we can get the details of the employees with 'emp_role' 'Developer' . Then the Query will be

SELECT * FROM employee_details WHERE emp_role = 'Developer';

Result:

In this way we can filter our data output.

SQL: SELECT Command

noreply@blogger.com (Anijit Sarkar) — Sun, 17 Feb 2013 12:01:00 +0000

SELECT command is use in SQL to "SELECT [some info] FROM [a location]". Now, this is the basic structure of the SELECT query, where SELECT and FROM are 2 commands of SQL. Here, [some info] part will be the column names separated by comma (,) sign and [a location] part will be the name of the Table or View. So, the syntax will be :

For Single Column :
Syntax : SELECT [Column_name] FROM [Table_Name];

For Multiple Columns :
Syntax : SELECT [Column1_name, Column2_name, Column3_name] FROM [Table_Name];

Now, what if you want to select all the columns of a table or a view. Do you have to write all the column name for that. No necessarily, you can user the star (*) sign in [Column_name] area. Then the syntax will be:

For All Columns :
Syntax : SELECT * FROM [Table_Name];

Example:
Suppose there is a table to keep
Employee Details (Table Name: employee_details), which contains
Employee ID(Column Name: emp_id),
Employee Name(Column Name: emp_name),
Employee Address:(Column Name: emp_address) and
Employee Role: (Column Name: emp_role).

Table: employee_details

Now, to select emp_id and emp_name from the table, the query will be,

SELECT emp_id, emp_name FROM employee_details;

Result:

Again, if you wants to select all the colunms' record, then the query will be,

SELECT * FROM employee_details;

Result:

JAVA: Parse String to Double

noreply@blogger.com (Anijit Sarkar) — Thu, 14 Feb 2013 20:59:00 +0000

Paser String to Double:

You can parse a double value in string format to double in 4 ways.

Double.valueof(String s) : This method returns a double object containing the value invoked in it in string format.
- It can trim white-space in start or end of the string argument, by using String.trim().
- It throws NumberFormatException if the string argument is not in proper form.

Double.parseDouble(String s) : This method also returns a double instance containing the invoked string value.
- It can also trim white space in start and end of the input value, using String.trim().
- It also throws NumberFormatException if the string argument is not in proper form.

new Double(String paramString) : You a also parse a string argument containing float value by invoking it on the constructor of the Class Double. its internally using the valueof(String s) method and returns a new Double instance containing the parsed double value. So it is also using
String.trim() and throws NumberFormatException.

Fourth one, the last one is the very important one, actually its been used by all the above 3 APIs. sun.misc.FloatingDecimal.readJavaFormatString(String paramString). Its the original method used to parse a String value to decimal value. This is the actual methods, which is trimming the white space of the string, using String.trim(). It returns value in FloatingDecimal instance, so you need to cast it to double by using doubleValue(), which is another method of Class FloatingDecimal.

Below is an example which explains the above discussion:

Code:

package com.interview.question.java;

public class PaserStringToDouble {

/**

* Sample class that shows how to parse a String to double.

* @author http://interviewquestionjava.blogspot.com

public static void main(String[] args) {

// TODO Auto-generated method stub

// set a decimal value in a string with

// white space on both end.

String strValue = " 12.329 ";

// parse the string to double using

//Double.valueof(String s)

double dblValue = Double.valueOf(strValue);

// parse the string to double using

// Double.parseDouble(String s)

double dblValue2 = Double.parseDouble(strValue);

// parse the string to double using

//Double(String paramString)

Double dblValue3 = new Double(strValue);

// parse the string to double using new

// FloatingDecimal.readJavaFormatString

//(String paramString)

Double dblValue4 = new Double(sun.misc.FloatingDecimal

.readJavaFormatString(strValue).doubleValue());

// printing the outputs

System.out.println("dblValue: " + dblValue +

"\ndblValue2: " + dblValue + "\ndblValue3: " +

dblValue3 + "\ndblValue4: " + dblValue4);

}

Output:

dblValue: 12.329

dblValue2: 12.329

dblValue3: 12.329

dblValue4: 12.329

SQL: What is SQL

noreply@blogger.com (Anijit Sarkar) — Wed, 13 Feb 2013 19:41:00 +0000

SQL (Structured Query Language) is a type of programming language, which uses to communicate with database. It’s also known as “sequel”. It provides some syntax which helps you to interact with a database. These syntax are very similar to normal English language, so it’s easy to remember and use. Now a day, all major RDBMS (Relational Database Management System) like MySQL, Oracle, postgres, MS Access and SQL Server uses SQL to maintain data.

SQL helps to store, manipulate, read and delete data from data base. It helps to performs the CRUD(Create, Read, Update & Delete) operations in RDBMS.

Create: It helps to create database, schema, table and view, along with there properties.

Read: It helps to select all information from single or multiple records from one or many table or view.

Update: It also helps us to manipulates existing data in a database.

Delete: It can also delete information or structure of database or table.

FRAMEWORK: MVC – Model View Controller

noreply@blogger.com (Anijit Sarkar) — Sun, 10 Feb 2013 16:59:00 +0000

Model-View-Controller (MVC) is a popular Software Architecture pattern widely used in web applications. It separates application data from UI (user interface) by a thin controlling layer, which actually helps as a bridge between UIs and model. In this pattern the whole application is separated in 3 layers,

1. Models are answerable for encapsulating application data, for view to present the data.

2. Views should only present this data, without involving any business logic.

3. Controllers are answerable for receiving requests from users and invoking back-end services for business process.

FRAMEWORK: WHAT IS FRAMEWORK? WHAT’S THE DIFFERENCE BETWEEN FRAMEWORK AND LIBRARY?

noreply@blogger.com (Anijit Sarkar) — Mon, 28 Jan 2013 09:50:00 +0000

Framework:

A framework is a basic conceptual and reusable structure which provides generic functionality, used to solve or address complex issues.

A software framework provides basic architecture, application programming interfaces (APIs) and tools for building application and provides required infrastructure.

Library v/s Framework:

Library: Library or code library is a collection of behavior written is a specific language, which can be used to execute some function. You use it the way you want.

Framework: It controls you. You can’t deviate from the framework rules and create application.

J2EE: SERVLET: doGet() vs. doPost()

noreply@blogger.com (Anijit Sarkar) — Sat, 07 Jul 2012 20:55:00 +0000

doGet():

protected void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, java.io.IOException – is a method of Class HttpServlet. It is called by the server (via the service method) to allow a servlet to handle a client's GET request.
In doGet(), the client’s request parameters are appended to the URL and sent along with header information.
doGet() is not a secured process because the request parameters are clearly visible in the URL.
Since request parameters are sent along with header information, so only a limited amount of data should be sent.

doPost():

Protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException – is a method of Class HttpServlet. It is called by the server (via the service method) to allow a servlet to handle a POST request.
In doPost(), the client’s request parameters are submitted via form.
As in doPost(), client’s request parameters are sent via form body, the parameters’ values are not visible in any where, so its safe and secure.
This method allows the client to send data of unlimited length to the Web server a single.

Anijit Sarkar

JAVA: What is the superclass of Exception

noreply@blogger.com (Anijit Sarkar) — Mon, 05 Mar 2012 11:58:00 +0000

java.lang.Throwable is the superclass of all the errors and exceptions in java.

JAVA: Why Errors are Unchecked?

noreply@blogger.com (Anijit Sarkar) — Mon, 05 Mar 2012 11:56:00 +0000

Error is unpredictable. It can occur at any point and recover is also quite impossible. So it is meaningless to declare such exception. That’s why, in java, error is unchecked.

J2EE: SERVLET: Class GenericServlet vs Class HttpServlet

noreply@blogger.com (Anijit Sarkar) — Wed, 29 Feb 2012 20:25:00 +0000

Class GenericServlet :

· It is an abstract class which defines a generic and protocol independent servlet. Here, protocol independent means, by default, it doesn’t contain inherent support for any particular type of protocol, but it can be extended to provide implementation of any protocol.

· Class GenericServlet implements Interface Servlet and Interface ServletConfig and it belongs to javax.servlet package.

· It offers simpler version of the servlet life cycle methods init() and destroy() and the methods of ServletConfig. That’s why, it makes writing a servlet easier.

· Here, the method service(ServletRequest req, ServletResponse res) is abstract, so the subclasses must override it. And this is also the reason why the GenericServlet is an abstract class.

Class HttpServlet :

· It is also an abstract class which defines HTTP prototype dependent servlet. That means we need to extend it to write a HTTP servlet for the use of the web.

· Class HttpServlet is a subclass of Class GenericServlet and it belongs to javax.servlet.http package.

· As it’s an abstract class, a subclass of it must override at least 1 method, generally one of these doGet(), doPost(), doPut(), doDelete(), init(), destroy(), getServletInfo().

· Class HttpServlet has two service() methods - one is public void service(ServletRequest req, ServletResponse res) which dispatches client request to protected void service(ServletRequest req, ServletResponse resp) which again dispaches the request to the doXXX methods (like doGet(), doPost(), etc.).

A servlet hierarchy

Anijit Sarkar

J2EE: SERVLET: What is Servlet Interface?

noreply@blogger.com (Anijit Sarkar) — Tue, 28 Feb 2012 21:28:00 +0000

Interface javax.servlet.Servlet is that interface which defines the ServletLife Cycle methods. So, all servlets must implement this interface, either directly or by extending a class which implements this interface. Instead of directly implementing the Servlet Interface, a servlet can also extend Class GenericServlet (which implements Servlet Interface), or can extend HttpServlet Class (which extends the GenericServlet class).

Methods of Interface Servlet:

init(ServletConfig config) : Called by the Web Container to initialize a servlet. Here, config is a ServletConfig object containing the servlet's configuration and initialization parameters

service(ServletRequest req, ServletResponse res) : Called by the Web Container to allow a servlet to respond to a request. Here, req is the ServletRequest object that contains the client's request and res is the ServletResponse object that contains the servlet's response.

destroy() : Called by the Web Container to clean up a servlet’s service.

getServletConfig() : Return a ServletConfig object, which contain the initialization parameter and startup configuration of a servlet.

getServletInfo() : Returns a string containing the details of a servlet, like author, version and copyright.

Anijit Sarkar

J2EE: SERVLET: What is Servlet?

noreply@blogger.com (Anijit Sarkar) — Mon, 27 Feb 2012 08:52:00 +0000

Servlet:

Servlet

 is a server-side (runs within a Web server), Java Programming Language Class which interacts with clients via request-response programming model (example, HTTP Request-Response model).

It can respond to any type of request, but, generally, it is used to extend the application hosted by Web Server by providing dynamic web content.

It has build-in threading capability and provides a secure environment for programming.

Java Servlet API

 provides javax.servlet and javax.servlet.http packages offer necessary classes and interfaces for writing servlets. All Servlets must implement Interface Servlet, which contains the servlet life-cycle methods.

To implement a generic service we can extend Class GenericServlet, which defines a generic, protocol-independent servlet. And to write an HTTP servlet for use on the Web, we can extend Class HttpServlet, which provides methods, such as doGet() and doPost(), for handling HTTP-specific services.

Anijit Sarkar

JAVA: Why can’t enum extends any other class?

noreply@blogger.com (Anijit Sarkar) — Fri, 24 Feb 2012 05:47:00 +0000

By default, all enums implicitly extend java.lang.Enum. And as we know, Java doesn't support multiple inheritance, an enum cannot extend any other class.

J2EE: SERVLET: SERVLET API

noreply@blogger.com (Anijit Sarkar) — Sun, 19 Feb 2012 21:38:00 +0000

Java Servlet API is that Application Program Interface (API), which defines and describes the contracts between servlets and servers. That means, it contains the set of programs and standard instructions to develop a proper access between a servlet and the server. Servlet API is a part of the official J2EE API. This API contains 2 packages with the extension javax. They are as follows.

· Package javax.servlet

· Package javax.servlet.http

Package javax.servlet:

Package javax.servlet deals with the contracts between a servlet class and the runtime environment offered for an instance of the class, within the servlet container.

It contains a set of classes and interfaces. Some important classes and interfaces like, Class GenericServlet which implements Interface Servlet. Apart from that, interfaces like Filter, RequestDispatcher, ServletRequest, ServletResponse, etc. and classes like ServletInputStream, ServletOutputStream, etc are also belong of this package. It also contains 2 exceptions, and they are ServletException and UnavailableException.

Package javax.servlet.http:

Package javax.servlet.http deals with the contracts between a servlet class, which is running under HTTP protocol and the runtime environment offered for an instance of the class, within the servlet container.

It also contains some important classes and interfaces. Some of them are, Interfaces like HttpSession, HttpServletResponse, HttpServletRequest, HttpSessionBindingListener, etc and classes like Cookie, HttpServlet (which implements Interface Servlet of javax.servlet package), etc.

Uses of Servlet API:

Management of Servlet life cycle.
It provides access to servlet context.
It also provides some utility classes.
And last but not least, it also provides classes to handle HTTP protocol.

Anijit Sarkar

J2EE: SERVLET: What happens to Session if the client intentionally turns off the cookies?

noreply@blogger.com (Anijit Sarkar) — Thu, 16 Feb 2012 22:22:00 +0000

If client intentionally turns off the cookies, that means, the client chooses not to join the session. In this situation, until the client turns on the cookies, getSession will return a different session on each request, and isNew will always return true.

Anijit Sarkar

J2EE: SERVLET: Session Tracking in Servlets using Interface HttpSession

noreply@blogger.com (Anijit Sarkar) — Thu, 16 Feb 2012 22:01:00 +0000

Session tracking in Servlets is done by using Interface HttpSession. It helps to identify a client throughout many page requests or visiting a website and to store details about that client.
Whenever a request arrives, it checks for the preexisting session object, to fetch details of the client from there, else, if its first request from a new client, its simple creates a session object for that client. These session objects are simple java objects.
HttpSession contains various methods to handle session object. HttpSession object lives in the server, and it automatically associated with the requester by internal mechanism like cookies or URL-rewriting.
Whenever an application invokes or removes an object from a session, the session checks whether the object implemented the interface HttpSessionBindingListener or not. If yes, the servlet informs the object that it has been bounded to the session, if not, notifies unbound from the session. This alert goes after the binding methods complete.

Example:

HttpSession session = request.getSession(true);

/* here, ‘request.getSession(true)’ - returns the current session associated with this request, or if the request does not have a session, creates one. */

ClientDetails client_details = (ClientDetails)session. getAttribute("client_details");

if(client_details != null) {

//that means, existing client, can do something with the client_details

} else {

//create new client_details and store into the session

}

Anijit Sarkar

INTERNET: HTTP vs. HTTPS

noreply@blogger.com (Anijit Sarkar) — Fri, 10 Feb 2012 19:40:00 +0000

HTTP stands for HyperText Transfer Protocol, whereas, HTTPS is HyperText Transfer Protocol Secure.
HTTP transmits everything as plan text, while HTTPS provides encrypted communication, so that only the recipient can decrypt and read the information. Basically, HTTPS is a combination of HTTP and SSL (Secure Sockets Layer). This SSL is that protocol which encrypts the data.
HTTP is fast and cheap, where HTTPS is slow and expensive.
As, HTTPS is safe it’s widely used during payment transactions or any sensitive transactions over the internet. On the other hand, HTTP is used most of the sites over the net, even this blogspot sites also use HTTP.
HTTP URLs starts with “http:// “ and use port 80 by default, while HTTPS URLs stars with “https:// “ and use port 443.
HTTP is unsafe from attacks like man-in-the-middle and eavesdropping, but HTTPS is secure from these sorts of attacks.