ADVANCE JAVA & J2EE ANSWERS:

1. List the main principles of Object Oriented Programming with examples.

Four Fundamental Principles of OOPs:
 Encapsulation: Encapsulation is the concept of bundling data (variables) and methods
(functions) that operate on the data into a single unit called a class.
Example: A class Car with private attributes and public methods.
 Inheritance: Inheritance allows a new class to inherit properties and methods from an existing
class. This helps in code reusability.
Example: class Dog extends Animal.
 Polymorphism: Polymorphism means "many forms", and it allows objects to be treatedas
instances of their parent class rather than their actual class.
Example: Overriding speak() in Dog and Cat classes.
 Abstraction: Abstraction involves hiding complex implementation details and showing only
the necessary features.
Example: Abstract Animal class with a makeSound() method.
2. What is the difference between procedural and object-oriented
programming?

(OR)
3. What are the different types of variables in Java with examples.
Types of Variables in Java (Detailed Explanation)
1. Local Variables: Declared inside methods, constructors, or blocks. They exist only
during method execution and are destroyed afterward. Must be initialized before use.
Example: int age = 25; in main().

2. Instance Variables: Declared inside a class but outside methods. Each object has its
copy. Initialized with default values if not assigned.
Example: String name;.
 3. Static Variables: Declared using the static keyword. Shared across all objects of a class,
maintaining a single copy. Useful for constants.
Example: static int count;.

4. List the significance of wrapper classes in Java with examples.

Significance of Wrapper Classes in Java
Wrapper classes convert primitive data types (like int, double) into corresponding objects,
enabling their use in collections, frameworks, and APIs that require objects. They provide utility
methods to manipulate, parse, and convert primitive values. Autoboxing automatically converts
primitives to objects, while unboxing does the reverse.
Examples:

5. How are classes and objects related in Java? Provide a simple code.
Classes and Objects Relationship in Java
A class is a blueprint or template that defines properties (fields) and behaviors (methods) for
objects. Objects are instances of classes, created to represent real-world entities. The class
defines the structure, while objects hold specific values for the structure. Classes allow code
reusability and modularity, while objects enable dynamic interactions.
Example:
6. Describe the process of creating and using objects in Java.
Creating and Using Objects in Java
1. Define a Class: Create a blueprint for the object, defining fields and methods.
2. Create Objects: Use the new keyword to instantiate objects.
3. Access Fields or Methods: Use the object to access properties or call methods.

7. What is abstraction in Java? How is it achieved using abstract classes?

Abstraction in Java
Abstraction in Java refers to the concept of hiding implementation details and showing only
essential features. It allows focusing on what an object does, rather than how it does it. This
simplifies complex systems by hiding unnecessary details and exposing only relevant
functionality.
Achieved Using Abstract Classes:
Abstract classes cannot be instantiated and may contain abstract methods (methods without a
body) that must be implemented by subclasses.
Example:
8. How is abstraction different from encapsulation?

9. Show encapsulation with a code example.

OUTPUT:
10. What is inheritance? Explain different types of inheritance with examples.
Inheritance in Java
Inheritance allows a class to inherit properties and behaviors (methods) from another class,
promoting code reusability and creating a relationship between classes. It can be categorized as:
1. Single Inheritance: One class inherits from another.
2. Multilevel Inheritance: A class inherits from another, which also inherits from a third
class.
3. Hierarchical Inheritance: Multiple classes inherit from a single parent class.
Example:

11. How does Java support inheritance? What is the significance of the super keyword?
Java supports inheritance using the extends keyword, allowing a subclass to inherit methods and
properties from a superclass. This enables code reuse and creates a hierarchy of classes.
The super keyword refers to the parent class, allowing access to parent class methods and
constructors. It’s used to call the parent class’s method or constructor when it’s overridden in the
subclass.
Example:

Here, super.sound() calls the sound() method from Animal.

12. What is polymorphism? Explain compile-time and runtime polymorphism with
examples.
Polymorphism: Compile-time and Runtime
Polymorphism in Java allows objects to take on multiple forms, enabling a single interface to
represent different behaviors.
1. Compile-time (Static) Polymorphism: Achieved through method overloading, where
multiple methods with the same name have different parameter lists. The method to be
called is determined at compile-time. Example:

2. Runtime (Dynamic) Polymorphism: Achieved through method overriding, where a

subclass provides its own implementation of a method defined in the superclass. The
method to be called is determined at runtime. Example:

13. Demonstrate Java Server Pages(JSP) engine, and how does it work?
Java Server Pages(JSP) engine:
The JSP engine converts JSP files into servlets(Java programs that handle requests), compiles
them into bytecode(Compiled machine-readable code), and executes them to generate dynamic
content, enabling interactive, data-driven web applications on user requests.
Process:
1. Request a JSP page.
2. Parse and convert it into a servlet.
3. Compile into bytecode.
4. Execute to generate dynamic content.
14. Explain the lifecycle of a Java Server Pages(JSP). At what stage is the JSP translated
into a servlet?
JSP Lifecycle & Translation to Servlet
The JSP(Java Server Pages) lifecycle consists of three phases:
1. Translation Phase: When a JSP page is requested, the JSP engine converts the JSP code
into a Java servlet. This happens the first time the JSP is requested or after a change to
the file.
2. Compilation Phase: The generated servlet is compiled into bytecode and stored as a
.class file.
3. Execution Phase: The compiled servlet is executed to produce dynamic content (like
HTML) and send it to the user's browser.
The translation into a servlet occurs during the Translation Phase.
15. Compare between the translation and compilation phases of a Java Server Pages(JSP)
lifecycle.
A .class file is compiled Java bytecode ready for execution.

16. Outline the role of scripting elements in Java Server Pages(JSP)? Provide examples of
declaration, scriptlet, and expression tags.
JSP scripting elements allow embedding Java code in HTML for dynamic content:
 Declaration (<%! %>): Declares variables or methods.
 Scriptlet (<% %>): Executes Java code during request.
 Expression (<%= %>): Displays results of Java expressions directly in HTML.
These elements make web pages interactive and data-driven.
EXAMPLE:
Comments:
 Declaration: Declares x and method square().
 Scriptlet: Executes code, prints x, and calls square().
 Expression: Displays the square of x.
17. Explain the difference between < 0 <= d include %> and <jsp:include>. When would
you use each?

(OR)

18. Show how can the <jsp: forward> tag be used in a Java Server Pages (JSP)? Illustrate
with an example
The <jsp:forward> tag is used to forward a request from one JSP page to another JSP or servlet
for further processing. When the request is forwarded, the current page’s execution stops, and
control is transferred to the target resource. It is commonly used when you need to delegate
request processing to another page.
Example:

19. Demonstrate any five implicit objects in Java Server Pages(JSP). Provide an example of
how the session and out objects are used.
Implicit Objects in JSP
JSP provides pre-defined objects for easy access to common functionalities. Five key implicit
objects include:
1. request: Represents the HTTP request, used to get data from the client.
Example: <%= request.getParameter("name") %>
2. response: Represents the HTTP response, used for redirection.
3. session: Stores user-specific session data.
Example: <%= session.getAttribute("username") %>
4. out: Sends output to the client.
Example: <%= out.print("Welcome!") %>
5. application: Represents shared application data.
These objects simplify dynamic content creation.
Example:
20. Illustrate how the request object in Java Server Pages(JSP) can be used to retrieve form
data submitted via a POST method.
Retrieving Form Data with request Object in JSP
The request object in JSP retrieves data submitted via a form using the POST method. Use
request.getParameter("fieldName") to fetch form input values. For example:

21. Interpret the steps involved in handling uncaught exceptions in Java Server Pages(JSP)
using error pages? Provide code examples.
Steps to Handle Uncaught Exceptions in JSP
1. Define an Error Page: Use the errorPage attribute in the primary JSP to link to the error-
handling page.
2. Access Exception Object: Set isErrorPage="true" in the error page to enable access to
the exception object.
3. Display Error Details: Use <%= exception.getMessage() %> in the error page to show
the error message.
4. Automatic Redirection: If an exception occurs, it redirects automatically to the error
page.
5. Maintain Clear Separation: Keep error-handling logic separate for better
maintainability.
22. Explain the role of the "isErrorPage" attribute in Java Server Pages(JSP) error
handling. How does it enable exception access?
The isErrorPage attribute in JSP allows a page to handle errors by accessing the exception object.
It retrieves details like error messages and stack traces, enabling better error reporting and
enhancing the user experience.

23. Show the purpose of the <c:forEach> tag in JavaServer Pages Standard Tag Library
(JSTL). How does it simplify iteration in Java Server Pages (JSP)?
The <c:forEach> tag in JSTL(JavaServer Pages Standard Tag Library) simplifies iteration over
collections or arrays in JSP by eliminating the need for scriptlets (Java code) and making the
page cleaner. It loops through a list or array and dynamically generates HTML content.
(OR)
 The <c:forEach> tag simplifies iteration in JSP.
 It eliminates the need for scriptlets (Java code).
 Loops through collections or arrays.
 Dynamically generates HTML content.
 Promotes cleaner and more readable JSP pages.
Example:

24. Contrast Java Server Pages(JSP) snippet that uses JavaServer Pages Standard Tag
Library (JSTL) tags to display a list of user names from a collection.
Contrast: Using JSTL for Displaying Usernames
 Using JSTL: Uses the <c:forEach> tag to loop through a collection and display user
names in a cleaner, tag-based format. It eliminates the need for scriptlets, promoting
cleaner and more maintainable code.
 Without JSTL: Uses scriptlets (<% %>) to loop through the collection and display user
names using Java code directly in the JSP. This can make the JSP more complex and
harder to maintain.
Code Example:

25. Explain Java DataBase Connectivity (JDBC), and how does it facilitate the interaction
between Java applications and databases?
Java Database Connectivity (JDBC)
1. Definition: JDBC is a Java API that allows Java applications to connect and interact with
databases.
2. Purpose: It facilitates sending SQL queries, updating databases, and retrieving results.
3. Process: JDBC establishes a connection to a database, executes SQL commands, and
handles results.
4. Example: Connecting to a MySQL database using JDBC.

26. Outline the key components of Java DataBase Connectivity (JDBC).

Definition: JDBC (Java Database Connectivity) is a Java API for connecting and interacting with
relational databases.
Components:
1. DriverManager: Manages database drivers.
2. Connection: Represents a connection to a database.
3. Statement: Executes SQL queries.
4. ResultSet: Represents query results.
5. PreparedStatement: Precompiled SQL query.
Example

27. Explain the architecture of Java DataBase Connectivity (JDBC), detailing the roles of
the application layer, JDBC driver manager, JDBC drivers, and the database layer.
JDBC Architecture
 Application Layer: Sends queries using JDBC API.
 JDBC Driver Manager: Manages database communication.
 JDBC Driver: Translates API calls to database commands.
 Database Layer: Processes commands and returns data.

28. Compare the four types of Java DataBase Connectivity (JDBC) drivers. Which one is
most commonly used today and why?

Most Commonly Used: Type-4 is most commonly used due to its simplicity, portability, and no
dependency on additional software. ODBC stands for Open Database Connectivity
29. Illustrate the steps involved in connecting a Java program to a database using Java
DataBase Connectivity (JDBC)? Provide an example code for each step.
Steps to Connect Java to Database using JDBC:
1. Load the JDBC Driver: Load the database-specific JDBC driver class.
2. Establish the Connection: Connect to the database using
DriverManager.getConnection() method.
3. Create a Statement: Create a Statement object to execute SQL queries.
4. Execute Queries: Execute queries (SELECT, INSERT, etc.) using the Statement object.
5. Process the Results: Retrieve and process the results using a ResultSet.
30. Demonstrate the role and common methods of the ResultSet object in Java DataBase
Connectivity (JDBC). How is it used to retrieve data from a database?
Role and Common Methods of ResultSet in JDBC
1. Role:
o ResultSet stores data retrieved from a database after executing SQL queries.
o It allows iteration over the results and retrieval of column values.
2. Common Methods:
o next(): Moves the cursor to the next row.
o getString(), getInt(), etc.: Retrieves data of specific column types.
o getRow(): Retrieves the current row number.
3. Usage:
o It is used to retrieve and process query results, typically inside a loop.
Retrieving Data Using ResultSet in JDBC
1. Execute Query: Use Statement.executeQuery() to run a SELECT SQL query.
2. Iterate Through Results: Use ResultSet.next() to move to each row.
3. Retrieve Data: Use methods like getString() or getInt() to get column values.
4. Process Results: Display or process the retrieved data.
31. Interpret the different types of Java DataBase Connectivity (JDBC) statements?
Provide examples of when each type should be used.
Types of JDBC Statements:
1. Statement:
o Executes static SQL queries without parameters.
o Use: For one-time queries without dynamic input. Example:
stmt.executeQuery("SELECT * FROM users");
 2. PreparedStatement:
o Executes precompiled SQL queries with placeholders for parameters.
o Use: For dynamic queries, improving performance and security. Example:
PreparedStatement ps = conn.prepareStatement("SELECT * FROM users
WHERE id = ?");
3. CallableStatement:
o Executes stored procedures or functions.
o Use: When calling stored procedures in a database. Example: CallableStatement
cs = conn.prepareCall("{call getUserById(?)}");

32. Show how can transactions be handled in Java DataBase Connectivity (JDBC) to
ensure atomicity? Illustrate with an example of a transaction in JDBC.
Handling Transactions in JDBC for Atomicity
1. Disable Auto-commit: Turn off auto-commit to manage transactions manually.
2. Begin Transaction: Start a transaction by executing queries.
3. Commit: If all queries are successful, commit the transaction to save changes.
4. Rollback: If an error occurs, rollback to undo changes.
Note: Transaction in Java ensures atomicity(indivisibility) by grouping multiple database
operations.
33. Summarize SQLException, and how is it handled in Java DataBase Connectivity
(JDBC)?
SQLException in JDBC
1. Definition: SQLException is an exception in JDBC that indicates a database-related error
during query execution or connection issues.
2. Causes: It occurs due to invalid queries, database unavailability, connection problems, or
incorrect SQL syntax.
3. Handling:
o Use try-catch blocks to catch SQLException.
o Retrieve detailed information using methods like getMessage(), getSQLState(),
and getErrorCode().
4. Example: SQLException can be thrown when running an invalid query, and you can
handle it with appropriate error messages for debugging.
34. Show JDBC-ODBC Bridge driver working, and why is it deprecated?
JDBC-ODBC Bridge Driver
1. Working:
o The JDBC-ODBC Bridge driver translates JDBC calls into ODBC calls.
o It connects Java applications to databases via ODBC (Open Database
Connectivity).
2. Why Deprecated:
o Performance Issues: The JDBC-ODBC Bridge introduces overhead and is slow.
o Platform Dependency: Requires ODBC drivers, limiting portability.
o Security Risks: The bridge exposes Java applications to potential security
vulnerabilities.
o No Longer Supported: It was removed in Java 8 and is no longer recommended
for modern applications.

35. Outline the purpose of the "DriverManager" class in Java DataBase Connectivity
(JDBC), and how does it manage database connections?
Purpose of DriverManager Class in JDBC:
1. Manages Database Drivers:
o It maintains a list of database drivers that can be used to establish a connection.
2. Establishes Connections:
o Uses the getConnection() method to create a connection to the database by
selecting the appropriate driver.
3. Driver Selection:
o It chooses the most suitable driver from the registered ones based on the
connection URL.
4. Registration of Drivers:
o Drivers are automatically loaded using Class.forName() or manually registered
via DriverManager.registerDriver().
DriverManager manages database connections by selecting an appropriate driver,
establishing the connection using the provided credentials, and returning a connection
object.
36. Explain the difference between java.sql and javax.sql packages. In what scenarios
would you use each?

 Use java.sql: When you need to execute SQL queries or updates directly without needing
advanced connection management.
 Use javax.sql: When you require features like connection pooling or handling multiple data
sources in large-scale applications.
37. Choose the primary difference between Swing and AWT in Java.

Swing provides a more flexible, customizable, and modern approach to GUI, while AWT
focuses on simplicity and is bound to the platform’s native look and feel. AWT stands
for Abstract Window Toolkit
38. Identify the three features of Java Swing and explain how they contribute to the
development of platform-independent Graphical User Interface(GUI) applications.
Three Features of Java Swing for Platform-Independent GUI Development:
1. Lightweight Components: Swing components are not tied to native OS components,
making them platform-independent and ensuring a consistent look and feel across
different platforms.
2. Customizable Look and Feel: Swing allows developers to customize the appearance,
including themes, which ensures applications can have a uniform look on any platform.
3. Event Handling: Swing uses a flexible event model, providing more control over user
interactions, ensuring reliable and consistent handling of GUI events across platforms.
Note: Native refers to components or applications designed for a specific platform, while
traditional often refers to older, established methods or designs.

39. Make use of the Model-View-Controller (MVC) architecture apples to Swing

components? Provide an example.
Model-View-Controller (MVC) in Swing
1. Model: Represents application data and business logic (e.g., a class that handles data).
2. View: Displays the data (Swing components like JFrame, JTextField).
3. Controller: Handles user input and updates the model or view (ActionListeners).
Example:
40. Choose the purpose of a JFrame in Java Swing, and how do you create one?
Purpose of JFrame in Java Swing:
1. Window Frame: JFrame is the top-level container for a Swing application.
2. GUI Layout: It holds other Swing components (e.g., buttons, labels, panels).
3. Event Handling: Manages events like window closing, resizing, etc.
4. Display Window: Creates a visible window for users to interact with the application.
Steps to Create a JFrame:
1. Import Swing Libraries: Import javax.swing.*.
2. Create a JFrame Object: JFrame frame = new JFrame("Title");
3. Set Frame Properties: frame.setSize(400, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
4. Make Visible: frame.setVisible(true);

41. Build the function of the "FlowLayout" layout manager in Java Swing. Provide an
example where it might be useful.
Function of "FlowLayout" in Java Swing:
1. Component Arrangement: Places components in a row, adjusting automatically to fit
the container width.
2. Wrap Around: If components exceed container width, they wrap to the next line.
3. Alignment: Supports left, center, or right alignment of components.
4. Flexibility: Automatically adjusts based on container size, making it ideal for dynamic
layouts.
Example Use Case:
Useful for forms or toolbars where components need to be arranged sequentially, and wrapping
is required when the container size changes.
Example Code:
42. Identify the differences between JDialog and JFrame in Java Swing. Provide a use case
for each.
Use Cases:
 JFrame: Used as the main window for an application, like an editor or browser.
 JDialog: Used for smaller windows like "About," error messages, or file selection
dialogs.
43. Construct a button click event in Java Swing with code.
Steps for Creating a Button Click Event in Java Swing:
1. Create a JFrame: Create a window that holds components.
2. Add a JButton: Add a button to the frame.
3. Add an ActionListener: Attach an ActionListener to the button.
4. Define the ActionPerformed method: Specify what happens when the button is clicked.
Example Code:
44. Choose and explain the key components of a JMenu in Java Swing, and how would you
implement a simple menu.
Key Components of a JMenu in Java Swing:
1. JMenuBar: A container for menus.
2. JMenu: A single menu that can contain menu items.
3. JMenuItem: Represents an item in a menu.
4. JSeparator: Used to separate menu items visually.
Steps:
1. Create a JMenuBar to hold the menus.
2. Create a JMenu for each menu category (e.g., "File").
3. Add JMenuItems to the menu.
4. Add the menu to the JMenuBar.
5. Attach the JMenuBar to the frame and display it.
Examples:

45. Build exception handling in Java Swing applications? how would you handle a
NullPointerException in a Swing app.
In Java Swing, exception handling is done using try-catch blocks. To handle a
NullPointerException, wrap the code that may cause the exception inside a try block. If the
exception occurs, it’s caught in the catch block, allowing the app to recover gracefully instead of
crashing.
Example:
Explanation:
The code safely handles the NullPointerException and prevents crashes.
46. Identify the advantages of using NetBeans and Eclipse for Swing development. Which
Integrated Development Environement(IDE) would you choose for a simple Graphical
User Interface(GUI) application and why?
Advantages of NetBeans:
 Built-in Swing components, simplifying development.
 GUI builder allows for easy drag-and-drop design.
 Automatic code generation for UI elements.
 Cross-platform support.
 User-friendly with real-time error checking.
Advantages of Eclipse:
 Strong plugin ecosystem, supporting various languages and frameworks.
 Customizable workspace for tailored development experience.
 Advanced debugging tools for efficient problem-solving.
 Integrated version control with Git.
 Robust community and support.
IDE Choice:
For simple GUI development, NetBeans is ideal due to its powerful Swing GUI builder, quick
setup, and beginner-friendly interface.

47. Make use of the function "Jpanel" container in Swing. Provide an example scenario
where it is used.
JPanel in Swing is a container that holds and organizes components in a graphical user interface
(GUI). It allows grouping of elements, enabling better layout management and modular UI
development.
Example Scenario:
A JPanel can be used to group buttons or text fields in a login form. By using JPanel, you can
organize the UI components into sections, such as placing the login inputs in one panel and
action buttons in another.
Code Example:
48. Develop how the "BoxLayout" layout manager works in Java Swing.

The BoxLayout layout manager in Java Swing arranges components either vertically (along the
Y-axis) or horizontally (along the X-axis). It is useful when you need to align components in a
single direction, creating a simple, organized layout.
 Horizontal Layout: Places components side by side.
 Vertical Layout: Stacks components on top of each other.
Example:

49. Build and explain the mapping in Hibernate.

Hibernate Mapping connects Java objects (POJOs) with database tables. It allows the ORM
(Object-Relational Mapping) process, enabling automatic data persistence. The key components
are:
1. XML Mapping: Mapping files (e.g., .hbm.xml) define the relationship between Java
classes and database tables.
2. Annotations: Use annotations like @Entity, @Table, @Id, etc., to map Java classes to
database tables directly.
3. Primary Key: Mapped using @Id or <id> in XML for unique identification.
Hibernate handles data translation between objects and relational databases seamlessly.

50. Identify the annotation is used in Hibernate to represent a one-to-one relationship

between two entities.
In Hibernate, the annotation used to represent a one-to-one relationship between two entities is
@OneToOne. This annotation is applied to a field in one entity class to map it to another entity
class, indicating that each instance of the first entity corresponds to exactly one instance of the
second entity.
Example:
This creates a one-to-one mapping between Employee and Address.
51. Identify the annotation in Hibernate is used to represent a many-toone relationship.
In Hibernate, the annotation used to represent a many-to-one relationship between two entities is
@ManyToOne. This annotation is applied to a field in the child entity class, which maps to the
parent entity, indicating that many instances of the child entity can be associated with one
instance of the parent entity.
Example:

This creates a many-to-one mapping between Order and Customer.

52. Select the difference between one-to-one and many-to-one mapping in Hibernate.
53. Identify the role of @JoinColumn in Hibernate's one-to-one and many-to-one
mappings.
The @JoinColumn annotation in Hibernate is used to specify the column that links two entities
in a one-to-one or many-to-one relationship. It defines the foreign key column in the database
that will hold the reference to the related entity. In a one-to-one mapping, it is used to associate
one entity with another using a unique foreign key, while in a many-to-one mapping, it connects
many instances to a single entity.

54. Choose how the mappedBy attribute used in Hibernate's one-to-many mapping.
In Hibernate, the mappedBy attribute is used in one-to-many relationships to indicate the inverse
side (child) of the relationship. It references the field in the parent class that owns the
relationship, defining the direction of the association.

55. Construct the Hibernate annotation code for a many-to-many relationship between
Student and Course.
Explanation:
 @ManyToMany: Defines the relationship between Student and Course.
 @JoinTable: Specifies the join table student_course.
 mappedBy: Identifies the inverse side of the relation in Course.
56. Experiment with the given scenario where an employee works for one department but
multiple employees work for the same department, create the necessary Hibernate
annotations.

 @OneToMany(mappedBy = "department"): Defines department’s employee list.

 @ManyToOne: Indicates employees belong to a department.
 @JoinColumn(name = "department_id"): Establishes foreign key.
57. Build a simple Hibernate mapping for a one-to-one relationship between Author and
Book, where each author can have only one book.

 @OneToOne(mappedBy = "author"): Defines the one-to-one relationship in

Author.
 @JoinColumn(name = "author_id"): Foreign key in Book to reference the author.
 mappedBy: Indicates that Author is the inverse side of the relationship.
58. Identify the role of @JoinColumn in Hibernate's one-to-one and many-to-one
mappings.@JoinColumn specifies the foreign key column in the child entity, linking it to
the parent entity in one-to-one and many-to-one relationships.

In Hibernate, @JoinColumn specifies the foreign key column in the child entity that links it to the parent
entity in both one-to-one and many-to-one relationships. It defines the column that references the primary
key of the parent entity.

Key Points:

 @JoinColumn(name = "department_id") creates the foreign key linking Employee to

Department.
 @ManyToOne defines the relationship from the child ( Employee) side.

59. Apply the correct mapping approach, given the entity classes Product and Category,
where each product can belong to multiple categories, and each category can have multiple
products.
Use @ManyToMany with @JoinTable for the relationship between Product and Category,
specifying join columns and inverse join columns.
Example:

 @ManyToMany: Defines the many-to-many relationship between Product and

Category.
 @JoinTable: Specifies the join table to manage the relationship.
 mappedBy: Indicates the inverse side of the relationship in the Category class.
60. Develop and build the model using hibernate annotation, if a department can have
many employees but an employee can only belong to one department.

This mapping uses @OneToMany on the Department class and @ManyToOne on the Employee
class to represent a one-to-many relationship. The @JoinColumn annotation establishes the
foreign key from Employee to Department.