Full stack interview questions and Answers

A connection leak implies a portion of the information base request/transaction are not getting shut as expected or are not getting committed. Lastly, those connections are getting abandoned and shut down all time.

To fix the leaks, you have to find where you have used the opening connections and then use try-with-resources that will do all the close() stuff for you.

A deadlock can appear almost when the processes share the resources. To detect the deadlock, the wait-for graph should be maintained, and the system invokes an algorithm periodically that searches for cycles in the wait-for graph.

How to avoid deadlock:

• Avoid nested locks: The main reason for the deadlock is giving locks to multiple threads. You should avoid giving the locks to multiple threads when you have already given them to one.
• Avoiding unnecessary locks: We can lock only the required members. To have a lock unnecessarily can lead to a deadlock.
• Use Thread. Join (): Deadlock condition appears when one Thread is waiting for another to finish. In case this condition arises, we can use the Thread. Join () with the maximum time the execution will take.

There are generally four main methods of session management in Servlet.

• URL rewriting
• Cookies
• HTTPS and SSL
• Hidden Form Fields

Spring MVC Framework provides two ways for handling the exceptions:

• Using XML configuration: this configuration is similar to the exception handling in Servlet/JSP, by calling a SimpleMappingExceptionResolver bean in the context file of Spring's application and the type of map execution with the view names. This approach simply applies to all the controllers in the application.
• Using exception handler method: The annotation type “@ExceptionHandler" provided by Spring is being used to annotate the method to handle the exceptions raised by the controller's methods. This approach applies to only the controllers in the application where the handler method is declared.

The static method can't be overridden in Java. This is because the overriding method depends upon the runtime dynamic binding, whereas the static methods are bonded statically at the compile time. Also, the static method is not linked with any of the class instances, so the concept is not applicable.

Constructor injection is better.

If you want to prompt the class, you always do it with the constructor. When you are using the constructor-based injection, the only way to prompt or instantiate the class is by using the constructor. If you pass the dependency via a constructor, it becomes obvious that it is an essential dependency.

However, if you use the setter injection in the POJO class, you might face challenges in setting the value of your class variable by using the setter method. This is entirely based on the customer's needs which is optional. If you pass the dependency via setter, it means that it is an optional dependency.

The overloading method is used in Java when two or more methods share the same name in the same class but with different parameters.

class Dog{
   public void bark(){
     System.out.println("woof ");
   }
  //overloading method
  public void bark(int num){
    for(int i=0; i < num; i++) {
      System.out.println("woof ");
    }
  }
}

The overriding method defines the case where the child's class redefines the same method as their parent class. The overridden methods should have the same argument list, name, and return type.

class Dog{
   public void bark(){
     System.out.println("woof ");
   }
}
class Hound extends Dog{
   public void sniff(){
     System.out.println("sniff ");
   }
   public void bark(){
     System.out.println("bowl");
   }
}

public class OverridingTest{
   public static void main(String [] args){
     Dog dog = new Hound();
     dog.bark();
   }
}

Garbage collection makes Java more memory efficient by simply removing the objects which are not referenced to anything from the heap memory and creating the free space for the new objects.