1. **Explain about yourself:**
- This is a common question where you should provide a brief overview of your professional
background, education, and relevant experiences. Highlight your expertise in Java Full Stack
development, any notable projects, and your key skills.
2. **Explain about monolithic architecture:**
- A monolithic architecture is a traditional software development approach where the entire
application is built as a single, tightly-coupled unit. All components of the application, such as
the user interface, business logic, and data access layer, are packaged together. This
architecture is contrasted with microservices, where the application is broken into smaller,
independent services.
3. **What is Spring dependency injection?**
- Spring Dependency Injection is a design pattern used in the Spring Framework. It allows
objects to be injected with their dependencies rather than creating the dependencies within the
object itself. This promotes loose coupling and easier testing. In Spring, dependency injection
can be achieved through constructor injection, setter injection, or method injection.
4. **Write code for Restful web service:**
- A simple example of a RESTful web service in Java using Spring Boot:
```java
@RestController
public class UserController {
@GetMapping("/users/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
// Retrieve user from the database
User user = userRepository.findById(id).orElse(null);
if (user != null) {
return new ResponseEntity<>(user, HttpStatus.OK);
} else {
return new ResponseEntity<>(HttpStatus.NOT_FOUND);
}
}
}
```
5. **What is a stored procedure?**
- A stored procedure is a precompiled collection of one or more SQL statements that can be
executed as a single unit. Stored procedures are stored in a database and can be called by
applications or other stored procedures. They are used for better performance, modular code
organization, and security.
6. **Difference between == and === in JavaScript?**
- In JavaScript, `==` checks for equality after type coercion, whereas `===` checks for strict
equality without type coercion. For example, `1 == '1'` would be true, but `1 === '1'` would be
false.
7. **How to schedule jobs in Jenkins?**
- Jobs in Jenkins can be scheduled using cron syntax in the build trigger configuration. For
example, to schedule a job every day at 3 AM, the cron expression would be `0 3 * * *`.
8. **Explain about your previous project:**
- Provide a detailed overview of a relevant project, discussing the technologies used, your
role, challenges faced, and how you contributed to the project's success.
9. **Explain the singleton design pattern:**
- The Singleton Design Pattern ensures that a class has only one instance and provides a
global point of access to that instance. It involves a private constructor, a private static instance
of the class, and a public static method to retrieve the instance.
10. **Threading:**
- Threading involves executing multiple threads concurrently. In Java, this can be achieved
using the `Thread` class or the `ExecutorService` framework. It helps in improving application
performance by parallelizing tasks.
11. **Give a general overview of the Java memory model:**
- The Java Memory Model defines how threads in a Java program interact through memory. It
includes concepts like the heap, stack, and the Java Memory Model ensures visibility of
changes made by one thread to other threads.
12. **HashMap details:**
- `HashMap` is a data structure that stores key-value pairs. It uses hashing to efficiently
retrieve values based on keys. It allows one null key and multiple null values. Retrieving values
from a `HashMap` is fast, but the order of elements is not guaranteed.
13. **How can you stop clone in a singleton Java class?**
- To prevent cloning in a Singleton class, you can throw a `CloneNotSupportedException` in
the `clone()` method or override the `clone()` method to return the singleton instance.
14. **How will you iterate `HashMap`?**
- You can iterate through a `HashMap` using the `entrySet()` method or the `keySet()`
method along with an iterator. For example:
```java
for (Map.Entry<K, V> entry : hashMap.entrySet()) {
K key = entry.getKey();
V value = entry.getValue();
// Process key and value
}
```
15. **What will you do if a Java application is slow or lagging?**
- Investigate performance bottlenecks using profilers and monitoring tools. Analyze database
queries, optimize algorithms, and consider caching. Thoroughly review code for inefficiencies
and consider parallelization where applicable.
16. **Synchronization:**
- Synchronization in Java is the process of controlling the access of multiple threads to
shared resources. It can be achieved using the `synchronized` keyword, locks, or other
concurrency utilities.
17. **Explain Angular routing and how it works:**
- Angular routing allows navigation between different components and views in a single-page
application. It uses the Angular Router module to define routes, associate them with
components, and handle navigation.
18. **Java 8 features:**
- Key features of Java 8 include lambda expressions, functional interfaces, the Stream API,
default methods in interfaces, and the `java.time` package for improved date and time handling.
19. **Sort a list using Java 8:**
- Using the `Comparator` interface and lambda expressions:
```java
list.sort((obj1, obj2) -> obj1.compareTo(obj2));
```
20. **Angular AOT:**
- Ahead-of-Time (AOT) compilation in Angular involves translating Angular components and
templates into highly optimized JavaScript code during the build process. This improves runtime
performance.
21. **Angular internal implementation:**
- Discuss the internal workings of Angular, including the component lifecycle, change
detection mechanism, dependency injection, and the role of modules.
22. **Java string concepts:**
- Strings in Java are immutable objects. Common operations include concatenation,
substring, and length retrieval. The `StringBuilder` class is used for mutable string operations.
23. **Difference between class and interface:**
- A class can have both concrete methods and fields, while an interface can only have
abstract methods and constants. A class can extend only one class, but it can implement
multiple interfaces.
24. **What is a LinkedList:**
- A LinkedList is a data structure where each element (node) contains data and a reference to
the next node in the sequence. It allows for efficient insertion and deletion but has slower
random access compared to arrays.
25. **Tell me about your previous projects:**
- Discuss another relevant project, emphasizing your role, technologies used, challenges
overcome, and the impact on the business or users.
26. **New features of HTML5:**
- HTML5 introduces new features like semantic elements (header, footer, article), audio and
video support, canvas for drawing graphics, local storage, and improved form elements.
27. **Most used design patterns:**
- Common design patterns include Singleton, Factory, Observer, Strategy, Decorator, and
MVC. Discuss their applications and benefits in software design.
28. **How do you avoid Cross-Origin
exceptions between frontend and backend:**
- Use CORS (Cross-Origin Resource Sharing) headers on the server to specify which origins
are allowed to access resources. Configure the server to handle preflight requests and respond
appropriately.
29. **Difference between SOAP and REST:**
- SOAP (Simple Object Access Protocol) is a protocol for exchanging structured information
using XML, while REST (Representational State Transfer) is an architectural style using
standard HTTP methods and typically relies on JSON for data representation.
30. **Collection Framework:**
- The Java Collection Framework provides interfaces and classes for managing and
manipulating collections of objects. Key interfaces include List, Set, Queue, and Map, with
various implementations like ArrayList, HashSet, PriorityQueue, and HashMap.
31. **Exception Handling:**
- Exception handling in Java involves using try, catch, and finally blocks. Checked exceptions
must be declared in the method signature or caught, while unchecked exceptions need not be
declared.
32. **Explain the working of each API layer:**
- Discuss the responsibilities of each API layer, such as the presentation layer (UI), business
logic layer, and data access layer. Emphasize the role of RESTful APIs in communication.
33. **Explain in detail how requests are made to the backend and responses displayed in
frontend:**
- Describe the frontend making HTTP requests to backend APIs, handling asynchronous
responses, and updating the UI. Discuss frameworks like Angular's HttpClient for handling
requests.
34. **Difference between == and .equals():**
- In Java, `==` compares object references, while `.equals()` compares the content of objects.
`.equals()` should be overridden in custom classes for meaningful content comparison.
35. **How is a String saved in JAVA:**
- Strings in Java are saved in the String Pool, a special area in the heap memory. The String
Pool helps in reusing string literals, reducing memory overhead.
36. **Difference between string pool and heap memory:**
- The String Pool is a part of the heap memory, specifically used for storing string literals. The
heap memory, in general, is used for dynamic memory allocation.
37. **What is Bean, what are the bean scopes, and which is the default:**
- In Spring, a Bean is an object managed by the Spring IoC container. Bean scopes include
Singleton, Prototype, Request, Session, and Application. Singleton is the default scope.
38. **Collections:**
- Discuss the various collections in Java, such as List, Set, Queue, and Map, and their
common use cases.
39. **HashMap:**
- Reiterate the usage of `HashMap` for storing key-value pairs and its key characteristics.
40. **TreeMap:**
- `TreeMap` is a sorted map implementation based on a Red-Black tree. It maintains the keys
in a sorted order.
41. **Stacks:**
- Stacks are data structures that follow the Last In First Out (LIFO) principle. Elements are
added and removed from the top of the stack.
42. **Spring Boot basic question:**
- Discuss the benefits of Spring Boot, its convention over configuration approach, and how it
simplifies the development of production-ready applications.
43. **Explain about Java Virtual Machine (JVM):**
- JVM is an integral part of Java. It provides a runtime environment for Java applications to
execute. It takes Java bytecode, generated during the compilation process, and translates it into
machine code for the underlying hardware.
44. **What is the Observer pattern and where is it used in Java?**
- The Observer pattern is a behavioral design pattern where an object, known as the subject,
maintains a list of its dependents, called observers, that are notified of any state changes. In
Java, it is commonly used in event handling, such as the implementation of listeners in GUI
programming.
45. **Explain the Model-View-Controller (MVC) architecture:**
- MVC is a software architectural pattern where the application is divided into three
interconnected components: Model (data and business logic), View (presentation and UI), and
Controller (handles user input and updates the Model). It promotes separation of concerns and
maintainability.
46. **What is Aspect-Oriented Programming (AOP) in Spring?**
- AOP is a programming paradigm that allows modularizing cross-cutting concerns (e.g.,
logging, security) separately from the main business logic. In Spring, AOP is used to achieve
this separation by defining aspects that can be applied to multiple components.
47. **Explain the concept of lazy loading in Hibernate:**
- Lazy loading is a technique where data is loaded on-demand, rather than loading it all at
once. In Hibernate, it is often used with associations. For example, if an entity has a collection of
other entities, lazy loading ensures that the collection is not loaded until explicitly requested.
48. **What are the SOLID principles in object-oriented design?**
- SOLID is an acronym representing five design principles: Single Responsibility Principle,
Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and
Dependency Inversion Principle. These principles guide developers in creating maintainable
and scalable software.
49. **Explain the differences between Java 8 streams and collections:**
- Java 8 streams provide a functional approach for processing sequences of elements. While
collections are data structures that store and manage elements, streams allow for functionalstyle operations like map, filter, and reduce, promoting parallelism and concise code.
50. **What is the purpose of the `finally` block in exception handling?**
- The `finally` block in exception handling is used to specify code that must be executed,
regardless of whether an exception is thrown or not. It is typically used for cleanup operations,
such as closing resources, ensuring they are released.
51. **Explain the use of `@RequestMapping` in Spring MVC:**
- `@RequestMapping` is an annotation used in Spring MVC to map web requests to specific
controller methods. It allows developers to define how the requests should be handled,
specifying the URL path, HTTP methods, and other parameters.
52. **How does garbage collection work in Java?**
- Garbage collection in Java is an automatic process where the JVM identifies and frees up
memory occupied by objects that are no longer reachable. The `gc()` method can be invoked to
suggest garbage collection, but the JVM decides when and how to perform it.
53. **What is the purpose of the `super` keyword in Java?**
- The `super` keyword in Java is used to refer to the immediate parent class of the current
class. It is often used to invoke the parent class's methods, access parent class fields, or call
the parent class's constructor.
54. **Explain the concept of A/B testing:**
- A/B testing, also known as split testing, involves comparing two versions (A and B) of a
webpage or application to determine which performs better. It is commonly used in software
development and marketing to optimize user experience and outcomes.
55. **What is the role of an application server in Java EE architecture?**
- In Java EE (Enterprise Edition), an application server provides a runtime environment for
deploying, managing, and executing enterprise-level Java applications. It includes features such
as transaction management, security, and connectivity to databases.
56. **Explain the purpose of the `@Autowired` annotation in Spring:**
- The `@Autowired` annotation in Spring is used for automatic dependency injection. It allows
Spring to automatically wire and inject the dependencies required by a class, reducing the need
for manual configuration.
57. **What is the purpose of the `volatile` keyword in Java?**
- The `volatile` keyword in Java is used to indicate that a variable's value may be changed by
multiple threads simultaneously. It ensures that changes made by one thread are immediately
visible to other threads, preventing visibility issues.
58. **Explain the concept of microservices architecture:**
- Microservices architecture is an approach where a software application is divided into small,
independent services that communicate through APIs. Each service is responsible for a specific
business capability and can be developed, deployed, and scaled independently.
59. **How does Hibernate ORM work with relational databases?**
- Hibernate is an Object-Relational Mapping (ORM) framework that simplifies database
interaction by mapping Java objects to database tables. It handles database operations,
allowing developers to work with Java objects instead of SQL queries.
60. **Explain the principles of RESTful design:**
- REST (Representational State Transfer) is an architectural style that follows principles like
statelessness, uniform interface, resource-based, and client-server communication. RESTful
APIs use standard HTTP methods (GET, POST, PUT, DELETE) for communication.