Core Java and J2EE Concepts Quiz

The == operator performs reference equality in Java, comparing if two strings are literally the same object in memory. The new String() creates a new object instance even if the literal value is identical, thus making s1 == s3 false. "abc" is a string literal and is treated as a unique object, hence s1 == s2 is true.

The continue statement skips the current iteration of the loop and jumps to the next one. The break statement completely terminates the loop's execution. This code increments y and checks conditions. Even numbers are skipped (y % x == 0), and the loop breaks at y == 8. Only odd numbers less than 8 are printed.

In Java, inheritance follows the principle of "hiding" or "shadowing". The child class (B) inherits the parent class (A) but can declare member variables (like int a) with the same name. So, within the scope of class B, obj.a refers to B's a (20). However, because obj is declared as type A, only A's methods are accessible, hence a (10) is printed.

The code iterates through an array, swapping each element with the one at the opposite end. The assignment arr[i] = arr[arr.length - 1 - i] basically flips the array around.

Multiple inheritance is not directly supported in Java. Interfaces can have default methods, which are implemented by classes that implement that interface. Using X.super.print() explicitly calls the default method of interface X.

AWT is a Java library for creating basic graphical user interfaces (GUIs) but is not a part of the J2EE architecture, which focuses on enterprise-level web applications. Java Servlet, JSP, and EJB are core components of J2EE.

Enterprise JavaBeans (EJB) is a framework for developing server-side components that support distributed transactions, allowing multiple applications to work together across networks.

JNDI (Java Naming and Directory Interface) is an API used in J2EE applications to look up and discover resources, such as databases, JMS queues, and EJBs, using a naming system. Essentially, it acts like a phone book for accessing objects within a J2EE application.

The web.xml deployment descriptor in a J2EE web application is where you configure key aspects of your app, including mapping URLs to servlets, setting session timeout values, and defining security constraints. It's the central configuration file for your web application.

Servlets are Java programs that run on a web server and generate dynamic web content. They handle HTTP requests, process data, and send responses to clients, enabling interactive web applications.

To mark an entity as immutable in Hibernate, we use the @Immutable annotation. This ensures that Hibernate treats the entity as read-only and doesn't attempt to modify it.

The @Fetch(FetchMode.SUBSELECT) annotation tells Hibernate to fetch associated collections using a separate subquery for each entity. This helps optimize performance when there are many entities but reduces the need to join tables.

The second-level cache in Hibernate acts as a shared cache for entities across sessions, improving performance by storing frequently accessed data. This enables all sessions to access the same cached data.

The @version annotation in Hibernate marks a specific field as a 'version' field, used for optimistic locking. When an entity is updated, Hibernate compares the version value to detect potential conflicts.

The @NaturalId annotation in Hibernate maps a natural business key (a field representing a unique identifier) to a unique constraint in the database. This helps maintain data integrity and ensure uniqueness based on real-world constraints.

The @Component annotation is used to mark a class as a candidate for auto-detection by Spring's component scanning mechanism, making it a Spring-managed bean. This facilitates dependency injection and allows Spring to manage the lifecycle of your component.

The @Autowired annotation in Spring is used to inject dependencies automatically by type. It allows Spring to find and inject the correct instance of a dependency into the annotated method parameter or field.

Spring Boot is a powerful tool for building Spring applications with minimal configuration. It provides auto-configuration, embedded servers, and CLI tools, making development much easier.

The @Transactional annotation in Spring is used to mark a method as requiring transactional behavior. It instructs Spring to manage the transaction for that method, ensuring consistency and data integrity.

Custom scopes in Spring allow you to control the lifecycle and visibility of your beans. You can extend the Scope interface to define your own custom scopes and register them with the Spring application context.

WSDL (Web Services Description Language) is used to describe the capabilities of a web service, including the operations it supports (e.g., methods, parameters), data types (e.g., XML schema), and how to communicate with it. Think of it as a contract that defines how to interact with the web service.

The HTTP method PUT is idempotent, meaning that multiple identical requests have the same effect as one. In RESTful APIs, it's typically used to update an existing resource, replacing it entirely with the data provided in the request body.

UDDI (Universal Description, Discovery, and Integration) is a registry where businesses can publish information about their web services, and other businesses can discover and use those services. It acts like a central directory for web services.

HATEOAS (Hypermedia As The Engine Of Application State) is a REST API design constraint, aiming for APIs that are self-documenting and discoverable. It means making APIs discoverable through links within the response, allowing clients to understand what actions are available without prior external documentation.

WS-Security is a standard used to secure SOAP-based web services, providing authentication, message integrity (ensuring message hasn't been tampered with), and confidentiality (encrypting message content). It's crucial for sensitive data exchange in web services.

The Strategy pattern in Java allows you to dynamically switch between different algorithms or implementations at runtime. It uses composition over inheritance to achieve flexibility, as you can plug in different algorithm objects to your main object.

The Bridge pattern in Java decouples an abstraction (interface or abstract class) from its implementation (concrete classes), allowing both to vary independently. Think of it as separating different aspects of a system, allowing for more manageable and flexible code.

The Protection Proxy pattern in Java provides access control to an object by filtering operations. Some actions are allowed, others are blocked, effectively controlling who can access the real subject object.

The State pattern in Java allows an object to change its behavior based on its internal state. The object's functionality can vary depending on the current state, allowing for more dynamic and context-aware behavior.

The Singleton pattern in Java ensures that a class has only one instance. However, in a multithreaded environment without proper synchronization, multiple threads can concurrently attempt to create an instance, potentially leading to multiple singleton instances, violating the pattern's core principle.

Microservices architecture is built around the idea of creating small, independent, self-contained services that communicate with each other. This approach emphasizes loose coupling, making services flexible and scalable.

A service registry acts as a central directory in a microservices architecture. It allows services to discover and locate each other dynamically. This eliminates hard-coded dependencies and enables services to adapt to changes in the system.

An API gateway in a microservices architecture is a central entry point for client requests. It routes requests to the appropriate microservice based on their path, headers, or other criteria. It simplifies client interactions and provides a consistent interface.

The CAP theorem states that a distributed system cannot simultaneously ensure Consistency (data is always synchronized), Availability (system is always operational), and Partition Tolerance (system works even if parts are isolated). You have to choose two out of three, depending on your system's requirements.

The Circuit Breaker pattern helps improve resilience in microservices. It prevents cascading failures by temporarily stopping calls to a service that is failing. If the service returns to a healthy state, the circuit breaker will allow calls again.

In JavaScript, the this keyword's value depends on how the function is called. In this case, the function sum is called without an object context, so this refers to the global object in the browser, which is a window object. Since window object doesn't have a and b properties, the calculation results in NaN.

The transform property in CSS3 allows you to apply 3D transformations to elements. These transformations can include rotations, translations, scaling, and skewing, creating visually interesting effects.

The <optgroup> element in HTML5 is used to group a set of options within a select element (dropdown list). This allows you to logically group related options for better organization and user experience.

The position: sticky; property in CSS3 makes an element stick to the viewport when the user scrolls. Initially, the element remains in its normal position. But once the scroll position passes a certain threshold, the element will stick to the viewport, ensuring it remains visible.

In this JavaScript code, the IIFE (Immediately Invoked Function Expression) creates a new scope. Inside the IIFE, this refers to the global object (window object in browser environment). So, typeof this returns "object".

The useEffect hook in React is used to perform side effects like fetching data, setting up subscriptions, or interacting with the DOM. The dependency array ([]) ensures that the side effect runs only once on initial render.

The useMemo hook in React memoizes the return value from a function. This means that if the function's dependencies haven't changed, the cached result is returned. This helps optimize performance by preventing unnecessary recalculations.

The React.memo function in React is used to memoize functional components. It checks if the component's props have changed and only renders the component if something has changed. This helps avoid unnecessary re-renders and improves performance.

The useCallback hook in React memoizes a callback function. This means that the callback function only re-creates when its dependencies change. This is helpful to prevent unnecessary re-renders of child components that rely on this callback.

The React Context API provides a way to share data and state across components without manual prop drilling. This is helpful for passing data like themes, user preferences, and other global data.

Amazon ECS (Elastic Container Service) is a fully managed container orchestration service for deploying, scaling, and managing containerized applications. It integrates seamlessly with Docker and provides features like service discovery and load balancing.

AWS Lambda is a serverless compute service that lets you run code without managing servers. You can upload your code and Lambda will automatically execute it when triggered by events such as HTTP requests, database changes, or file uploads.

AWS CloudFormation lets you model and provision your AWS resources using templates. It automates the creation, updating, and deletion of resources, making it easier to manage your infrastructure as code.

Amazon DynamoDB is a fully managed NoSQL database service that provides high performance and scalability. It uses a key-value store model and is suitable for applications that require fast data access.

AWS CodePipeline is a fully managed continuous integration and continuous delivery (CI/CD) service that lets you automate the build, test, and deployment of your applications. It integrates with other AWS services like CodeCommit, CodeBuild, and CodeDeploy.

The HAVING clause in SQL is used to filter groups of rows after they have been aggregated using the GROUP BY clause. It allows you to apply conditions to the aggregated results.

A correlated subquery in SQL is a subquery that refers to a column (or columns) from the outer query. It is evaluated for each row returned by the outer query, allowing you to conditionally filter or retrieve data based on the values in the outer query.

To create an index on a table in SQL, you use the CREATE INDEX statement. Indexes help speed up data retrieval by creating a sorted structure that contains a subset of the table's data, making searching more efficient.