40+ Movate Interview Questions and Answers

Explaining differences between abstract class and interface, throw and throws, and why we use throws. Also, why String is immutable.

• Abstract class can have both abstract and non-abstract methods, while interface can only have abstract methods.

• A class can implement multiple interfaces, but can only extend one abstract class.

• Throw is used to explicitly throw an exception, while throws is used to declare the exceptions that a method may throw.

• We use throws to inform the caller o...read more

JDK is a development kit, JRE is a runtime environment, and JVM is a virtual machine for executing Java code.

• JDK includes JRE and development tools like javac and java

• JRE includes JVM and necessary libraries to run Java applications

• JVM is responsible for interpreting Java bytecode and executing it

• Example: JDK 8 includes JRE 8 and development tools like javac and java

• Example: JRE 8 includes JVM 8 and necessary libraries to run Java applications

Synchronization in Java is used to control access to shared resources by multiple threads.

• Synchronization can be achieved using synchronized keyword or locks.

• It ensures that only one thread can access the shared resource at a time.

• Synchronization can be applied to methods or blocks of code.

• Example: synchronized void method() { //code }

• Example: synchronized(obj) { //code }

Stream API is used to perform operations on collections in a functional programming style.

• Stream API provides a set of methods to perform operations on collections such as filtering, mapping, and reducing.

• It allows for concise and readable code by using lambda expressions.

• Stream API supports parallel processing for improved performance.

• Examples: stream.filter(x -> x > 5), stream.map(x -> x * 2), stream.reduce(0, (x, y) -> x + y)

In my current project, I implemented object-oriented programming (OOPs) principles to design and develop a banking application.

• Used encapsulation to protect sensitive customer data

• Implemented inheritance to create different types of bank accounts

• Utilized polymorphism to perform different operations on various account types

• Applied abstraction to hide complex implementation details from users

• Implemented interfaces to define common behaviors for different classes

Design patterns are reusable solutions to common software problems.

• Creational patterns: Singleton, Factory, Abstract Factory, Builder, Prototype

• Structural patterns: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy

• Behavioral patterns: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor

Difference between interface and abstract class with example

• Interface is a blueprint of a class, while abstract class is a partially implemented class

• Interface can only have abstract methods, while abstract class can have both abstract and non-abstract methods

• A class can implement multiple interfaces, but can only extend one abstract class

• Example of interface: Runnable interface in Java

• Example of abstract class: Animal class with abstract method 'makeSound'

Collections are Java classes that provide a way to store and manipulate groups of objects.

• Collections are used to store and organize multiple objects in Java.

• They provide various data structures and algorithms for efficient manipulation of objects.

• Examples of collections include ArrayList, LinkedList, HashSet, and HashMap.

Exception handling in Spring is done using @ExceptionHandler annotation, @ControllerAdvice annotation, and custom exception classes.

• Use @ExceptionHandler annotation in controller classes to handle specific exceptions.

• Use @ControllerAdvice annotation to define global exception handling for all controllers.

• Create custom exception classes by extending RuntimeException or Exception classes.

• Use try-catch blocks to handle exceptions within the code.

String is immutable to ensure its security and thread safety. It can be made mutable using StringBuilder or StringBuffer.

• String is immutable to prevent modification of its value once created.

• Immutable strings are thread-safe and can be safely shared among multiple threads.

• To make a string mutable, we can use StringBuilder or StringBuffer classes.

• StringBuilder is not thread-safe but provides better performance.

• StringBuffer is thread-safe but has slightly lower performance comp...read more

Multiple data sources in Spring can be configured using Spring Boot's @Configuration annotation and @Bean annotation.

• Use @Configuration annotation to define a configuration class for each data source

• Use @Bean annotation to create DataSource objects for each data source

• Use @Primary annotation to specify the primary data source if needed

Servlet is a Java class that handles requests and responses, while JSP is a technology that simplifies the creation of dynamic web pages.

• Servlet is a Java class that extends the capabilities of servers to respond to requests. It is used to create dynamic web content.

• JSP is a technology that simplifies the creation of dynamic web pages by allowing Java code to be embedded in HTML pages.

• Servlets are used to handle business logic, while JSP is used for presentation logic.

• Servlet...read more

Spring MVC follows a Model-View-Controller architecture where the controller receives the requests, processes them, and returns the response.

• Controller: Handles incoming requests and delegates processing to the appropriate service

• Model: Represents the data and business logic of the application

• View: Renders the model data and sends it back to the client

• DispatcherServlet: Front controller that receives all incoming requests and dispatches them to the appropriate controllers

• Hand...read more

A string is a sequence of characters used to represent text in programming.

• Strings are often used for storing and manipulating text data.

• In Java, strings are represented by the String class.

• Strings can be concatenated using the + operator.

• Strings are immutable, meaning they cannot be changed once created.

• Examples of string literals include "hello world" and "42".

Spring Boot validation is a feature that allows developers to validate input data in a Spring Boot application.

• Spring Boot validation is used to ensure that the data entered by the user meets certain criteria.

• It can be applied to request parameters, request bodies, and path variables.

• Annotations like @NotNull, @Size, @Email, etc., are commonly used for validation.

• Custom validation logic can also be implemented using custom annotations and validators.

Spring is a framework for building Java applications, while Spring Boot is a tool that simplifies the setup and configuration of Spring applications.

• Spring is a comprehensive framework that provides various modules for building Java applications, such as Spring MVC, Spring Security, and Spring Data.

• Spring Boot is an opinionated tool that simplifies the setup and configuration of Spring applications by providing defaults and auto-configuration.

• Spring Boot includes embedded ser...read more

Stack memory is used for static memory allocation and execution of thread-specific variables, while heap memory is used for dynamic memory allocation.

• Stack memory is used for static memory allocation, such as local variables and function call stack.

• Heap memory is used for dynamic memory allocation, such as objects created using 'new' keyword.

• Stack memory is limited in size and typically faster to access, while heap memory is larger and slower to access.

• Stack memory is automat...read more

Encapsulation is the process of hiding implementation details and providing access to only necessary information.

• Encapsulation helps in achieving data abstraction and information hiding.

• It allows for better control over data and prevents unauthorized access.

• In Java, encapsulation is achieved through the use of access modifiers such as private, public, and protected.

• For example, a class may have private variables that can only be accessed through public methods.

• This ensures th...read more

Interface defines only method signatures while abstract class can have both method signatures and implementations.

• Abstract class can have constructors while interface cannot

• A class can implement multiple interfaces but can only extend one abstract class

• Abstract class can have non-abstract methods while interface cannot

• Abstract class is used for creating a base class while interface is used for implementing a contract

• Example: Abstract class - Animal, Interface - Flyable

String buffer is synchronized while string builder is not.

• String buffer is thread-safe while string builder is not.

• String buffer is slower than string builder.

• String builder is preferred for single-threaded operations.

• Both classes are used for manipulating strings.

• Example: StringBuffer sb = new StringBuffer(); StringBuilder sb = new StringBuilder();

Exception handling is a mechanism to handle runtime errors. There are two types of exceptions: checked and unchecked.

• Checked exceptions are checked at compile-time and must be handled or declared in the method signature.

• Unchecked exceptions are not checked at compile-time and can be handled using try-catch or thrown to the calling method.

• Common exceptions include NullPointerException, ArrayIndexOutOfBoundsException, and IOException.

• Exception handling can improve program robus...read more

Dependency Injection (DI) is a design pattern used in Spring framework to manage object dependencies.

• DI allows objects to be loosely coupled, making them easier to test and maintain.

• In Spring, DI is achieved through inversion of control (IoC) container.

• There are three types of DI in Spring: constructor injection, setter injection, and field injection.

• Example: @Autowired annotation in Spring is used for DI.

• DI promotes reusability, modularity, and separation of concerns.

Bean scope in Spring determines the lifecycle and visibility of a bean in the Spring container.

• Bean scope defines how long a bean lives and how many instances are created

• Common scopes include singleton, prototype, request, session, and application

• Singleton scope creates a single instance per Spring container, prototype creates a new instance each time it is requested

An interface is a collection of abstract methods and constants that can be implemented by a class.

• Interfaces define a contract that a class must follow if it implements the interface.

• Interfaces can be used to achieve abstraction and polymorphism in Java.

• A class can implement multiple interfaces but can only extend one class.

• Examples of interfaces in Java include Serializable, Comparable, and Runnable.

There are multiple ways to create a thread in Java, including extending the Thread class, implementing the Runnable interface, and using Java 8's lambda expressions.

• Extending the Thread class

• Implementing the Runnable interface

• Using Java 8's lambda expressions

Comparable and Comparator are interfaces in Java used for sorting objects.

• Comparable is used to define the natural ordering of objects.

• Comparator is used to define custom ordering of objects.

• Comparable is implemented by the class whose objects need to be sorted.

• Comparator is a separate class that implements the compare() method.

• Comparable uses the compareTo() method to compare objects.

• Comparator uses the compare() method to compare objects.

• Comparable is used when the sorting ...read more

Array is a fixed-size data structure while ArrayList is a dynamic data structure in Java.

• Array is a basic data structure in Java that stores a fixed-size sequential collection of elements of the same type.

• ArrayList is a dynamic data structure that can grow or shrink in size as needed.

• Arrays are faster and more efficient for accessing elements, while ArrayLists are more flexible and easier to use.

• Example: int[] arr = new int[5]; ArrayList list = new ArrayList<>();

• Example: arr[...read more

Array is a fixed-size data structure while ArrayList is a dynamic-size data structure.

• Array is a primitive data type while ArrayList is a class in Java.

• Array has a fixed size while ArrayList can grow or shrink dynamically.

• Array can hold only homogeneous data types while ArrayList can hold heterogeneous data types.

• Array uses [] to declare while ArrayList uses <>.

• Example: int[] arr = new int[5]; ArrayList list = new ArrayList<>();

Collection framework in Java is a set of classes and interfaces that provide a standard way to store and manipulate groups of objects.

• It provides interfaces like List, Set, and Map to store collections of objects.

• Classes like ArrayList, LinkedList, HashSet, and HashMap implement these interfaces.

• Collections framework simplifies the process of storing, retrieving, and manipulating data in Java programs.

Java is a programming language while Hibernate is an ORM tool for Java.

• Java is an object-oriented programming language used for developing applications.

• Hibernate is an ORM tool that simplifies the process of mapping Java objects to database tables.

• Hibernate provides a framework for querying and manipulating data from a database using Java objects.

• Hibernate supports various database management systems such as MySQL, Oracle, and PostgreSQL.

• Hibernate reduces the amount of boiler...read more

Garbage collection is the process of automatically reclaiming memory occupied by objects that are no longer in use by the program.

• Garbage collection is a feature in Java that automatically manages memory by deallocating memory for objects that are no longer needed.

• It helps in preventing memory leaks and ensures efficient memory usage.

• Garbage collection runs in the background and identifies objects that are no longer reachable by the program.

• Examples of garbage collection algo...read more

Method overloading is when multiple methods in the same class have the same name but different parameters.

• Allows multiple methods with the same name but different parameters to be defined in a class.

• Parameters can differ in number, type, or order.

• Example: void print(int a) and void print(String s) are overloaded methods in the same class.

Array is a fixed size data structure while ArrayList is a dynamic size data structure in Java.

• Array is a primitive data type while ArrayList is a class in Java.

• Array can hold only homogeneous data types while ArrayList can hold heterogeneous data types.

• Array needs to be initialized with a fixed size while ArrayList can be initialized without a size.

• Array uses [] brackets to declare while ArrayList uses <> brackets to declare.

• Array is faster than ArrayList for accessing elemen...read more

Marker interface is an interface with no methods, used to mark a class as having a certain property or behavior.

• Marker interfaces are used for metadata purposes.

• They are used to provide information to the compiler or runtime environment.

• Examples of marker interfaces in Java include Serializable, Cloneable, and Remote.

• Marker interfaces can also be used to enforce design patterns, such as the Decorator pattern.

Multi threading is the ability of a program to execute multiple threads concurrently, allowing for better performance and responsiveness.

• Allows multiple tasks to be performed simultaneously

• Improves performance by utilizing multiple CPU cores

• Can lead to synchronization issues if not handled properly

• Example: A web server handling multiple client requests concurrently

Collection framework is a set of classes and interfaces that provide a way to store and manipulate groups of objects.

• It includes interfaces like List, Set, and Map

• It provides implementations like ArrayList, HashSet, and HashMap

• It simplifies the process of storing and manipulating data

• It allows for easy iteration and sorting of collections

• Example: List<String> names = new ArrayList<>();

• Example: Map<String, Integer> ages = new HashMap<>();

Thread is a lightweight sub-process, a separate path of execution within a program.

• Threads allow concurrent execution of two or more parts of a program.

• Java provides built-in support for multithreading through the Thread class and Runnable interface.

• Threads can be created by extending the Thread class or implementing the Runnable interface.

• Thread.sleep() method is used to pause the execution of a thread for a specified amount of time.

• Thread.join() method is used to wait for a...read more

Microservices is an architectural style that structures an application as a collection of small, independent services.

• Microservices are independently deployable and scalable.

• Each microservice focuses on a specific business capability.

• Communication between microservices is usually done through APIs.

• Microservices can be developed using different programming languages and technologies.

• Examples of companies using microservices include Netflix, Amazon, and Uber.

Constructor chaining is calling one constructor from another constructor within the same class.

• It allows to reuse the code of one constructor in another constructor.

• It is achieved using the 'this' keyword followed by the constructor parameters.

• It can be used to set default values or to initialize variables before calling another constructor.

• Example: public MyClass(int x) { this(x, 0); } public MyClass(int x, int y) { this.x = x; this.y = y; }

Runnable and Callable are interfaces in Java for creating threads. Runnable is used for tasks that don't return a result, while Callable is used for tasks that return a result.

• Runnable is a functional interface with a single run() method, while Callable is a generic interface with a single call() method.

• Runnable tasks are executed using the void run() method, while Callable tasks are executed using the Future call() method.

• Runnable tasks cannot throw checked exceptions, while...read more

Streams in Java are sequences of elements that support functional-style operations. They provide advantages like lazy evaluation and parallel processing.

• Streams allow for functional-style operations like map, filter, and reduce.

• They support lazy evaluation, meaning elements are processed only when needed.

• Streams can be easily parallelized to improve performance.

• Example: List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); Stream<String> stream = names.stream();

OOPs stands for Object-Oriented Programming. It is a programming paradigm based on the concept of objects.

• OOPs focuses on creating objects that contain both data and functions to manipulate that data.

• It emphasizes on encapsulation, inheritance, and polymorphism.

• Java, C++, Python, and Ruby are some of the popular OOPs languages.

• Example: A car can be considered as an object that has properties like color, model, and functions like start, stop, and accelerate.

JDBC is a low-level API for connecting to databases, while Hibernate is a high-level ORM framework.

• JDBC requires manual coding for CRUD operations, while Hibernate provides automatic mapping of objects to database tables.

• JDBC is more suitable for small-scale applications, while Hibernate is better for large-scale applications.

• Hibernate provides caching and lazy loading, which improves performance, while JDBC does not have these features.

• Hibernate supports inheritance mapping,...read more

Java 8 introduced several new features including lambda expressions, streams, and functional interfaces.

• Lambda expressions allow for functional programming and simplify code.

• Streams provide a way to process collections of data in a functional way.

• Functional interfaces allow for the use of lambda expressions.

• Default methods allow for adding methods to interfaces without breaking existing implementations.

• Date and time API improvements.

• Nashorn JavaScript engine.

• Parallel array so...read more

HTTP servlet is a Java class that extends the capabilities of servers that host applications accessed by HTTP protocol.

• HTTP servlet is a Java class that extends the capabilities of servers that host applications accessed by HTTP protocol

• It is used to handle HTTP requests and responses

• It provides methods to get information about the request and to send a response back to the client

• It can be used to create dynamic web pages, handle form data, and manage sessions

• Example: HttpSer...read more

Patch and put are HTTP methods used for updating resources on a server.

• PATCH is used to partially update a resource, while PUT is used to completely replace a resource.

• PATCH requests only include the changes that need to be made, while PUT requests require sending the entire updated resource.

• PATCH is often used for incremental updates, while PUT is used for full updates.

• Example: PATCH request to update the 'name' field of a user resource, and PUT request to replace the entire...read more

OOPs (Object-Oriented Programming) is a programming paradigm based on the concept of objects, which can contain data and code.

• OOPs focuses on creating objects that interact with each other to solve a problem.

• Key principles include encapsulation, inheritance, polymorphism, and abstraction.

• Encapsulation involves bundling data and methods that operate on the data into a single unit.

• Inheritance allows a class to inherit properties and behavior from another class.

• Polymorphism allo...read more

OOPs is a programming paradigm based on the concept of objects.

• OOPs stands for Object-Oriented Programming.

• It focuses on creating objects that contain both data and functions.

• Encapsulation, Inheritance, and Polymorphism are the three main pillars of OOPs.

• Java, C++, Python, and Ruby are some of the popular OOPs languages.

• Example: A car can be an object with properties like color, model, and functions like start, stop, and accelerate.