Explore topic-wise InterviewSolutions in .

A THREAD that has a lock won't be released even after it calls sleep(). DESPITE the thread sleeping for a SPECIFIED period of time, the lock will not be released.

The Java Garbage Collector (GC) typically removes unused objects when they are no longer required, but when they are STILL referenced, the unused objects cannot be removed. So this causes the MEMORY leak problem. Example - Consider a linked list like the structure below -

In the above image, there are unused objects that are not referenced. But then also Garbage collection will not free it. Because it is referencing some existing referenced OBJECT. So this can be the situation of memory leak.

Some common causes of Memory leaks are - 

• When there are Unbounded caches.
• Excessive page swapping is done by the operating system.
• Improper written CUSTOM data structures.
• Inserting into a collection object without first deleting it.
  etc.

Java Design PATTERNS are categorized into the following DIFFERENT types. And those are also further categorized as 

Structural patterns:

• Adapter
• Bridge
• FILTER
• Composite
• Decorator
• Facade
• Flyweight
• Proxy

Behavioral patterns:

• Interpreter
• Template method/ pattern
• Chain of responsibility
• Command pattern
• Iterator pattern
• Strategy pattern
• Visitor pattern

J2EE patterns:

• MVC Pattern
• Data Access Object pattern
• Front controller pattern
• Intercepting filter pattern
• Transfer object pattern

Creational patterns:

• Factory method/Template
• Abstract Factory
• Builder
• Prototype
• Singleton

A scope can be set by an annotation such as the @Scope annotation or the "scope" ATTRIBUTE in an XML configuration FILE. Spring Bean supports the FOLLOWING five SCOPES:

• Singleton
• Prototype
• Request
• Session
• Global-session

There is no boundation for using a particular dependency INJECTION. But the recommended approach is - 

Setters are mostly recommended for optional dependencies injection, and constructor arguments are recommended for mandatory ONES. This is because constructor injection ENABLES the injection of VALUES into immutable FIELDS and enables reading them more easily.

class Main{ public STATIC void main(String[] args){ int[][] num = new int[3][]; num[0] = new int[5]; num[1] = new int[2]; num[2] = new int[3]; num[2] = new int[5]; num[0] = new int[4]; num[1] = new int[3]; num = new int[2][]; }}

In the above program, a total of 7 OBJECTS will be eligible for garbage collection. Let’s visually understand what's happening in the code.

In the above figure on line 3, we can see that on each array index we are DECLARING a new array so the reference will be of that new array on all the 3 indexes. So the old array will be pointed to by none. So these three are eligible for garbage collection. And on line 4, we are creating a new array object on the older reference. So that will point to a new array and older multidimensional objects will become eligible for garbage collection.

FIRST Approach: Set the object references to null once the object creation purpose is served.

Second Approach: Point the reference variable to another object. Doing this, the object which the reference variable was referencing before becomes eligible for GC.

Third Approach: Island of Isolation Approach: When 2 reference variables pointing to instances of the same class, and these variables refer to only each other and the objects pointed by these 2 variables don't have any other references, then it is said to have formed an “Island of Isolation” and these 2 objects are eligible for GC.

public class InterviewBit{ public static void main(String[] args) { System.out.println('b' + 'i' + 't'); }}

“bit” would have been the result PRINTED if the letters were USED in double-quotes (or the string literals). But the QUESTION has the CHARACTER literals (single quotes) being used which is why concatenation wouldn't OCCUR. The corresponding ASCII values of each character would be added and the result of that sum would be printed.
The ASCII values of ‘b’, ‘i’, ‘t’ are:

• ‘b’ = 98
• ‘i’ = 105
• ‘t’ = 116

98 + 105 + 116 = 319

Hence 319 would be printed.

• The length method returns the number of Unicode units of the STRING. Let's understand what Unicode units are and what is the confusion below.
• We know that Java uses UTF-16 for String representation. With this Unicode, we NEED to understand the below two Unicode related terms:
  • Code Point: This represents an integer denoting a character in the code space.
  • Code Unit: This is a BIT sequence used for encoding the code points. In order to do this, one or more units might be required for representing a code point.
• Under the UTF-16 scheme, the code points were divided logically into 17 planes and the first plane was called the Basic Multilingual Plane (BMP). The BMP has classic characters - U+0000 to U+FFFF. The rest of the characters- U+10000 to U+10FFFF were termed as the supplementary characters as they were contained in the remaining planes.
  • The code points from the first plane are encoded using one 16-bit code unit
  • The code points from the remaining planes are encoded using two code units.

Now if a string contained supplementary characters, the length function WOULD count that as 2 units and the result of the length() function would not be as per what is expected.

In other words, if there is 1 supplementary character of 2 units, the length of that SINGLE character is considered to be TWO - Notice the inaccuracy here? As per the java documentation, it is expected, but as per the REAL logic, it is inaccurate.

This is a convenient means of initializing any collections in Java. Consider the below example.

In the above example, we SEE that the stringSets were initialized by using double braces.

• The first brace does the task of creating an anonymous inner class that has the capability of accessing the parent class’s behavior. In our example, we are creating the subclass of HashSet so that it can use the add() method of HashSet.
• The second braces do the task of initializing the instances.

Care should be taken while initializing through this method as the method involves the creation of anonymous inner classes which can cause PROBLEMS during the garbage collection or serialization processes and may ALSO result in memory leaks.

Marker interfaces, also KNOWN as tagging interfaces are those interfaces that have no methods and CONSTANTS defined in them. They are there for helping the COMPILER and JVM to get run time-related INFORMATION regarding the OBJECTS.

NO. The control of the program post System.exit(0) is immediately gone and the program gets TERMINATED which is why the FINALLY BLOCK never gets EXECUTED.

This is a big NO. We need to understand that the importing of the sub-packages of a package needs to be done EXPLICITLY. Importing the PARENT package only results in the IMPORT of the classes WITHIN it and not the contents of its child/sub-packages.

It is POSSIBLE to import a class or package more than once, HOWEVER, it is REDUNDANT because the JVM internally loads the package or class only once.

• The main ADVANTAGE of having an ordered array is the reduced search TIME complexity of O(log n) whereas the time complexity in an unordered array is O(n).
• The main drawback of the ordered array is its increased insertion time which is O(n) due to the fact that its element has to reordered to maintain the order of array during EVERY insertion whereas the time complexity in the unordered array is only O(1).
• CONSIDERING the above 2 key points and depending on what KIND of scenario a developer requires, the appropriate data structure can be used for implementation.

Java thread life cycle is as follows:

• NEW – When the instance of the thread is created and the start() method has not been invoked, the thread is considered to be alive and hence in the NEW state.
• RUNNABLE – Once the start() method is invoked, before the run() method is called by JVM, the thread is said to be in RUNNABLE (ready to run) state. This state can also be entered from the Waiting or Sleeping state of the thread.
• Running – When the run() method has been invoked and the thread starts its execution, the thread is said to be in a RUNNING state.
• Non-Runnable (Blocked/Waiting) – When the thread is not able to run despite the fact of its aliveness, the thread is said to be in a NON-RUNNABLE state. Ideally, after some time of its aliveness, the thread should go to a runnable state.
  • A thread is said to be in a Blocked state if it wants to enter synchronized code but it is unable to as another thread is operating in that synchronized block on the same object. The first thread has to wait until the other thread exits the synchronized block.
  • A thread is said to be in a Waiting state if it is waiting for the signal to execute from another thread, i.e it waits for work until the signal is received.
• Terminated – Once the run() method execution is completed, the thread is said to enter the TERMINATED step and is considered to not be alive.

The following flowchart clearly EXPLAINS the lifecycle of the thread in Java.

System.out.println() is used to print the message on the CONSOLE. System - It is a class PRESENT in java.lang package. Out is the static variable of type PrintStream class present in the System class. println() is the method present in the PrintStream class.

So if we justify the statement, then we can SAY that if we want to print ANYTHING on the console then we need to call the println() method that was present in PrintStream class. And we can call this using the output OBJECT that is present in the System class.

class InterviewBit{ INT i; static int J; { System.out.println(" Instance Block 1. Value of i = "+i); } static{ System.out.println(" Static Block 1. Value of j = "+j); method_2(); } { i = 5; } static{ j = 10; } InterviewBit(){ System.out.println(" Welcome to InterviewBit "); } public static void main(String[] args){ InterviewBit ib = new InterviewBit(); } public void method_1(){ System.out.println(" Instance method. "); } static{ System.out.println(" Static Block 2. Value of j = "+j); } { System.out.println(" Instance Block 2. Value of i = "+i); method_1(); } public static void method_2(){ System.out.println(" Static method. "); }}

The Output we get by executing this program will be

Static Block 1. Value of j = 0
Static method. 
Static Block 2. Value of j = 10
Instance Block 1. Value of i = 0
Instance Block 2. Value of i = 5
Instance method. 
Welcome to InterviewBit

This is a java tricky interview question frequently asked in java interviews for the EXPERIENCED. The output will be like this because, when the java program is compiled and gets executed, then there are various steps followed for execution. And the steps are - 

• Identification of Static Members from top to bottom.
• Execution of Static variable assignment and a Static block from top to bottom.
• Execution of the main method.
• Identification of Instance Members from top to bottom.
• Execution of Instance variable assignment and Instance block from top to bottom.
• Execution of Constructor.

In above steps from 4 to 6, will be executed for EVERY object creation. If we create multiple objects then for every object these steps will be performed.

Now from the above code, the execution will happen like this - 

1. In the step of identification of static members. It is found that -

• static int j.
• static block.
• main method.
• static method_2.

During identification, the JVM will assign the default value in the static int j variable. Then it is currently in the state of reading and indirectly writing. Because the original value is not assigned.

2. In the next step, it will execute the static block and assign the value in static variables.

• First static block it will print and because execution from top to bottom and original value in j is not assigned. So it will print the default value of 0.
• After executing static block 1. It will execute the static method_1 because it is called from the static block 1.
• Then it will assign the original value of 5 in the j variable. And executes the remaining static block.

3. Now it will execute the main method. In which it will create an object for the class InterviewBit. And then the execution of INSTANCES will happen.

4. Identify the instance variables and blocks from top to bottom. 

• int i.
• Instance block 1.
• Instance method_1.

Like a static variable, the instance variable also has been initialized with the default value 0 and will be in the state of reading and writing indirectly.

5. It will execute the instance methods and assign the original value to the instance variable.

• Prints the Instance block 1. And the current value of i is not assigned till now, so it will print 0.
• Assign the original value to i. Then print instance block 2. And after that instance method will be called and printed because it is being called in the instance block.

6. And at the last step, the constructor will be invoked and the lines will be executed in the constructor.

This is how the java program gets executed.

public void fooBarMethod(String... variables){ // method CODE}

• ABILITY to provide ... is a feature called varargs (variable arguments) which was introduced as part of Java 5.
• The function having ... in the above example indicates that it can receive multiple arguments of the datatype String.
• For example, the fooBarMethod can be called in multiple ways and we can still have one method to process the DATA as shown below:

Concurrent execution of different processes is made possible by synchronization. When a particular resource is shared between many THREADS, situations may arise in which multiple threads require the same shared resource.

Synchronization assists in resolving the issue and the resource is shared by a single thread at a time. Let’s take an example to understand it more clearly. For example, you have a URL and you have to find out the number of requests made to it. Two simultaneous requests can MAKE the count erratic.

No synchronization:

If a thread Thread1 views the count as 10, it will be INCREASED by 1 to 11. Simultaneously, if another thread Thread2 views the count as 10, it will be increased by 1 to 11. Thus, inconsistency in count values takes place because the EXPECTED final value is 12 but the actual final value we get will be 11.

Now, the function increase() is made synchronized so that simultaneous accessing cannot take place.

With synchronization:

If a thread Thread1 views the count as 10, it will be increased by 1 to 11, then the thread Thread2 will VIEW the count as 11, it will be increased by 1 to 12. Thus, consistency in count values takes place.

Yes, it is possible for the program to go out of MEMORY in spite of the presence of a garbage collector. Garbage collection assists in recognizing and eliminating those objects which are not required in the program anymore, in order to free up the resources used by them.

In a program, if an object is unreachable, then the execution of garbage collection takes place with respect to that object. If the amount of memory required for creating a NEW object is not SUFFICIENT, then memory is RELEASED for those objects which are no longer in the scope with the HELP of a garbage collector. The memory limit is exceeded for the program when the memory released is not enough for creating new objects.

Moreover, exhaustion of the heap memory takes place if objects are created in such a manner that they remain in the scope and consume memory. The developer should make sure to dereference the object after its work is accomplished. Although the garbage collector endeavors its level best to reclaim memory as much as possible, memory limits can still be exceeded.

Let’s take a look at the following example:

Both ‘new’ and ‘newInstance()’ operators are USED to creating objects. The difference is- that when we ALREADY know the class name for which we have to create the object then we use a new OPERATOR. But suppose we don’t know the class name for which we need to create the object, Or we get the class name from the command line argument, or the database, or the file. Then in that CASE we use the ‘newInstance()’ operator.

The ‘newInstance()’ keyword throws an exception that we need to HANDLE. It is because there are chances that the class definition doesn’t exist, and we get the class name from runtime. So it will throw an exception.

When a String is formed as a literal with the assistance of an ASSIGNMENT operator, it makes its way into the String constant pool so that String Interning can take place. This same object in the HEAP will be referenced by a different String if the content is the same for both of them.

The checking() function will return true as the same content is referenced by both the VARIABLES.

Conversely, when a String formation takes place with the HELP of a new() operator, interning does not take place. The object gets created in the heap memory even if the same content object is present.

The checking() function will return false as the same content is not referenced by both the variables.

Composition, and Aggregation help to build (Has - A - Relationship) between classes and objects. But both are not the same in the END. Let’s understand with the help of an EXAMPLE. 

• CONSIDER the University as a CLASS that has some DEPARTMENTS in it. So the university will be the container object. And departments in it will contain objects. Now in this case, if the container object destroys then the contained objects will also get destroyed automatically.  So here we can say that there is a strong association between the objects. So this Strong Association is called Composition.
• Now consider one more example. Suppose we have a class department and there are several professors' objects there in the department. Now if the department class is destroyed then the professor's object will become free to bind with other objects. Because container objects (Department) only hold the references of contained objects (Professor’s). So here is the weak association between the objects. And this weak association is called Aggregation.

These 2 are the BITWISE right shift OPERATORS. Although both operators LOOK similar. But there is a minimal difference between these two right shift operators.

• ‘>>’ Bitwise Right Shift Operator- This operator shifts each bit to its right position. And this maintains the signed bit.
• ‘>>>’ Bitwise Right Shift Operator with trailing ZERO- This operator also shifts each bit to its right. But this doesn’t maintain the signed bit. This operator makes the Most significant bit to 0.

Example- Num1 = 8, Num2 = -8.

So the binary form of these numbers are - 

Num1 = 00000000 00000000 00000000 00001000 
Num2 = 11111111 11111111 11111111  11111000

‘>>’ Operator : 8 >> 1 (Shift by one bit) : 

Num1 = 00000000 00000000 00000000 00000100
Num2 = 11111111 11111111 11111111  11111100

‘>>>’ Operator : 8 >>> 1 (Shift by one bit) = 

Num1 = 00000000 00000000 00000000 00000100
Num2 = 01111111 11111111 11111111 11111100

Inheritance lags BEHIND composition in the following scenarios:

• Multiple-inheritance is not possible in Java. Classes can only extend from one superclass. In cases where multiple functionalities are required, for example - to read and write information into the file, the pattern of composition is preferred. The writer, as well as reader functionalities, can be made use of by considering them as the private members.
• Composition assists in attaining high FLEXIBILITY and prevents breaking of encapsulation.
• Unit testing is possible with composition and not inheritance. When a developer wants to test a class composing a different class, then Mock Object can be created for signifying the composed class to facilitate testing. This technique is not possible with the help of inheritance as the derived class cannot be tested without the help of the superclass in inheritance.
• The loosely COUPLED nature of composition is preferable over the tightly coupled nature of inheritance.

Let’s take an example:

In the above example, inheritance is FOLLOWED. Now, some modifications are done to the Top class like this:

If the new implementation of the Top class is followed, a compile-time error is bound to occur in the Bottom class. Incompatible return type is there for the Top.stop() function. Changes have to be made to either the Top or the Bottom class to ensure compatibility. However, the composition technique can be utilized to solve the given problem: