Wednesday, 25 June 2014

Basics

Why wait and notify is declared in Object class instead of Thread ?
Another tough java question, how can you answer this question if you are not designed Java programming language. anyway some common sense and deep knowledge of Java programming helps to answer such tough core java interview question. See this blog post to learn  Why wait and notify is declared in Object class and not in Thread.


Why multiple inheritance is not supported in Java ?
I found this core Java question really tough to answer because your answer may not satisfy Interviewer, in most cases Interviewer is looking for specific points and if you can bring them, they would be happy. Key to answer this kind of tough question in Java is to prepare topic well to accommodate any follow-ups. See Why multiple inheritance is not supported in Java for answer of this tough Java question.


Why Java does not support operator overloading ?
One more similar category of  tough Java question. C++ supports operator overloading than why not Java? this is the argument Interviewer will give to you and some time even say that + operator is overloaded in Java for String concatenation, Don't be fooled with such arguments. See  Why support operator overloading is not supported in Java for detailed answer of this tricky Java question.

Why String is immutable in Java?
My favorite Java interview question, this is tough, tricky but same time very useful as well. Some interviewer also ask this question as Why String is final in Java. look at this post for some points which make sense on Why String is final or immutable in Java

Why char array is preferred to store password than String in Java?
Another tricky Java question which is based on String and believe me there are only few Java programmer which can answer this question correctly. This is a real tough core Java interview question and again solid knowledge of String is required to answer this. see Why char array is better than String for storing password in Java to find out answer of this tough Java question.

How to create thread-safe singleton in Java using double checked locking?
This Java question is also asked as What is thread-safe singleton  and how to do you write it. Well Singleton created with double checked locking before Java 5 was broker and its possible to have multiple instance of Singleton if multiple thread try to create instance of Singleton at same time. from Java 5 its easy to create thread safe Singleton using Enum. but if interviewer persist with double checked locking then you have to write that code for them. remember to use volatile variable.  See 10 Java singleton interview question for more details on this topic.

Write Java program to create deadlock in Java and fix it ?
One of the classical but tough core Java interview question and you are likely to fail if you have not involved in coding of multi-threaded concurrent Java application. See  how to create and prevent deadlock in Java for complete answer of  this tough core Java interview question

What happens if your Serializable class contains a member which is not  serializable? How do you fix it?
Any attempt to Serialize that class will fail with NotSerializableException, but this can be easily solved by making that variable transient for static in Java. See Top 10 Serialization interview question answers in Java for more details.



Why wait and notify  called from synchronized method in Java?
Another tough core Java question for wait and notify. They are called from synchronized method or synchronized block because wait and modify need monitor on Object on which wait or notify get called. See  Why wait and notify require synchronized context for complete answer of this tough and tricky Java multi-threading question.

Can you override static method in Java? if I create same method in subclass is it compile time error?
No you can not override static method in Java but its not a compile time error to declare exactly same method in sub class, That is called method hiding in Java. See  Can you override static method in Java for complete answer of this tough Java interview question.









 1.What are the principle concepts of OOPS?

There are four principle concepts upon which object oriented design and programming rest. They are:

    Abstraction
    Polymorphism
    Inheritance
    Encapsulation
    (i.e. easily remembered as A-PIE).


2.What is Abstraction?

Abstraction refers to the act of representing essential features without including the background details or explanations.

3.What is Encapsulation?

Encapsulation is a technique used for hiding the properties and behaviors of an object and allowing outside access only as appropriate. It prevents other objects from directly altering or accessing the properties or methods of the encapsulated object.

4.What is the difference between abstraction and encapsulation?

    Abstraction focuses on the outside view of an object (i.e. the interface) Encapsulation (information hiding) prevents clients from seeing it’s inside view, where the behavior of the abstraction is implemented.
    Abstraction solves the problem in the design side while Encapsulation is the Implementation.
    Encapsulation is the deliverables of Abstraction. Encapsulation barely talks about grouping up your abstraction to suit the developer needs.


5.What is Inheritance?

    Inheritance is the process by which objects of one class acquire the properties of objects of another class.
    A class that is inherited is called a superclass.
    The class that does the inheriting is called a subclass.
    Inheritance is done by using the keyword extends.
    The two most common reasons to use inheritance are:
        To promote code reuse
        To use polymorphism


6.What is Polymorphism?

Polymorphism is briefly described as "one interface, many implementations." Polymorphism is a characteristic of being able to assign a different meaning or usage to something in different contexts - specifically, to allow an entity such as a variable, a function, or an object to have more than one form.

7.How does Java implement polymorphism?

(Inheritance, Overloading and Overriding are used to achieve Polymorphism in java).
Polymorphism manifests itself in Java in the form of multiple methods having the same name.

    In some cases, multiple methods have the same name, but different formal argument lists (overloaded methods).
    In other cases, multiple methods have the same name, same return type, and same formal argument list (overridden methods).


8.Explain the different forms of Polymorphism.

There are two types of polymorphism one is Compile time polymorphism and the other is run time polymorphism. Compile time polymorphism is method overloading. Runtime time polymorphism is done using inheritance and interface.
Note: From a practical programming viewpoint, polymorphism manifests itself in three distinct forms in Java:

    Method overloading
    Method overriding through inheritance
    Method overriding through the Java interface


9.What is runtime polymorphism or dynamic method dispatch?

In Java, runtime polymorphism or dynamic method dispatch is a process in which a call to an overridden method is resolved at runtime rather than at compile-time. In this process, an overridden method is called through the reference variable of a superclass. The determination of the method to be called is based on the object being referred to by the reference variable.

10.What is Dynamic Binding?

Binding refers to the linking of a procedure call to the code to be executed in response to the call. Dynamic binding (also known as late binding) means that the code associated with a given procedure call is not known until the time of the call at run-time. It is associated with polymorphism and inheritance.

11.What is method overloading?

Method Overloading means to have two or more methods with same name in the same class with different arguments. The benefit of method overloading is that it allows you to implement methods that support the same semantic operation but differ by argument number or type.
Note:

    Overloaded methods MUST change the argument list
    Overloaded methods CAN change the return type
    Overloaded methods CAN change the access modifier
    Overloaded methods CAN declare new or broader checked exceptions
    A method can be overloaded in the same class or in a subclass


12.What is method overriding?

Method overriding occurs when sub class declares a method that has the same type arguments as a method declared by one of its superclass. The key benefit of overriding is the ability to define behavior that’s specific to a particular subclass type.
Note:

    The overriding method cannot have a more restrictive access modifier than the method being overridden (Ex: You can’t override a method marked public and make it protected).
    You cannot override a method marked final
    You cannot override a method marked static


13.What are the differences between method overloading and method overriding?

      Overloaded Method     Overridden Method
Arguments    

Must change
   

Must not change

Return type
   

Can change
   

Can’t change except for covariant returns

Exceptions
   

Can change
   

Can reduce or eliminate. Must not throw new or broader checked exceptions

Access
   

Can change
   

Must not make more restrictive (can be less restrictive)

Invocation
   

Reference type determines which overloaded version is selected. Happens at compile time.
   

Object type determines which method is selected. Happens at runtime.

14.Can overloaded methods be override too?

Yes, derived classes still can override the overloaded methods. Polymorphism can still happen. Compiler will not binding the method calls since it is overloaded, because it might be overridden now or in the future.

15.Is it possible to override the main method?

NO, because main is a static method. A static method can't be overridden in Java.

16.How to invoke a superclass version of an Overridden method?

To invoke a superclass method that has been overridden in a subclass, you must either call the method directly through a superclass instance, or use the super prefix in the subclass itself. From the point of the view of the subclass, the super prefix provides an explicit reference to the superclass' implementation of the method.

     // From subclass
        super.overriddenMethod();


17.What is super?

super is a keyword which is used to access the method or member variables from the superclass. If a method hides one of the member variables in its superclass, the method can refer to the hidden variable through the use of the super keyword. In the same way, if a method overrides one of the methods in its superclass, the method can invoke the overridden method through the use of the super keyword.
Note:

    You can only go back one level.
    In the constructor, if you use super(), it must be the very first code, and you cannot access any this.xxx variables or methods to compute its parameters.


18.How do you prevent a method from being overridden?

To prevent a specific method from being overridden in a subclass, use the final modifier on the method declaration, which means "this is the final implementation of this method", the end of its inheritance hierarchy.

                           public final void exampleMethod() {
                          //  Method statements
                          }


19.What is an Interface?

An interface is a description of a set of methods that conforming implementing classes must have.
Note:

    You can’t mark an interface as final.
    Interface variables must be static.
    An Interface cannot extend anything but another interfaces.


20.Can we instantiate an interface?

You can’t instantiate an interface directly, but you can instantiate a class that implements an interface.

21.Can we create an object for an interface?

Yes, it is always necessary to create an object implementation for an interface. Interfaces cannot be instantiated in their own right, so you must write a class that implements the interface and fulfill all the methods defined in it.

22.Do interfaces have member variables?

Interfaces may have member variables, but these are implicitly public, static, and final- in other words, interfaces can declare only constants, not instance variables that are available to all implementations and may be used as key references for method arguments for example.

23.What modifiers are allowed for methods in an Interface?

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

24.What is a marker interface?

Marker interfaces are those which do not declare any required methods, but signify their compatibility with certain operations. The java.io.Serializable interface and Cloneable are typical marker interfaces. These do not contain any methods, but classes must implement this interface in order to be serialized and de-serialized.

25.What is an abstract class?

Abstract classes are classes that contain one or more abstract methods. An abstract method is a method that is declared, but contains no implementation.
Note:

    If even a single method is abstract, the whole class must be declared abstract.
    Abstract classes may not be instantiated, and require subclasses to provide implementations for the abstract methods.
    You can’t mark a class as both abstract and final.


26.Can we instantiate an abstract class?

An abstract class can never be instantiated. Its sole purpose is to be extended (subclassed).

27.What are the differences between Interface and Abstract class?

Abstract Class     Interfaces
An abstract class can provide complete, default code and/or just the details that have to be overridden.     An interface cannot provide any code at all,just the signature.
In case of abstract class, a class may extend only one abstract class.     A Class may implement several interfaces.
An abstract class can have non-abstract methods.     All methods of an Interface are abstract.
An abstract class can have instance variables.     An Interface cannot have instance variables.
An abstract class can have any visibility: public, private, protected.     An Interface visibility must be public (or) none.
If we add a new method to an abstract class then we have the option of providing default implementation and therefore all the existing code might work properly.     If we add a new method to an









 31.What is Constructor?

    A constructor is a special method whose task is to initialize the object of its class.
    It is special because its name is the same as the class name.
    They do not have return types, not even void and therefore they cannot return values.
    They cannot be inherited, though a derived class can call the base class constructor.
    Constructor is invoked whenever an object of its associated class is created.


32.How does the Java default constructor be provided?

If a class defined by the code does not have any constructor, compiler will automatically provide one no-parameter-constructor (default-constructor) for the class in the byte code. The access modifier (public/private/etc.) of the default constructor is the same as the class itself.

33.Can constructor be inherited?

No, constructor cannot be inherited, though a derived class can call the base class constructor.

34.What are the differences between Contructors and Methods?

      Constructors     Methods

Purpose
   

Create an instance of a class
   

Group Java statements

Modifiers
   

Cannot be abstract, final, native, static, or synchronized
   

Can be abstract, final, native, static, or synchronized

Return Type
   

No return type, not even void
   

void or a valid return type

Name
   

Same name as the class (first letter is capitalized by convention) -- usually a noun
   

Any name except the class. Method names begin with a lowercase letter by convention -- usually the name of an action

this
   

Refers to another constructor in the same class. If used, it must be the first line of the constructor
   

Refers to an instance of the owning class. Cannot be used by static methods.

super
    Calls the constructor of the parent class. If used, must be the first line of the constructor     Calls an overridden method in the parent class

Inheritance
    Constructors are not inherited     Methods are inherited

35.How are this() and super() used with constructors?

    Constructors use this to refer to another constructor in the same class with a different parameter list.
    Constructors use super to invoke the superclass's constructor. If a constructor uses super, it must use it in the first line; otherwise, the compiler will complain.


36.What are the differences between Class Methods and Instance Methods?

Class Methods     Instance Methods
Class methods are methods which are declared as static. The method can be called without creating an instance of the class     Instance methods on the other hand require an instance of the class to exist before they can be called, so an instance of a class needs to be created by using the new keyword.
Instance methods operate on specific instances of classes.
Class methods can only operate on class members and not on instance members as class methods are unaware of instance members.     Instance methods of the class can also not be called from within a class method unless they are being called on an instance of that class.
Class methods are methods which are declared as static. The method can be called without creating an  instance of the class.     Instance methods are not declared as static.

37.How are this() and super() used with constructors?

    Constructors use this to refer to another constructor in the same class with a different parameter list.
    Constructors use super to invoke the superclass's constructor. If a constructor uses super, it must use it in the first line; otherwise, the compiler will complain.


38.What are Access Specifiers?

One of the techniques in object-oriented programming is encapsulation. It concerns the hiding of data in a class and making this class available only through methods. Java allows you to control access to classes, methods, and fields via so-called access specifiers..

39.What are Access Specifiers available in Java?

Java offers four access specifiers, listed below in decreasing accessibility:

    Public- public classes, methods, and fields can be accessed from everywhere.
    Protected- protected methods and fields can only be accessed within the same class to which the methods and fields belong, within its subclasses, and within classes of the same package.
    Default(no specifier)- If you do not set access to specific level, then such a class, method, or field will be accessible from inside the same package to which the class, method, or field belongs, but not from outside this package.
    Private- private methods and fields can only be accessed within the same class to which the methods and fields belong. private methods and fields are not visible within subclasses and are not inherited by subclasses.

 Situation       public       protected       default       private
 Accessible to class
 from same package?      yes     yes     yes     no
 Accessible to class
 from different package?      yes      no, unless it is a subclass      no     no


40.What is final modifier?

The final modifier keyword makes that the programmer cannot change the value anymore. The actual meaning depends on whether it is applied to a class, a variable, or a method.

    final Classes- A final class cannot have subclasses.
    final Variables- A final variable cannot be changed once it is initialized.
    final Methods- A final method cannot be overridden by subclasses.


41.What are the uses of final method?

There are two reasons for marking a method as final:

    Disallowing subclasses to change the meaning of the method.
    Increasing efficiency by allowing the compiler to turn calls to the method into inline Java code.


42.What is static block?

Static block which exactly executed exactly once when the class is first loaded into JVM. Before going to the main method the static block will execute.

43.What are static variables?

Variables that have only one copy per class are known as static variables. They are not attached to a particular instance of a class but rather belong to a class as a whole. They are declared by using the static keyword as a modifier.

         static type  varIdentifier;

where, the name of the variable is varIdentifier and its data type is specified by type.
Note: Static variables that are not explicitly initialized in the code are automatically initialized with a default value. The default value depends on the data type of the variables.

44.What is the difference between static and non-static variables?

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

45.What are static methods?

Methods declared with the keyword static as modifier are called static methods or class methods. They are so called because they affect a class as a whole, not a particular instance of the class. Static methods are always invoked without reference to a particular instance of a class.
Note:The use of a static method suffers from the following restrictions:

    A static method can only call other static methods.
    A static method must only access static data.
    A static method cannot reference to the current object using keywords super or this.





 46.What is an Iterator ?

    The Iterator interface is used to step through the elements of a Collection.
    Iterators let you process each element of a Collection.
    Iterators are a generic way to go through all the elements of a Collection no matter how it is organized.
    Iterator is an Interface implemented a different way for every Collection.


47.How do you traverse through a collection using its Iterator?

To use an iterator to traverse through the contents of a collection, follow these steps:

    Obtain an iterator to the start of the collection by calling the collection’s iterator() method.
    Set up a loop that makes a call to hasNext(). Have the loop iterate as long as hasNext() returns true.
    Within the loop, obtain each element by calling next().


48.How do you remove elements during Iteration?

Iterator also has a method remove() when remove is called, the current element in the iteration is deleted.

49.What is the difference between Enumeration and Iterator?

Enumeration     Iterator

Enumeration doesn't have a remove() method
   

Iterator has a remove() method

Enumeration acts as Read-only interface, because it has the methods only to traverse and fetch the objects
   

Can be abstract, final, native, static, or synchronized

Note: So Enumeration is used whenever we want to make Collection objects as Read-only.

50.How is ListIterator?

ListIterator is just like Iterator, except it allows us to access the collection in either the forward or backward direction and lets us modify an element

51.What is the List interface?

    The List interface provides support for ordered collections of objects.
    Lists may contain duplicate elements.


52.What are the main implementations of the List interface ?

The main implementations of the List interface are as follows :

    ArrayList : Resizable-array implementation of the List interface. The best all-around implementation of the List interface.
    Vector : Synchronized resizable-array implementation of the List interface with additional "legacy methods."
    LinkedList : Doubly-linked list implementation of the List interface. May provide better performance than the ArrayList implementation if elements are frequently inserted or deleted within the list. Useful for queues and double-ended queues (deques).


53.What are the advantages of ArrayList over arrays ?

Some of the advantages ArrayList has over arrays are:

    It can grow dynamically
    It provides more powerful insertion and search mechanisms than arrays.


54.Difference between ArrayList and Vector ?

ArrayList     Vector
ArrayList is NOT synchronized by default.     Vector List is synchronized by default.
ArrayList can use only Iterator to access the elements.     Vector list can use Iterator and Enumeration Interface to access the elements.
The ArrayList increases its array size by 50 percent if it runs out of room.     A Vector defaults to doubling the size of its array if it runs out of room
ArrayList has no default size.     While vector has a default size of 10.

55.How to obtain Array from an ArrayList ?

Array can be obtained from an ArrayList using toArray() method on ArrayList.

    List arrayList = new ArrayList();
      arrayList.add(…

    Object  a[] = arrayList.toArray();


56.Why insertion and deletion in ArrayList is slow compared to LinkedList ?

    ArrayList internally uses and array to store the elements, when that array gets filled by inserting elements a new array of roughly 1.5 times the size of the original array is created and all the data of old array is copied to new array.
    During deletion, all elements present in the array after the deleted elements have to be moved one step back to fill the space created by deletion. In linked list data is stored in nodes that have reference to the previous node and the next node so adding element is simple as creating the node an updating the next pointer on the last node and the previous pointer on the new node. Deletion in linked list is fast because it involves only updating the next pointer in the node before the deleted node and updating the previous pointer in the node after the deleted node.


57.Why are Iterators returned by ArrayList called Fail Fast ?

Because, if list is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove or add methods, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

58.How do you decide when to use ArrayList and When to use LinkedList?

If you need to support random access, without inserting or removing elements from any place other than the end, then ArrayList offers the optimal collection. If, however, you need to frequently add and remove elements from the middle of the list and only access the list elements sequentially, then LinkedList offers the better implementation.


59.What is the Set interface ?

    The Set interface provides methods for accessing the elements of a finite mathematical set
    Sets do not allow duplicate elements
    Contains no methods other than those inherited from Collection
    It adds the restriction that duplicate elements are prohibited
    Two Set objects are equal if they contain the same elements

60.What are the main Implementations of the Set interface ?

The main implementations of the List interface are as follows:

    HashSet
    TreeSet
    LinkedHashSet
    EnumSet

61.What is a HashSet ?

    A HashSet is an unsorted, unordered Set.
    It uses the hashcode of the object being inserted (so the more efficient your hashcode() implementation the better access performance you’ll get).
    Use this class when you want a collection with no duplicates and you don’t care about order when you iterate through it.

62.What is a TreeSet ?

TreeSet is a Set implementation that keeps the elements in sorted order. The elements are sorted according to the natural order of elements or by the comparator provided at creation time.

63.What is an EnumSet ?

An EnumSet is a specialized set for use with enum types, all of the elements in the EnumSet type that is specified, explicitly or implicitly, when the set is created.

64.Difference between HashSet and TreeSet ?

HashSet     TreeSet
HashSet is under set interface i.e. it  does not guarantee for either sorted order or sequence order.     TreeSet is under set i.e. it provides elements in a sorted  order (acceding order).
We can add any type of elements to hash set.     We can add only similar types
of elements to tree set.


65.What is a Map ?

    A map is an object that stores associations between keys and values (key/value pairs).
    Given a key, you can find its value. Both keys  and  values are objects.
    The keys must be unique, but the values may be duplicated.
    Some maps can accept a null key and null values, others cannot.


66.What are the main Implementations of the Map interface ?

The main implementations of the List interface are as follows:

    HashMap
    HashTable
    TreeMap
    EnumMap


67.What is a TreeMap ?

TreeMap actually implements the SortedMap interface which extends the Map interface. In a TreeMap the data will be sorted in ascending order of keys according to the natural order for the key's class, or by the comparator provided at creation time. TreeMap is based on the Red-Black tree data structure.

68.How do you decide when to use HashMap and when to use TreeMap ?

For inserting, deleting, and locating elements in a Map, the HashMap offers the best alternative. If, however, you need to traverse the keys in a sorted order, then TreeMap is your better alternative. Depending upon the size of your collection, it may be faster to add elements to a HashMap, then convert the map to a TreeMap for sorted key traversal.

69.Difference between HashMap and Hashtable ?

HashMap     Hashtable
HashMap lets you have null values as well as one null key.     HashTable  does not allows null values as key and value.
The iterator in the HashMap is fail-safe (If you change the map while iterating, you’ll know).     The enumerator for the Hashtable is not fail-safe.
HashMap is unsynchronized.     Hashtable is synchronized.

Note: Only one NULL is allowed as a key in HashMap. HashMap does not allow multiple keys to be NULL. Nevertheless, it can have multiple NULL values.


70.How does a Hashtable internally maintain the key-value pairs?

TreeMap actually implements the SortedMap interface which extends the Map interface. In a TreeMap the data will be sorted in ascending order of keys according to the natural order for the key's class, or by the comparator provided at creation time. TreeMap is based on the Red-Black tree data structure.

71.What Are the different Collection Views That Maps Provide?

Maps Provide Three Collection Views.

    Key Set - allow a map's contents to be viewed as a set of keys.
    Values Collection - allow a map's contents to be viewed as a set of values.
    Entry Set - allow a map's contents to be viewed as a set of key-value mappings.


72.What is a KeySet View ?

KeySet is a set returned by the keySet() method of the Map Interface, It is a set that contains all the keys present in the Map.

73.What is a Values Collection View ?

Values Collection View is a collection returned by the values() method of the Map Interface, It contains all the objects present as values in the map.

74.What is an EntrySet View ?

Entry Set view is a set that is returned by the entrySet() method in the map and contains Objects of type Map. Entry each of which has both Key and Value.

75.How do you sort an ArrayList (or any list) of user-defined objects ?

Create an implementation of the java.lang.Comparable interface that knows how to order your objects and pass it to java.util.Collections.sort(List, Comparator).

76.What is the Comparable interface ?

The Comparable interface is used to sort collections and arrays of objects using the Collections.sort() and java.utils.Arrays.sort() methods respectively. The objects of the class implementing the Comparable interface can be ordered.

The Comparable interface in the generic form is written as follows:

    interface Comparable<T>

where T is the name of the type parameter.

All classes implementing the Comparable interface must implement the compareTo() method that has the return type as an integer. The signature of the compareTo() method is as follows:

      int i = object1.compareTo(object2)

    If object1 < object2: The value of i returned will be negative.
    If object1 > object2: The value of i returned will be positive.
    If object1 = object2: The value of i returned will be zero.


77.What are the differences between the Comparable and Comparator interfaces ?

Comparable     Comparato

It uses the compareTo() method.

int objectOne.compareTo(objectTwo).
    t uses the compare() method.

int compare(ObjOne, ObjTwo)
It is necessary to modify the class whose instance is going to be sorted.     A separate class can be created in order to sort the instances.
Only one sort sequence can be created.     Many sort sequences can be created.
It is frequently used by the API classes.     It used by third-party classes to sort instances.



 1. What is the most important feature of Java?
Java is a platform independent language.
2. What do you mean by platform independence?
Platform independence means that we can write and compile the java code in one
platform (eg Windows) and can execute the class in any other supported platform eg (Linux,Solaris,etc).
3. Are JVM's platform independent?
JVM's are not platform independent. JVM's are platform specific run time implementation provided by the vendor.
4. What is a JVM?
JVM is Java Virtual Machine which is a run time environment for the compiled java class
files.
5. What is the difference between a JDK and a JVM?
JDK is Java Development Kit which is for development purpose and it includes execution
environment also. But JVM is purely a run time environment and hence you will not be able to
compile your source files using a JVM.
6. What is a pointer and does Java support pointers?
Pointer is a reference handle to a memory location. Improper handling of pointers leads to
memory leaks and reliability issues hence Java doesn't support the usage of pointers.
7. What is the base class of all classes?
java.lang.Object
8. Does Java support multiple inheritance?
Java doesn't support multiple inheritance.
9. Is Java a pure object oriented language?
Java uses primitive data types and hence is not a pure object oriented language.
10. Are arrays primitive data types?
In Java, Arrays are objects.
11. What is difference between Path and Classpath?
Path and Classpath are operating system level environment variales. Path is used define
where the system can find the executables(.exe) files and classpath is used to specify the
location .class files.
12. What are local variables?
Local varaiables are those which are declared within a block of code like methods. Local
variables should be initialised before accessing them.
13. What are instance variables?
Instance variables are those which are defined at the class level. Instance variables need
not be initialized before using them as they are automatically initialized to their default values.
14. How to define a constant variable in Java?
The variable should be declared as static and final. So only one copy of the variable
exists for all instances of the class and the value can't be changed also.
static final int PI = 2.14; is an example for constant.
15. Should a main method be compulsorily declared in all java classes?
No not required. main method should be defined only if the source class is a java
application.
16. What is the return type of the main method?
Main method doesn't return anything hence declared void.
17. Why is the main method declared static?
main method is called by the JVM even before the instantiation of the class hence it is
declared as static.
18. What is the arguement of main method?
main method accepts an array of String object as arguement.
19. Can a main method be overloaded?
Yes. You can have any number of main methods with different method signature and
implementation in the class.
20. Can a main method be declared final?
Yes. Any inheriting class will not be able to have it's own default main method.
21. Does the order of public and static declaration matter in main method?
No it doesn't matter but void should always come before main().
22. Can a source file contain more than one Class declaration?
Yes a single source file can contain any number of Class declarations but only one of the
class can be declared as public.
23. What is a package?
Package is a collection of related classes and interfaces. package declaration should be
first statement in a java class.
24. Which package is imported by default?
java.lang package is imported by default even without a package declaration.
25. Can a class declared as private be accessed outside it's package?
Not possible.
26. Can a class be declared as protected?
A class can't be declared as protected. only methods can be declared as protected.
27. What is the access scope of a protected method?
A protected method can be accessed by the classes within the same package or by the
subclasses of the class in any package.
28. What is the purpose of declaring a variable as final?
A final variable's value can't be changed. final variables should be initialized before using
them.
29. What is the impact of declaring a method as final?
A method declared as final can't be overridden. A sub-class can't have the same method
signature with a different implementation.
30. I don't want my class to be inherited by any other class. What should i do?
You should declared your class as final. But you can't define your class as final, if it is an
abstract class. A class declared as final can't be extended by any other class.
31. Can you give few examples of final classes defined in Java API?
java.lang.String,java.lang.Math are final classes.
32. How is final different from finally and finalize?
final is a modifier which can be applied to a class or a method or a variable. final class
can't be inherited, final method can't be overridden and final variable can't be changed.
finally is an exception handling code section which gets executed whether an exception
is raised or not by the try block code segment.
finalize() is a method of Object class which will be executed by the JVM just before
garbage collecting object to give a final chance for resource releasing activity.
33. Can a class be declared as static?
No a class cannot be defined as static. Only a method,a variable or a block of code can
be declared as static.
34. When will you define a method as static?
When a method needs to be accessed even before the creation of the object of the class
then we should declare the method as static.
35. What are the restriction imposed on a static method or a static block of code?
A static method should not refer to instance variables without creating an instance and
cannot use "this" operator to refer the instance.
36. I want to print "Hello" even before main is executed. How will you acheive that?
Print the statement inside a static block of code. Static blocks get executed when the
class gets loaded into the memory and even before the creation of an object. Hence it will be
executed before the main method. And it will be executed only once.
37. What is the importance of static variable?
static variables are class level variables where all objects of the class refer to the same
variable. If one object changes the value then the change gets reflected in all the objects.
38. Can we declare a static variable inside a method?
Static varaibles are class level variables and they can't be declared inside a method. If
declared, the class will not compile.
39. What is an Abstract Class and what is it's purpose?
A Class which doesn't provide complete implementation is defined as an abstract class.
Abstract classes enforce abstraction.
40. Can a abstract class be declared final?
Not possible. An abstract class without being inherited is of no use and hence will result
in compile time error.
41. What is use of a abstract variable?
Variables can't be declared as abstract. only classes and methods can be declared as
abstract.
42. Can you create an object of an abstract class?
Not possible. Abstract classes can't be instantiated.
43. Can a abstract class be defined without any abstract methods?
Yes it's possible. This is basically to avoid instance creation of the class.
44. Class C implements Interface I containing method m1 and m2 declarations. Class
C has provided implementation for method m2. Can i create an object of Class C?
No not possible. Class C should provide implementation for all the methods in the
Interface I. Since Class C didn't provide implementation for m1 method, it has to be declared as
abstract. Abstract classes can't be instantiated.
45. Can a method inside a Interface be declared as final?
No not possible. Doing so will result in compilation error. public and abstract are the only
applicable modifiers for method declaration in an interface.
46. Can an Interface implement another Interface?
Intefaces doesn't provide implementation hence a interface cannot implement another
interface.
47. Can an Interface extend another Interface?
Yes an Interface can inherit another Interface, for that matter an Interface can extend
more than one Interface.
48. Can a Class extend more than one Class?
Not possible. A Class can extend only one class but can implement any number of
Interfaces.
49. Why is an Interface be able to extend more than one Interface but a Class can't
extend more than one Class?
Basically Java doesn't allow multiple inheritance, so a Class is restricted to extend only
one Class. But an Interface is a pure abstraction model and doesn't have inheritance hierarchy
like classes(do remember that the base class of all classes is Object). So an Interface is
allowed to extend more than one Interface.
50. Can an Interface be final?
Not possible. Doing so so will result in compilation error.
51. Can a class be defined inside an Interface?
Yes it's possible.
52. Can an Interface be defined inside a class?
Yes it's possible.
53. What is a Marker Interface?
An Interface which doesn't have any declaration inside but still enforces a mechanism.
54. Which OO Concept is achieved by using overloading and overriding?
Polymorphism.
55. If i only change the return type, does the method become overloaded?
No it doesn't. There should be a change in method arguements for a method to be
overloaded.
56. Why does Java not support operator overloading?
Operator overloading makes the code very difficult to read and maintain. To maintain
code simplicity, Java doesn't support operator overloading.
57. Can we define private and protected modifiers for variables in interfaces?
No
58. What is Externalizable?
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)
59. What modifiers are allowed for methods in an Interface?
Only public and abstract modifiers are allowed for methods in interfaces.
60. What is a local, member and a class variable?
Variables declared within a method are "local" variables. Variables declared within the
class i.e not within any methods are "member" variables (global variables). Variables declared
within the class i.e not within any methods and are defined as "static" are class variables
61. What is an abstract method?
An abstract method is a method whose implementation is deferred to a subclass.
62. What value does read() return when it has reached the end of a file?
The read() method returns -1 when it has reached the end of a file.
63. Can a Byte object be cast to a double value?
No, an object cannot be cast to a primitive value.
64. What is the difference between a static and a non-static inner class?
A non-static inner class may have object instances that are associated with instances of
the class's outer class. A static inner class does not have any object instances.
65. What is an object's lock and which object's have locks?
An object's lock is a mechanism that is used by multiple threads to obtain synchronized
access to the object. A thread may execute a synchronized method of an object only after it has
acquired the object's lock. All objects and classes have locks. A class's lock is acquired on the
class's Class object.
66. What is the % operator?
It is referred to as the modulo or remainder operator. It returns the remainder of dividing
the first operand by the second operand.
67. When can an object reference be cast to an interface reference?
An object reference be cast to an interface reference when the object implements the
referenced interface.
68. Which class is extended by all other classes?
The Object class is extended by all other classes.
69. Which non-Unicode letter characters may be used as the first character of an
identifier?
The non-Unicode letter characters $ and _ may appear as the first character of an
identifier
70. What restrictions are placed on method overloading?
Two methods may not have the same name and argument list but different return types.
71. What is casting?
There are two types of casting, casting between primitive numeric types and casting
between object references. Casting between numeric types is used to convert larger values,
such as double values, to smaller values, such as byte values. Casting between object
references is used to refer to an object by a compatible class, interface, or array type reference.
72. What is the return type of a program's main() method?
void.
73. If a variable is declared as private, where may the variable be accessed?
A private variable may only be accessed within the class in which it is declared.
74. What do you understand by private, protected and public?
These are accessibility modifiers. Private is the most restrictive, while public is the least
restrictive. There is no real difference between protected and the default type (also known as
package protected) within the context of the same package, however the protected keyword
allows visibility to a derived class in a different package.
75. What is Downcasting ?
Downcasting is the casting from a general to a more specific type, i.e. casting down the
hierarchy
76. What modifiers may be used with an inner class that is a member of an outer
class?
A (non-local) inner class may be declared as public, protected, private, static, final, or
abstract.
77. How many bits are used to represent Unicode, ASCII, UTF-16, and UTF-8
characters?
Unicode requires 16 bits and ASCII require 7 bits. Although the ASCII character set uses
only 7 bits, it is usually represented as 8 bits. UTF-8 represents characters using 8, 16, and 18
bit patterns. UTF-16 uses 16-bit and larger bit patterns.
78. What restrictions are placed on the location of a package statement within a
source code file?
A package statement must appear as the first line in a source code file (excluding blank
lines and comments).
79. What is a native method?
A native method is a method that is implemented in a language other than Java.
80. What are order of precedence and associativity, and how are they used?
Order of precedence determines the order in which operators are evaluated in
expressions. Associatity determines whether an expression is evaluated left-to-right or
right-to-left
81. Can an anonymous class be declared as implementing an interface and extending
a class?
An anonymous class may implement an interface or extend a superclass, but may not be
declared to do both.
82. What is the range of the char type?
The range of the char type is 0 to 2^16 - 1.
83. What is the range of the short type?
The range of the short type is -(2^15) to 2^15 - 1.
84. Why isn't there operator overloading?
Because C++ has proven by example that operator overloading makes code almost
impossible to maintain.
85. What does it mean that a method or field is "static"?
Static variables and methods are instantiated only once per class. In other words they
are class variables, not instance variables. If you change the value of a static variable in a
particular object, the value of that variable changes for all instances of that class. Static
methods can be referenced with the name of the class rather than the name of a particular
object of the class (though that works too). That's how library methods like System.out.println()
work. out is a static field in the java.lang.System class.
86. Is null a keyword?
The null value is not a keyword.
87. Which characters may be used as the second character of an identifier,but not as
the first character of an identifier?
The digits 0 through 9 may not be used as the first character of an identifier but they may
be used after the first character of an identifier.
88. Is the ternary operator written x : y ? z or x ? y : z ?
It is written x ? y : z.
89. How is rounding performed under integer division?
The fractional part of the result is truncated. This is known as rounding toward zero.
10 / 15
129 Core Java Interview Questions and Answers
Written by Shaukat
Sunday, 18 September 2011 07:58 -
90. If a class is declared without any access modifiers, where may the class be
accessed?
A class that is declared without any access modifiers is said to have package access.
This means that the class can only be accessed by other classes and interfaces that are
defined within the same package.
91. Does a class inherit the constructors of its superclass?
A class does not inherit constructors from any of its superclasses.
92. Name the eight primitive Java types.
The eight primitive types are byte, char, short, int, long, float, double, and boolean.
93. What restrictions are placed on the values of each case of a switch statement?
During compilation, the values of each case of a switch statement must evaluate to a
value that can be promoted to an int value.
94. What is the difference between a while statement and a do statement?
A while statement checks at the beginning of a loop to see whether the next loop
iteration should occur. A do statement checks at the end of a loop to see whether the next
iteration of a loop should occur. The do statement will always execute the body of a loop at least
once.
95. What modifiers can be used with a local inner class?
A local inner class may be final or abstract.
96. When does the compiler supply a default constructor for a class?
The compiler supplies a default constructor for a class if no other constructors are
provided.
97. If a method is declared as protected, where may the method be accessed?
A protected method may only be accessed by classes or interfaces of the same package
or by subclasses of the class in which it is declared.
98. What are the legal operands of the instanceof operator?
The left operand is an object reference or null value and the right operand is a class,
interface, or array type.
99. Are true and false keywords?
The values true and false are not keywords.
100. What happens when you add a double value to a String?
The result is a String object.
101. What is the diffrence between inner class and nested class?
When a class is defined within a scope od another class, then it becomes inner class. If
the access modifier of the inner class is static, then it becomes nested class.
102. Can an abstract class be final?
An abstract class may not be declared as final
103. What is numeric promotion?
Numeric promotion is the conversion of a smaller numeric type to a larger numeric type,
so that integer and floating-point operations may take place. In numerical promotion, byte, char,
and short values are converted to int values. The int values are also converted to long values, if
necessary. The long and float values are converted to double values, as required
104. What is the difference between a public and a non-public class?
A public class may be accessed outside of its package. A non-public class may not be
accessed outside of its package.
105. To what value is a variable of the boolean type automatically initialized?
The default value of the boolean type is false
106. What is the difference between the prefix and postfix forms of the ++ operator?
The prefix form performs the increment operation and returns the value of the increment
operation. The postfix form returns the current value all of the expression and then performs the
increment operation on that value.
107. What restrictions are placed on method overriding?
Overridden methods must have the same name, argument list, and return type. The
overriding method may not limit the access of the method it overrides. The overriding method
may not throw any exceptions that may not be thrown by the overridden method.
108. What is a Java package and how is it used?
A Java package is a naming context for classes and interfaces. A package is used to
create a separate name space for groups of classes and interfaces. Packages are also used to
organize related classes and interfaces into a single API unit and to control accessibility to
these classes and interfaces.
109. What modifiers may be used with a top-level class?
A top-level class may be public, abstract, or final.
110. What is the difference between an if statement and a switch statement?
The if statement is used to select among two alternatives. It uses a boolean expression
to decide which alternative should be executed. The switch statement is used to select among
multiple alternatives. It uses an int expression to determine which alternative should be
executed.
111. What are the practical benefits, if any, of importing a specific class rather than an
entire package (e.g. import java.net.* versus import java.net.Socket)?
It makes no difference in the generated class files since only the classes that are
actually used are referenced by the generated class file. There is another practical benefit to
importing single classes, and this arises when two (or more) packages have classes with the
same name. Take java.util.Timer and javax.swing.Timer, for example. If I import java.util.* and
javax.swing.* and then try to use "Timer", I get an error while compiling (the class name is
ambiguous between both packages). Let's say what you really wanted was the
javax.swing.Timer class, and the only classes you plan on using in java.util are Collection and
HashMap. In this case, some people will prefer to import java.util.Collection and import
java.util.HashMap instead of importing java.util.*. This will now allow them to use Timer,
Collection, HashMap, and other javax.swing classes without using fully qualified class names in.
112. Can a method be overloaded based on different return type but same argument
type ?
No, because the methods can be called without using their return type in which case
there is ambiquity for the compiler
113. What happens to a static var that is defined within a method of a class ?
Can't do it. You'll get a compilation error
114. How many static init can you have ?
As many as you want, but the static initializers and class variable initializers are
executed in textual order and may not refer to class variables declared in the class whose
declarations appear textually after the use, even though these class variables are in scope.
115. What is the difference between method overriding and overloading?
Overriding is a method with the same name and arguments as in a parent, whereas
overloading is the same method name but different arguments
116. What is constructor chaining and how is it achieved in Java ?
A child object constructor always first needs to construct its parent (which in turn calls
its parent constructor.). In Java it is done via an implicit call to the no-args constructor as the
first statement.
117. What is the difference between the Boolean & operator and the && operator?
If an expression involving the Boolean & operator is evaluated, both operands are
evaluated. Then the & operator is applied to the operand. When an expression involving the &&
operator is evaluated, the first operand is evaluated. If the first operand returns a value of true
then the second operand is evaluated. The && operator is then applied to the first and second
operands. If the first operand evaluates to false, the evaluation of the second operand is
skipped.
118. Which Java operator is right associative?
The = operator is right associative.
119. Can a double value be cast to a byte?
Yes, a double value can be cast to a byte.
120. What is the difference between a break statement and a continue statement?
A break statement results in the termination of the statement to which it applies (switch,
for, do, or while). A continue statement is used to end the current loop iteration and return
control to the loop statement.
121. Can a for statement loop indefinitely?
Yes, a for statement can loop indefinitely. For example, consider the following: for(;;) ;
122. To what value is a variable of the String type automatically initialized?
The default value of an String type is null.
What is the difference between a field variable and a local variable?
A field variable is a variable that is declared as a member of a class. A local variable is
a variable that is declared local to a method.
123. How are this() and super() used with constructors?
this() is used to invoke a constructor of the same class. super() is used to invoke a
superclass constructor.
124. What does it mean that a class or member is final?
A final class cannot be inherited. A final method cannot be overridden in a subclass. A
final field cannot be changed after it's initialized, and it must include an initializer statement
where it's declared.
125. What does it mean that a method or class is abstract?
An abstract class cannot be instantiated. Abstract methods may only be included in abstract classes. However, an abstract class is not required to have any abstract methods,
though most of them do. Each subclass of an abstract class must override the abstract methods
of its superclasses or it also should be declared abstract.
126. What is a transient variable?
transient variable is a variable that may not be serialized.
127. How does Java handle integer overflows and underflows?
It uses those low order bytes of the result that can fit into the size of the type allowed by
the operation.
128. What is the difference between the >> and >>> operators?
The >> operator carries the sign bit when shifting right. The >>> zero-fills bits that have
been shifted out.
129. Is sizeof a keyword?
The sizeof operator is not a keyword.


Spring Questions with Answers



What is Spring?
Spring is a framework for developing enterprise Java applications. The benefit of using Spring over other frameworks is that it’s open source. This means developers can build reusable code without any vendor lock-in. Another major advantage of Spring is the layered architecture that enables you to select only the components you need while offering a seamless J2EE application development framework.

List the advantages of the Spring framework.
Spring has the following advantages:
  • Layered architecture that allows you to use what you need while leaving what you don’t need.
  • Spring allows developers to focus on Plain Old Java Object (POJO) Programming. This allows for continuous testing and integration.
  • Being an open source, there is no vendor lock-in.
  • Dependency injection and inversion of control makes Java Database Connectivity (JDBC) simpler.
List some features of Spring.
Container:
Spring manages and contains the configuration and life cycle of application objects.
Lightweight:
When it comes to transparency and size, Spring is a lightweight application framework. The lightest version of the Spring framework only takes up 1MB. Additionally, the overhead in terms of processing is similarly minuscule.
MVC Framework:
Spring utilizes the model-view-controller (MVC) web application framework which is built on the core Spring functionality. This framework accommodates several view technologies such as JSP, Tiles, Velocity, POI, and iText. Additionally, it is highly configurable with the use of strategy interfaces. However, several other frameworks could be easily used in place of the Spring MVC Framework. You can learn more about other MVC frameworks from this
Inversion Of Control (IOC):
Spring achieves loose coupling through the use of Inversion of Control. Objects provide their dependencies rather than looking for or creating dependent objects.
Transaction Management:
A generic abstraction layer is supplied by the Spring framework for the purpose of transaction management. This allows developers to include pluggable transaction managers while making it very easy to separate transactions while avoiding low-level issues. This transaction support is not connected with the J2REE environment. Also, it can be utilized in containerless environments.
Aspect Oriented Programming (AOP):
By separating system services from application business logic, Spring supports aspect oriented programming. This also allows for cohesive deployment of applications.
JDBC Exception Handling:
The Java Database Connectivity (JDBC) abstraction layer of Spring provides a useful exception hierarchy. This makes error handling strategy much easier to develop. Additionally, Spring offers great integration services with JDO, iBATIS, and Hibernate.
What is Dependency Injection (AKA IOC)?
Dependency Injection or Inversion of Control (IOC), at the most basic level, allows you to describe how objects should be created rather than creating them directly. That is, you describe the services that are needed by different components using a configuration file rather than directly connecting these components and services in code. In the case of the Spring framework, these services and components are then connected by the IOC container.
For example, objects are given their dependencies when they are created by an external process that manages each object within a system. In other words, the dependencies are inserted into objects. This is contrary from the way dependencies are handled in other frameworks, which is why the term inversion of control was coined. This signifies an inversion of responsibility for creating references to dependencies within objects. Here’s a course that can teach you more about the basics of Spring 3.2 Framework.
List some different types of Dependency Injection (IOC)
The three (3) types of dependency injection, or IOC, are:
  • Setter Injection (used by Spring): JavaBeans properties are used to assign dependencies.
  • Interface Injection (used by Avalon): An interface is used for injection.
  • Constructor Injection (used by Spring, Pico container, and others): Constructor parameters are used to provide dependencies.
It’s important to note that Spring only supports Setter Injection and Constructor Injection.
1) What is spring framework? Why Java programmer should use Spring framework
Very common Spring interview question, Spring is a framework which helps Java programmer in development. Spring provides dependency Injection and IOC container, Spring MVC flow and several useful API for Java programmer.

2) What is default scope of bean in Spring framework ?

default scope of bean is Singleton, you can read this article which explains about all possible scope of a spring bean :

3) Does Spring singleton beans are thread-safe ?
No, Spring singleton beans are not thread-safe. Singleton doesn't mean bean would be thread-safe

4) What is dependency Injection?
Dependency Injection is one of the design pattern, which allows to inject dependency on Object, instead of object resolving dependency.

5) What is Inversion of Control concept, how does Spring support IOC?
6) What is Spring MVC ? Can you explain How one request is processed ?
7) How to you create controller in Spring ?

8) What is view Resolver pattern ? how it work in Spring MVC
View Resolver patter is a J2EE pattern which allows a web application to dynamically choose it's view technology e.g. HTML, JSP, Tapestry, JSF, XSLT or any other view technology. In this pattern, View resolver holds mapping of different views, controller return name of view, which is than passed to View Resolver for selecting appropriate view. Spring MVC framework supplies inbuilt view resolver for selecting views.


9) What is Spring Security ?
Spring security is a project under spring framework umbrella, which provides support for security requirements of enterprise Java projects. Spring Security formerly known as aegis security provides out of box support for creating login screen, remember me cookie support, securing URL, authentication provider to authenticate user from database, LDAP and in memory, concurrent active session management support and many more. In order to use Spring security in a Spring MVC based project, you need to include spring-security.jar and configure it in application-Context-security.xml file, you can name it whatever you want, but make sure to supply this to ContextLoaderListener, which is responsible for creating Spring context and initializing dispatcher servlet.

10) How do you control concurrent Session on Java web application using Spring Security.


11) What types of dependency injection is supported by Spring Framework? When do you use Setter and Constructor Injection, pros and cons?

12) What is difference between ApplicationContext and BeanFactory in Spring framework?

13) How do you call stored procedure by using Spring framework?

14) What does JdbcTemplate and JmsTemplate class offer in Spring?

15) Can we use more than one configuration file for our Spring project?

These were some of the Core Spring framework and MVC Interview questions from my collection, I have given short answers for most of these Spring interview question. I suggest to research more or read along those Spring question to prepare for follow up Spring interview questions.


Question 1: What is difference between a process and thread?
A process is a single execution of a program whereas a thread is a single execution sequence within a process. A process may contain multiple threads. A thread is sometimes referred to as a lightweight process. Threads in a JVM share the same heap space. Hence, threads can share same object. Threads have their own stack space, this is how one invocation of a method and its local variables are kept thread safe. Heap is not thread safe and hence must be synchronised for thread safety. 

Question 2: What are the different ways of creating Threads?
1) By implementing Runnable
2) By Extending Thread class
3) By using Executor Framework

Question 3: Which of the above method should be use?
Generally we should try to create threads by implementing Runnable as it will come in handy, when we need multiple inheritance.

Question 4: What are Thread states possible?
Thread can have the following states:
1) Runnable - Thread has started and is waiting for the Thread Scheduler to pick and execute.
2) Running - Thread is actively executing the code.
3) Waiting - Waiting for some external event like finish a file I/O to finish.
4) Sleeping - Thread are put to sleep for a certain period of time and will become runnable when it wakes from sleeping duration.
5) Blocked on I/O or Synchronised: Blocked by an external call to I/O or waiting to acquire lock.
6) Dead - Thread has finished executing code.

Question 5: What is difference between sleep and wait method?
Sleep method is used to stop the thread execution for a certain period of time, whereas wait method is used to make the thread wait for some external event or woke up by another thread by calling notify() or notifyAll().

Question 6: What is the difference between notify() and notifyAll()?
notify() and notifyAll() methods are used to pass the control to another thread that might be in the waiting state. When we call notify() it only means that the call will wake up the thread next in line. However, by calling notifyAll() we are actually passing the control to a larger number of threads which in turn may again compete to get control.

Question 7: What is difference between Thread.start() and Thread.run()?
Thread.start() actually does the job of calling Thread.run(). If we call the Thread.run() directly then it would be a simple method call from the main thread. It will not cause the thread to run independently.

Question 8: When is the InvalidMonitorStateException is thrown? why?
This exception is thrown when we try to call wait(), notify() or notifyAll() methods on an object in your program where you do not have the lock on the object. InvalidMonitorStateException extends RuntimeException and hence we do not need to catch it.

Question 9: What happens if the static method is defined as synchronized?
Executing such a method would mean that the thread has acquired a "Class" level lock, which means other threads cannot executed any other "static synchronized" method. This is different then the instance method synchronization in the way that two threads can execute the same synchronized instance method as long as they are executing it on the different instance of the object.

Q. What do you understand by the terms Dependency Inversion Principle (DIP), Dependency Injection (DI) and Inversion of Control (IoC) container ?

A.
  • Dependency Inversion Principle (DIP) is a design principle which is in some ways related to the Dependency Injection (DI) pattern. The idea of DIP is that higher layers of your application should not directly depend on lower layers. Dependency Inversion Principle does not imply Dependency Injection. This principle doesn’t say anything about how higher la yers know what lower layer to use. This could be done as shown below by coding to interface using a factory pattern or through Dependency Injection by using an IoC container like Spring framework, Pico container, Guice, or Apache HiveMind.




        The Dependency Inversion Principle (DIP) states that
  • High level modules should not depend upon low level modules. Both should depend upon abstractions.
  • Abstractions should not depend upon details. Details should depend upon abstractions.
When this principle is applied, the higher level classes will not be working directly with the lower level classes, but with an abstract layer. This gives us the flexibility at the cost of increased effort.Here are some code snippets for DIP.

Firstly define the abstraction layer.
?
1
2
3
4
5
<span class="IL_AD" id="IL_AD4">package</span> principle_dip2;

public interface AnimalHandler {
    public abstract void handle( );
}

?
1
2
3
4
5
package principle_dip2;

public interface AnimalHelper {
    public abstract void help( );
}

Now the implementation that depends on the abstraction as opposed to the implementation.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package principle_dip2;

public class CircusService {
     
    AnimalHandler handler;
     
    public void setHandler(AnimalHandler handler) {
        this.handler = handler;
    }

    public void showStarts( ) {
        //code omitted for brevity
        handler.handle( );
    }
}

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package principle_dip2;

public class TigerHandler implements AnimalHandler{
     
   AnimalHelper helper;
     
    public void setHelper(AnimalHelper helper) {
        this.helper = helper;
    }

    public void handle( ){
        //...
        helper.help( );
        //...
    }
}

?
1
2
3
4
5
6
7
8
package principle_dip2;

public class TigerHelper implements AnimalHelper{
     
    public void help( ){
        //......
    }
}

  • Dependency Injection (DI) is a pattern of injecting a class’s dependencies into it at runtime. This is achieved by defining the dependencies as interfaces, and then injecting in a concrete class implementing that interface to the constructor. This allows you to swap in different implementations without having to modify the main class. The Dependency Injection pattern also promotes high cohesion by promoting the  Single Responsibility Principle (SRP), since your dependencies are individual objects which perform discrete specialized tasks like data access (via DAOs) and business services (via Service and Delegate classes) .

  • The Inversion of Control Container (IoC) is a container that supports Dependency Injection. In this you use a central container  like Spring framework, Guice, or HiveMind, which defines what concrete classes should be used for what dependencies throughout your application. This brings in an added flexibility through looser coupling, and it makes it much easier to change what dependencies are used on the fly. The basic concept of the Inversion of Control pattern is that you do not create your objects but describe how they should be created. You don't directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (in the case of the Spring framework, the IOC container) is then responsible for hooking it all up. Applying IoC, objects are given their dependencies at creation time by some external entity that coordinates each object in the system. That is, dependencies are injected into objects. So, IoC means an inversion of responsibility with regard to how an object obtains references to collaborating objects.


The real power of DI and IoC is realized  in its ability to replace the compile time binding of the relationships between classes with  binding those relationships at runtime. For example, in Seam framework, you can have a real and mock implementation of an interface, and at runtime decide which one to use based on a property, presence of another file, or some precedence values. This is incredibly useful if you think you may need to modify the way your application behaves in different scenarios. Another real benefit of DI and IoC is that it makes your code easier to unit test. There are other benefits like promoting looser coupling without any proliferation of factory and singleton design patterns, follows a consistent approach for lesser experienced developers to follow, etc. These benefits can come in at the cost of the added complexity to your application and has to be carefully manged by using them only at the right places where the real benefits are realized, and not just using them because many others are using them.




Note: The CDI (Contexts and Dependency Injection)  is an attempt at describing a true standard on Dependency Injection. CDI is a part of the Java EE 6 stack, meaning an application running in a Java EE 6 compatible container can leverage CDI out-of-the-box. Weld is the reference implementation of CDI.


 Q. In your experience, why would you use Spring framework?
A.
  • Spring has a layered architecture with over 20 modules to choose from. This means, use what you need and leave what you don't need now. Spring simplifies JEE through POJO programming. There is no behind the scene magic in Spring as in JEE programming. POJO programming enables continuous integration and testability.

  • Spring framework's core functionality is dependency injection (DI). Dependency injection promotes easy unit testing and more maintainable and flexible code. DI code is much easier to test. The functionality expressed by the object can be tested in a black box by building 'mock' objects implementing the interfaces expected by your application logic. DI code is much easier to reuse as the 'depended' functionality is extrapolated into well defined interfaces, allowing separate objects whose configuration is handled by a suitable application platform to be plugged into other objects at will. DI code is more flexible. It is innately loosely coupled code to an extreme. This allows the programmer to pick and choose how objects are connected based exclusively on their required interfaces on one end and their expressed interfaces on the other.
  • Spring supports Aspect Oriented Programming (AOP), which enables cohesive development by separating application business logic from system services. Supporting functionalities like auditing, gathering performance and memory metrics, etc can be enabled through AOP.
  • Spring also provides a lot of templates which act as base classes to make using the JEE standard technologies a breeze to work with. For example, the JdbcTemplate works well with JDBC, the JpaTemplate does good things with JPA, JmsTemplate makes JMS pretty straightforward. The RestTemplate is simply awesome in it's simplicity. Simplicity means more readable and maintainable code.
  • When writing software these days, it is important to try and decouple as much middleware code from your business logic as possible. The best approach when using remoting is to use Spring Remoting which can then use any messaging or remoting technology under the covers. Apache Camel is a powerful open source integration framework based on known Enterprise Integration Patterns with powerful Bean Integration. Apache Camel is designed to work nicely with the Spring Framework in a number of ways.
  • It also provides declarative transactions, job scheduling, authentication, a fully-fledged MVC web framework, and integration to other frameworks like Hibernate, iBatis, JasperReports, JSF, Struts, Tapestry, Seam, Quartz job scheduler, etc.
  • Spring beans can be shared between different JVMs using Terracotta. This allows you to take existing beans and spread them across a cluster, turn Spring application context events into distributed events, export clustered beans via Spring JMX, and make your Spring applications highly available and clustered. Spring also integrate well with other clustering solutions like Oracle's Coherance.
  • Spring favors unchecked exceptions and eliminates unsightly try, catch, and finally (and some times try/catch within finally itself) blocks. The Spring templates like JpaTemplate takes care of closing or releasing a database connection. This prevents any potential resource leaks and promotes more readable code.
  • It prevents the proliferation of factory and singleton pattern classes that need to be created to promote loose coupling if not for using a DI framework like Spring or Guice.
Q. In your experience, what do you don't like about Spring? Are there any pitfalls?
A.
  • Spring has become very huge and bulky. So, don't over do it by using all its features because of the hype that Spring is good. Look at what parts of Spring really provides some benefits for your project and use those parts. In most cases, it is much better to use proven frameworks like Spring than create your own equivalent solution from a maintenance and applying the best practices perspective. For example, all spring templates (jdbc, rest, jpa etc.) have the following advantages -- perform common setup routines for you, let you skip the boilerplate and concentrate on the logic you want.
  • Spring MVC is probably not the best Web framework. There are other alternatives like Struts 2, Wicket, and JSF.  Having said this, Spring integrates well with the other Web frameworks like Struts, JSF, etc.
  • The XML files can get bloated. This can be minimized by carefully considering other options like annotations, JavaConfig, and having separate XML configuration files.

Q. What are the different types of IoC (dependency injection) ?
A. There are three types of dependency injection:
  • Constructor Injection (e.g. Spring): Dependencies are provided as constructor parameters.
  • Setter Injection (e.g. Spring): Dependencies are assigned through JavaBeans properties (ex: setter methods).
  • Interface Injection (e.g. Avalon): Injection is done through an interface.

Q. Have you used any other Dependency Injection (DI) frameworks?
A. Yes, Guice, Hivemind, and Seam.


Spring interview questions and answers are below

Questions : 1
What is IOC (or Dependency Injection)?
Answers : 1
The basic concept of the Inversion of Control pattern (also known as dependency injection) is that you do not create your objects but describe how they should be created. You don't directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (in the case of the Spring framework, the IOC container) is then responsible for hooking it all up.

i.e., Applying IoC, objects are given their dependencies at creation time by some external entity that coordinates each object in the system. That is, dependencies are injected into objects. So, IoC means an inversion of responsibility with regard to how an object obtains references to collaborating objects. .


Questions : 2
What are the different types of IOC (dependency injection) ?
Answers : 2
There are three types of dependency injection:
==>Constructor Injection (e.g. Pico container, Spring etc): Dependencies are provided as constructor parameters.
==>Setter Injection (e.g. Spring): Dependencies are assigned through JavaBeans properties (ex: setter methods).
==>Interface Injection (e.g. Avalon): Injection is done through an interface. Note: Spring supports only Constructor and Setter Injection


Questions : 3
What are the benefits of IOC (Dependency Injection)?
Answers : 3
Benefits of IOC (Dependency Injection) are as follows: ·

Minimizes the amount of code in your application. With IOC containers you do not care about how services are created and how you get references to the ones you need. You can also easily add additional services by adding a new constructor or a setter method with little or no extra configuration.

· Make your application more testable by not requiring any singletons or JNDI lookup mechanisms in your unit test cases. IOC containers make unit testing and switching implementations very easy by manually allowing you to inject your own objects into the object under test.

· Loose coupling is promoted with minimal effort and least intrusive mechanism. The factory design pattern is more intrusive because components or services need to be requested explicitly whereas in IOC the dependency is injected into requesting piece of code. Also some containers promote the design to interfaces not to implementations design concept by encouraging managed objects to implement a well-defined service interface of your own.

· IOC containers support eager instantiation and lazy loading of services. Containers also provide support for instantiation of managed objects, cyclical dependencies, life cycles management, and dependency resolution between managed objects etc.


Questions : 4
What is Spring ?
Answers : 4
Spring is an open source framework created to address the complexity of enterprise application development. One of the chief advantages of the Spring framework is its layered architecture, which allows you to be selective about which of its components you use while also providing a cohesive framework for J2EE application development. .


Questions : 5
What are the advantages of Spring framework?
Answers : 5
The advantages of Spring are as follows:
Spring has layered architecture. Use what you need and leave you don't need now.
Spring Enables POJO Programming. There is no behind the scene magic here. POJO
programming enables continuous integration and testability.
Dependency Injection and Inversion of Control Simplifies JDBC
Open source and no vendor lock-in. .


Questions : 6
What are features of Spring ?
Answers : 6
Lightweight:
spring is lightweight when it comes to size and transparency. The basic version of spring framework is around 1MB. And the processing overhead is also very negligible.
Inversion of control (IOC):
Loose coupling is achieved in spring using the technique Inversion of Control. The objects give their dependencies instead of creating or looking for dependent objects.
Aspect oriented (AOP):
Spring supports Aspect oriented programming and enables cohesive development by separating application business logic from system services.
Container:
Spring contains and manages the life cycle and configuration of application objects.
MVC Framework:
Spring comes with MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. But other frameworks can be easily used instead of Spring MVC Framework.
Transaction Management:
Spring framework provides a generic abstraction layer for transaction management. This allowing the developer to add the pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Spring's transaction support is not tied to J2EE environments and it can be also used in container less environments.
JDBC Exception Handling:
The JDBC abstraction layer of the Spring offers a meaningful exception hierarchy, which simplifies the error handling strategy. Integration with Hibernate, JDO, and iBATIS: Spring provides best Integration services with Hibernate, JDO and iBATIS


Questions : 7
How many modules are there in Spring? What are they?
Answers : 7
Spring comprises of seven modules. They are..
The core container:
The core container provides the essential functionality of the Spring framework. A primary component of the core container is the BeanFactory, an implementation of the Factory pattern. The BeanFactory applies the Inversion of Control (IOC) pattern to separate an application's configuration and dependency specification from the actual application code.
Spring context:
The Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, e-mail, internalization, validation, and scheduling functionality.
Spring AOP:
The Spring AOP module integrates aspect-oriented programming functionality directly into the Spring framework, through its configuration management feature. As a result you can easily AOP-enable any object managed by the Spring framework. The Spring AOP module provides transaction management services for objects in any Spring-based application. With Spring AOP you can incorporate declarative transaction management into your applications without relying on EJB components.
Spring DAO:
The Spring JDBC DAO abstraction layer offers a meaningful exception hierarchy for managing the exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the amount of exception code you need to write, such as opening and closing connections. Spring DAO's JDBC-oriented exceptions comply to its generic DAO exception hierarchy.
Spring ORM:
The Spring framework plugs into several ORM frameworks to provide its Object Relational tool, including JDO, Hibernate, and iBatis SQL Maps. All of these comply to Spring's generic transaction and DAO exception hierarchies.
Spring Web module:
The Web context module builds on top of the application context module, providing contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.
Spring MVC framework:
The Model-View-Controller (MVC) framework is a full-featured MVC implementation for building Web applications. The MVC framework is highly configurable via strategy interfaces and accommodates numerous view technologies including JSP, Velocity, Tiles, iText, and POI.


Questions : 8
What are the types of Dependency Injection Spring supports?>
Answers : 8
Setter Injection:
Setter-based DI is realized by calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.
Constructor Injection:
Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator


Questions : 9
What is Bean Factory ?
Answers : 9
A BeanFactory is like a factory class that contains a collection of beans. The BeanFactory holds Bean Definitions of multiple beans within itself and then instantiates the bean whenever asked for by clients.
BeanFactory is able to create associations between collaborating objects as they are instantiated. This removes the burden of configuration from bean itself and the beans client. BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.


Questions : 10
What is Application Context?
Answers : 10
A bean factory is fine to simple applications, but to take advantage of the full power of the Spring framework, you may want to move up to Springs more advanced container, the application context. On the surface, an application context is same as a bean factory.Both load bean definitions, wire beans together, and dispense beans upon request. But it also provides:
A means for resolving text messages, including support for internationalization.
A generic way to load file resources.
Events to beans that are registered as listeners.


Questions : 11
What is the difference between Bean Factory and Application Context
Answers : 11
On the surface, an application context is same as a bean factory. But application context offers much more..

Application contexts provide a means for resolving text messages, including support for i18n of those messages.
Application contexts provide a generic way to load file resources, such as images.
Application contexts can publish events to beans that are registered as listeners.
Certain operations on the container or beans in the container, which have to be handled in a programmatic fashion with a bean factory, can be handled declaratively in an application context. ResourceLoader support: Spring’s Resource interface us a flexible generic abstraction for handling low-level

resources. An application context itself is a ResourceLoader, Hence provides an application with access to deployment-specific Resource instances.
MessageSource support: The application context implements MessageSource, an interface used to obtain localized messages, with the actual implementation being pluggable


Questions : 12
What do you mean by Bean wiring ?
Answers : 12
The act of creating associations between application components (beans) within the Spring container is reffered to as Bean wiring.


Questions : 13
What do you mean by Auto Wiring?
Answers : 13
The Spring container is able to autowire relationships between collaborating beans. This means that it is possible to automatically let Spring resolve collaborators (other beans) for your bean by inspecting the contents of the BeanFactory. The autowiring functionality has five modes. · no · byName · byType · constructor · autodirect


Questions : 14
What is DelegatingVariableResolver?
Answers : 14
Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard Java Server Faces managed beans mechanism which lets you use JSF and Spring together. This variable resolver is called as DelegatingVariableResolver


Questions : 15
How to integrate Java Server Faces (JSF) with Spring?
Answers : 15
? JSF and Spring do share some of the same features, most noticeably in the area of IOC services. By declaring JSF managed-beans in the faces-config.xml configuration file, you allow the FacesServlet to instantiate that bean at startup. Your JSF pages have access to these beans and all of their properties.We can integrate JSF and Spring in two ways:
DelegatingVariableResolver: Spring comes with a JSF variable resolver that lets you use JSF and Spring together.
< ?xml version="1.0" encoding="UTF-8 "? >
< ! DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >
< faces-config >
< application >
< variable-resolver >
org.springframework.web.jsf.DelegatingVariableResolver < / variable-resolver >
< / application >
< / faces-config >
The DelegatingVariableResolver will first delegate value lookups to the default resolver of the underlying JSF implementation, and then to Spring's 'business context' WebApplicationContext. This allows one to easily inject dependencies into one's JSF-managed beans. FacesContextUtils:custom VariableResolver works well when mapping one's properties to beans in faces-config.xml, but at times one may need to grab a bean explicitly. The FacesContextUtils class makes this easy. It is similar to WebApplicationContextUtils, except that it takes a FacesContext parameter rather than a ServletContext parameter. ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());


Questions : 16
What is Java Server Faces (JSF) - Spring integration mechanism?
Answers : 16
Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard JavaServer Faces managed beans mechanism. When asked to resolve a variable name, the following algorithm is performed:
Does a bean with the specified name already exist in some scope (request, session, application)? If so, return
Is there a standard JavaServer Faces managed bean definition for this variable name? If so, invoke it in the usual way, and return the bean that was created.
Is there configuration information for this variable name in the Spring WebApplicationContext for this application? If so, use it to create and configure an instance, and return that instance to the caller.
If there is no managed bean or Spring definition for this variable name, return null instead.
BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.
As a result of this algorithm, you can transparently use either JavaServer Faces or Spring facilities to create beans on demand. e.


Questions : 17
How to integrate your Struts application with Spring?
Answers : 17
To integrate your Struts application with Spring, we have two options:
Configure Spring to manage your Actions as beans, using the ContextLoaderPlugin, and set their dependencies in a Spring context file.
Subclass Spring's ActionSupport classes and grab your Spring-managed beans explicitly using agetWebApplicationContext()


Questions : 18
What are the ways to access Hibernate using Spring ?
Answers : 18
There are two approaches to Spring’s Hibernate integration:
Inversion of Control with a HibernateTemplate and Callback
Extending HibernateDaoSupport and Applying an AOP Interceptor nodes.


Questions : 19
What is AOP? and How the AOP used in Spring?
Answers : 19
Aspect-oriented programming, or AOP, is a programming technique that allowsprogrammers to modularize crosscutting concerns, or behavior that cuts across the typical divisions of responsibility, such as logging and transaction management. The core construct of AOP is the aspect, which encapsulates behaviors affecting multiple classes into reusable modules.

AOP is used in the Spring Framework: To provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management, which builds on the Spring Framework's transaction abstraction.To allow users to implement custom aspects, complementing their use of OOP with AOP.


Questions : 20
Explain about the Spring DAO support
Answers : 20
The Data Access Object (DAO) support in Spring is aimed at making it easy to work with data access technologies like JDBC, Hibernate or JDO in a consistent way. This allows one to switch between the persistence technologies fairly easily and it also allows one to code without worrying about catching exceptions that are specific to each technology.


Questions : 21
What is SQLExceptionTranslator ?
Answers : 21
SQLExceptionTranslator, is an interface to be implemented by classes that can translate between SQLExceptions and Spring's own data-access-strategy-agnostic org.springframework.dao.DataAccessException.