Introduction to java programming

Previous year 2022 solution

1. Choose the correct answer of any seven of the following :

(a). What is truncation in java?
(i) Floating-point value assigned to an Integer type.
(ii)Integer value assigned to a floating type.
(iii)Floating-point value assigned to a floating type.
(iv)Floating-point value assigned to an Integer type.

Correct Answer-: option (iii)

(b) Which of these is an incorrect array declaration?
(i) int arr[ ] = new int[5]
(ii) int [ ] arr = new int[5]
(iii) int arr[ ] = int[5] new
(iv) None of the above

Correct Answer-: option (iii)

(c) What is true about a break?
(i) Break stops the execution of the entire program.
(ii) Break halts the execution and forces the control
out of the loop.
(iii) Break forces the control out of the loop and starts
the execution of next iteration.
(iv) Break halts the execution of the loop for certain
time frame.
Correct Answer-: option (ii)
(d) When method overloading is determined?
(i) At run time
(ii) At compile time
(iii) At coding time
 (iv) At execution time

Correct Answer-: option (ii)

(e) Which method can be defined only once in a program?
(i) Main method
(ii) Finalize method
(iii) Static method
(iv) Private method

Correct Answer-: option (i)

(f) Which of these is used to access a member of class before
object of that class is created?
(i) Public
(ii) Private
(iii) Static
(iv) Protected

Correct Answer-: option (iii)

(g) All classes in java are inherited from which class?

(i) [Link]
(ii) [Link]
(iii) [Link]
(iv) [Link]

Correct Answer-: option (iv)

(h) Which of these packages contains all the java’s built in

exceptions?
(i) [Link]
(ii) [Link]
(iii) [Link]
(iv) [Link]
Correct Answer-: option (iii)
(i) Which of the following is a superclass of all exception-type
classes?
(i) Catchable
(ii) Run-time exception
(iii) String
(iv) Throwable

Correct Answer-: option (iv)

(j) What should not be done to avoid deadlock?

(i) Avoid using multiple threads

(ii) Avoid hold several locks at once
(iii) Execute foreign code while holding a lock
(iv) Use interruptible locks

Correct Answer-: option (i)

2(a) List some important features of java programming languages. How

does Java provide better application development environment than C++ ?
Ans:- There are the following important features of java programming.
1. Platform Independence: Java programs are compiled into bytecode,
which is platform-independent and can be executed on any platform with
a compatible Java Virtual Machine (JVM).
2. Object-Oriented: Java is a pure object-oriented programming language,
promoting good software engineering practices and code reusability.
3. Automatic Memory Management: Java provides automatic memory
management through garbage collection, reducing the risk of memory
leaks and simplifying memory management for developers.
 4. Strong Standard Library: Java includes a rich standard library with
packages for various tasks, such as I/O, networking, data structures, and
more, making it easier to develop applications.
5. Multi-threading: Java offers built-in support for multi-threading, allowing
developers to create multi-threaded applications easily, enhancing
concurrency and responsiveness.
6. Exception Handling: Java has a robust exception-handling mechanism,
making it easier to write code that can handle errors gracefully.
7. Security: Java includes a strong security model with features like
sandboxing for applets and fine-grained access controls, helping protect
against malicious code.

Java provides several advantages that can make it a better application development
environment compared to C++. Here are some of the ways Java excels:
1. Platform Independence: Java’s “write once, run anywhere” capability makes it highly
portable. Java code is compiled into platform-independent bytecode, which can be
executed on any platform with a compatible Java Virtual Machine (JVM). In contrast,
C++ code must be recompiled for different platforms, leading to platform-specific
binaries.
2. Automatic Memory Management: Java offers automatic memory management
through garbage collection. This helps prevent memory leaks and reduces the risk of
common memory-related bugs, which are more prevalent in C++ due to manual
memory management.
3. Object-Oriented: Both Java and C++ are object-oriented languages, but Java enforces
a stricter object-oriented model, promoting good software engineering practices and
code reusability.
4. Security: Java’s security model is robust, with features like sandboxing for applets
and fine-grained access controls, which help protect against potentially harmful
operations in untrusted code. C++ does not have built-in security features to the same
extent.

2(b) Discuss primitive data type supported by java with example?

Ans:- In Java, primitive data types are basic data types that represent simple
values like numbers, characters, and booleans. They are not objects and do not
have methods or properties like objects do. Java provides several primitive data
types, which include:

1. byte: This data type is an 8-bit integer that can store values from -128 to 127. It is often used
for efficient storage of small numbers.

For example: byte myByte = 100;

 2. short: This data type is a 16-bit integer that can store values from -32,768
to 32,767. It is commonly used when memory conservation is a concern.
For example: short myShort = 2000;

3. int: This is a 32-bit integer data type that can store values from -
2,147,483,648 to 2,147,483,647. It’s one of the most commonly used data
types for storing whole numbers.
For example: int myInt = 50000;

4. long: This data type is a 64-bit integer that can store very large whole numbers. It is used when
you need to represent extremely large numbers.

For example: long myLong = 1000000000L; // Note the ‘L’ suffix to indicate a long literal

5. float: This is a 32-bit floating-point data type that can store decimal
numbers with single-precision.
For example: float myFloat = 3.14159f; // Note the ‘f’ suffix to indicate a float literal

6. double: This is a 64-bit floating-point data type that can store decimal
numbers with double-precision. It is often used for more accurate and larger
floating-point numbers.
For example: double myDouble = 3.14159265359;

7. char: This data type is used to store a single 16-bit Unicode character.
For example: char myChar = ‘A’;

8. boolean: This data type represents a binary value, either true or false. It is
often used for conditional statements and logic.
For example: boolean isJavaFun = true;

3(a) Create a class student to represent the students of a class. Include the
following members :
Data members : Roll Number, Name of the student, Address, Branch,
Marks
Methods : To assign initial values, To display the particulars of a student,
To update the marks of a student appropriately assume any required
information yourself.

Ans:-
class Student {
int roll;
String name;
String address;
String branch;
 double marks;

// Constructor to assign initial values

Student(int roll, String name, String address, String branch, double marks) {
[Link] = roll;
[Link] = name;
[Link] = address;
[Link] = branch;
[Link] = marks;
}

// Method to display the particulars of a student

public void display() {
[Link](“Student Roll Number: “ + roll);
[Link](“Student Name: “ + name);
[Link](“Student Address: “ + address);
[Link](“Student Branch: “ + branch);
[Link](“Student Marks: “ + marks);
}

// Method to update the marks of a student

public void updateMarks(double newMarks) {
marks = newMarks;
[Link](“Marks updated successfully for “ + name + “ (Roll Number: “ + roll
+ “)”);
}
}

public class demo1 {

public static void main(String[] args) {
Student student1 = new Student(101, “Deepak Kumar”, “Aurangabad”, “Computer
Science”, 85.5);
Student student2 = new Student(102, “Suraj Kumar”, “Dehri”, “Computer Science”,
78.0);
 // Display student details
[Link](“Student Details:”);
[Link](“*****************”);
[Link]();
[Link](“\n”);
[Link]();
[Link](“\n”);

// Update marks for a student

[Link](90.0);
[Link](“\n”);

// Display updated student details

[Link](“Updated Student Details:”);
[Link](“**********************”);
[Link]();
}
}
Output

3(b) What are the advantages of Java multithreading? Explain with

example.
Ans:- Some of the key advantages of Java multithreading include:
 1. Parallelism: Multithreading allows multiple threads to execute in parallel, utilizing
multiple CPU cores if available. This can significantly improve the performance of
CPU-bound tasks.
2. Responsiveness: Multithreading can be used to keep the user interface of an
application responsive while performing time-consuming tasks in the background.
This is crucial for providing a smooth user experience in applications with graphical
user interfaces.
3. Efficient Resource Utilization: Multithreading helps in efficient utilization of system
resources, as it enables better use of CPU and memory resources by allowing tasks to
run concurrently.
4. Scalability: Multithreading enables scalable applications. By dividing tasks into
threads, you can easily adapt your application to different hardware configurations or
processing loads.
5. Improved Throughput: In I/O-bound applications, multithreading can significantly
improve throughput. When one thread is waiting for I/O, other threads can continue
processing, preventing the CPU from idling.
6. Simplified Code: Multithreading can make code more modular and easier to
understand. You can divide a complex task into smaller, manageable threads, each
responsible for a specific part of the task.
7. Asynchronous Programming: Multithreading supports asynchronous programming,
which is essential for tasks like network communication and handling multiple clients
simultaneously. Asynchronous tasks can run concurrently without blocking the main
application thread.

Example of java multithreading:-

public class FactorialCalculator extends Thread {
private int number;
public FactorialCalculator(int number) {
[Link] = number;
}
public void run() {
long factorial = 1;
for (int i = 1; i <= number; i++) {

factorial *= i;

}
[Link](“Factorial of “ + number + “ is “ + factorial);

public static void main(String[] args) {

FactorialCalculator thread1 = new FactorialCalculator(5);

FactorialCalculator thread2 = new FactorialCalculator(10);

 [Link]();
[Link]();

}
}
In this example, two threads are used to calculate the factorial of 5 and 10 concurrently, making use
of parallelism to improve performance.

4(a) What are different types of inheritance in java? Also write program to
demonstrate multiple inheritance using interfaces.

Ans:- Java supports the following four types of

inheritance:
o Single Inheritance
o Multi-level Inheritance
o Hierarchical Inheritance
o Hybrid Inheritance

Single Inheritance :- In single inheritance, a sub-class is derived from only

one super class. It inherits the properties and behaviour of a single-parent
class. Sometimes it is also known as simple inheritance.

o In the above figure, Employee is a parent class and Executive is a child

class. The Executive class inherits all the properties of the Employee class.
Multi-level Inheritance

In multi-level inheritance, a class is derived from a class which is also derived from another class is
called multi-level inheritance. In simple words, we can say that a class that has more than one parent
class is called multi-level inheritance. Note that the classes must be at different levels. Hence, there
exists a single base class and single derived class but multiple intermediate base classes.

In the above figure, the class Marks inherits the members or methods of the class Students. The class
Sports inherits the members of the class Marks. Therefore, the Student class is the parent class of
the class Marks and the class Marks is the parent of the class Sports. Hence, the class Sports
implicitly inherits the properties of the Student along with the class Marks.

Hierarchical Inheritance

If a number of classes are derived from a single base class, it is called hierarchical inheritance.
In the above figure, the classes Science, Commerce, and Arts inherit a single parent class named
Student.

Hybrid Inheritance

Hybrid means consist of more than one. Hybrid inheritance is the combination of two or more types
of inheritance.

In the above figure, GrandFather is a super class. The Father class inherits the properties of the
GrandFather class. Since Father and GrandFather represents single inheritance. Further, the Father
class is inherited by the Son and Daughter class. Thus, the Father becomes the parent class for Son
and Daughter. These classes represent the hierarchical inheritance. Combinedly, it denotes the
hybrid inheritance.
Program for Multiple Inheritance :-
interface Swimmer {
void swim();

}
interface Flyer {
void fly();

}
class Bird implements Swimmer, Flyer {
public void swim() {
[Link](“Bird is swimming.”);

}
public void fly() {
[Link](“Bird is flying.”);

}
}
class MultipleInheritance {
public static void main(String[] args) {
Bird b1 = new Bird();
[Link]();
[Link]();

}
}
Output
4(b) Give the detailed explanation of packages in java.
Ans:- Packages in Java are a way to organize and group related classes, interfaces, and sub-
packages into a single unit. They serve several purposes, such as managing class names to
prevent naming conflicts, providing access control, and aiding in code organization and
maintenance. Below is a detailed explanation of packages in Java:

1. Organization and Namespace Management: Packages help organize Java classes

and interfaces into a hierarchical structure. The package name forms a part of the fully
qualified class name, ensuring that class names are unique to avoid naming conflicts.
For example, if two developers create classes with the same name but in different
packages, there won’t be any conflicts.
2. Access Control: Packages provide a level of access control. You can specify access
modifiers like public, protected, or package-private (default) for classes and
members within a package. This allows you to control the visibility and access of
classes and members to other classes within or outside the package.
3. Code Reusability: Packages facilitate code reusability. You can create a library of
related classes within a package and reuse them in multiple projects. When you want
to use the classes from that library, you can simply import the package into your code.
4. Encapsulation: Packages support encapsulation by allowing you to hide the
implementation details of classes within a package. You can mark classes or members
as package-private, limiting their access to classes within the same package and
encapsulating their functionality.
5. Maintenance and Organization: Packages help in structuring your code logically,
making it easier to understand and maintain. By categorizing classes into related
packages, you can quickly locate and modify code when needed.
6. Java Standard Library: The Java Standard Library itself is organized into packages.
For example, classes related to I/O operations are in the [Link] package, and classes
for user interface components are in packages like [Link]. This organization
helps developers easily locate and use the built-in Java API.

Here’s how you define and use packages in Java:

 Creating a Package: You define a package at the beginning of your Java source file
using the package statement.
For example :- package [Link];
Importing Classes : To use classes from another package, you can use the import statement at
the top of your Java source file.
For example:- import [Link];
 Accessing Classes: You can access classes from the same package without using the
import statement. Classes within the same package are automatically accessible.
 JAR Files: You can bundle classes in packages into JAR (Java Archive) files, which
makes it easier to distribute and reuse code.
 Naming Conventions: It’s a good practice to use reverse domain names to name your
packages, e.g., [Link]. This helps ensure that your package names are
globally unique.
5(a) Explain the concept of streams in java and discuss the classifications of
java stream classes. Also write a program to copy the content of one text
file to another.
Ans:- A stream can be defined as a sequence of data. The InputStream is used to read data
from a source and the OutputStream is used for writing data to a destination. InputStream and
OutputStream are the basic stream classes in Java.

Types of streams:
 Byte Stream : It provides a convenient means for handling input and output of byte.
 Character Stream : It provides a convenient means for handling input and output of
characters. Character stream uses Unicode and therefore can be internationalized.

1. Byte Stream:
Byte Stream Classes are used to read bytes from an input stream and write bytes to an output
stream.

 InputStream Classes - These classes are subclasses of an abstract class, InputStream and they
are used to read bytes from a source(file, memory or console).
 OutputStream Classes - These classes are subclasses of an abstract class, OutputStream and
they are used to write bytes to a destination(file, memory or console).
2. Character Stream:
Character stream is also defined by using two abstract classes at the top of the hierarchy, they
are Reader and Writer. These two abstract classes have several concrete classes that handle
Unicode characters.

 Reader classes : Abstract class that define character stream input.

 Writer classes : Abstract class that define character stream output.
 Write a program to copy the content of one text file to another.

import [Link];
import [Link];
import [Link];
import [Link];
public class FileCopyExample {
public static void main(String[] args) {
Path sourceFile = [Link](“[Link]”);
Path targetFile = [Link](“[Link]”);
try {
[Link](sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING);
[Link](“File copied successfully.”);
} catch (IOException e) {
[Link]();

}
}
}

6.(a) What is string handling? Write a program to append two strings in

java.
Ans:- String handling in Java refers to the manipulation, creation, and
management of string data. Strings are sequences of characters, and string
handling involves various operations such as concatenation, searching,
comparing, and formatting. In Java, strings are treated as objects of the
[Link] class, and there are various methods and operators available
for performing string operations.

Here’s a simple Java program to append two strings using the + operator, which
is used for string concatenation:
public class Append {
public static void main(String[] args) {
String firstString = “Deepak “;
String secondString = “Kumar”;
[Link](“First String = “ + firstString);
[Link](“Second String = “ + secondString);
String result = firstString + secondString;
[Link](“Result: “ + result);
}
}

t
6.(b) Explain exception handling model using try, catch and finally block.
Also write a program using multiple catch blocks and finally block.
Ans:- Exception handling in Java is a mechanism for dealing with runtime
errors and exceptional conditions that may occur during the execution of a
program. The primary components of Java’s exception handling model are the
try, catch, and finally blocks. These blocks are used to handle and manage
exceptions gracefully, preventing the program from crashing due to unexpected
errors. Here’s an explanation of each block in the exception handling model:

1. try Block:

 The try block encloses a section of code where exceptions may occur. This code is known as
the “guarded code.”
 When an exception is thrown within the try block, the control is transferred to the nearest
catch block that can handle that exception.
 You can have multiple try blocks in your code to isolate different sections that may
generate exceptions.

2. catch Block:
  The catch block follows the try block and is used to catch and handle exceptions.
 Each catch block can catch and handle a specific type of exception. You can have multiple
catch blocks for different exception types.
 When an exception occurs in the try block, the JVM searches for the appropriate catch
block to handle that exception. If a matching catch block is found, the code within that
block is executed.

3. finally Block:
 The finally block is optional and is placed after the catch block(s).
 The code within the finally block is executed regardless of whether an exception was
thrown or not. It is typically used for cleanup and resource release operations.
 Even if an exception is thrown and caught, the code in the finally block will still execute.

A program using multiple catch blocks and finally block.

public class exception {
public static void main(String[] args) {
try {
int numbers[] = { 1, 2, 3 };
int result = divide(numbers, 0);
[Link](“Result: “ + result);
} catch (ArithmeticException e) {
[Link](“ArithmeticException: “ + [Link]());

} catch (ArrayIndexOutOfBoundsException e) {

[Link](“ArrayIndexOutOfBoundsException: “ + [Link]());

} finally {

[Link](“Inside the finally block (cleanup code).”);

}
}
public static int divide(int[] numbers, int index) {
try {
 int result = numbers[0] / index; // May throw ArithmeticException
return result;

} catch (ArithmeticException e) {

throw e;

} catch (ArrayIndexOutOfBoundsException e) {

throw e;
}
}
}
7.(a) Write a program in java to find nth prime number where n is any
integer and should be taken as input from the user.
Ans:-
import [Link];
class prime {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
[Link](“Enter the value of n to find the nth prime number: “);
int n = [Link]();
if (n < 1){
[Link](“Please enter a positive integer for n.”);
return;
}
int primeNumber = find(n);
[Link](“The “ + n + “th prime number is: “ + primeNumber);
}
public static int find(int n) {
if (n == 1) {
return 2;
}
int count = 1; // Start with the first prime number, 2
int number = 3; // Check odd numbers starting from 3
while (count < n) {
if (isPrime(number)) {
count++;
if (count == n) {
return number;
}
}
number += 2; // Move to the next odd number
}
return -1; // This should not happen for a reasonable value of n
}
 public static boolean isPrime(int number) {
if (number <= 1) {
return false;
}
for (int i = 2; i <= [Link](number); i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
}

Output
7.(b) What are wrapper classes? Explain the same with examples.
Ans:- In Java, a wrapper class is a class that encapsulates the primitive data
types (e.g., int, char, boolean, etc.) and provides methods for working with
them as objects. The primary purpose of wrapper classes is to enable primitive
data types to be used in situations that require objects, such as in collections
(like ArrayList and HashMap) or when working with Java generics.

There are eight standard wrapper classes in Java, each corresponding to a specific primitive data
type:
1. Integer: Wraps int.
2. Long: Wraps long.
3. Double: Wraps double.
4. Float: Wraps float.
5. Character: Wraps char.
6. Boolean: Wraps boolean.
7. Byte: Wraps byte.
8. Short: Wraps short.

Class demo
{
public static void main(String args[])
{
Integer obj1=[Link](200); // Create object wrapper class
Float obj2=[Link](23.00); // Create object wrapper class
int a=[Link](); // Convert wrapper object into primitive variable
float b=[Link](); // Convert wrapper object into primitive variable
[Link](a);
[Link](b);
[Link](obj1);
 [Link](obj2);
}
}

8.(a) Explain the JDBC connectivity with an example.

Ans:- Java Database Connectivity (JDBC) is a Java-based API for connecting
and interacting with relational databases. It allows Java applications to
communicate with databases to perform various operations like querying,
updating, inserting, and deleting data. JDBC provides a standardized way to
connect to databases, regardless of the database management system (DBMS)
being used.
Here's an example of how to establish a JDBC connection and execute a simple
SQL query in Java:
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class JDBCDemo {

public static void main(String[] args) {
// JDBC URL, username, and password of the database
String jdbcUrl = "jdbc:mysql://localhost:3306/mydb"; // JDBC URL for a MySQL
database
String username = "your_username";
String password = "your_password";

// Establish a connection to the database

try {
Connection connection = [Link](jdbcUrl, username,
password);
 // Create a statement for executing SQL queries
Statement statement = [Link]();

// Define an SQL query

String sqlQuery = "SELECT * FROM employees";

// Execute the query and get the result set

ResultSet resultSet = [Link](sqlQuery);

// Iterate through the result set and print data

while ([Link]()) {
int empId = [Link]("employee_id");
String empName = [Link]("employee_name");
double empSalary = [Link]("employee_salary");

[Link]("Employee ID: " + empId);

[Link]("Employee Name: " + empName);
[Link]("Employee Salary: " + empSalary);
}

// Close the result set, statement, and connection

[Link]();
[Link]();
[Link]();
} catch (SQLException e) {
[Link]();
}
}
}
8.(b) Explain the life cycle of an applet. How are applets added to
HTML? Discuss with the help of an example.

Ans:- The applet life cycle can be defined as the process of how the object is created,
started, stopped, and destroyed during the entire execution of its application. It
basically has five core methods namely init(), start(), stop(), paint() and destroy().These
methods are invoked by the browser to execute.

Along with the browser, the applet also works on the client side, thus having less
processing time.

There are five methods of an applet life cycle, and they are:

o init(): The init() method is the first method to run that initializes the applet. It can be
invoked only once at the time of initialization.
o start(): The start() method contains the actual code of the applet and starts the applet.
It is invoked immediately after the init() method is invoked. Every time the browser is
loaded or refreshed, the start() method is invoked.
o stop(): The stop() method stops the execution of the applet. The stop () method is
invoked whenever the applet is stopped, minimized, or moving from one tab to
another in the browser, the stop() method is invoked. When we go back to that page,
the start() method is invoked again.
o destroy(): The destroy() method destroys the applet after its work is done. It is invoked
when the applet window is closed or when the tab containing the webpage is closed.
It removes the applet object from memory and is executed only once. We cannot start
the applet once it is destroyed.
o paint(): The paint() method belongs to the Graphics class in Java. It is used to draw
shapes like circle, square, trapezium, etc., in the applet. It is executed after the start()
method and when the browser or applet windows are resized.
Methods of Applet Life Cycle

There are the following steps to add applets into HTML.

Create a Java applet source code file (e.g., [Link]) that defines the
applet's behaviour. Here's a simple "Hello World" applet:

import [Link];
import [Link];

public class MyApplet extends Applet {

public void paint(Graphics g) {
[Link]("Hello, Applet!", 50, 25);
}
}

2. Compile the Applet:

Compile the Java source code to create a bytecode file using a Java compiler
(e.g., javac).

javac [Link]
 3. Create an HTML File:

Create an HTML file (e.g., applet_example.html) and include the following

code to embed the applet:

<!DOCTYPE html>
<html>
<head>
<title>Java Applet Example</title>
</head>
<body>
<applet code="[Link]" width="300" height="100">
Your browser does not support Java applets.
</applet>
</body>
</html>

In this HTML code:

 The <applet> element is used to embed the applet.

 The code attribute specifies the name of the applet's main class, which
should match the name of your compiled .class file.
 The width and height attributes define the dimensions of the applet's
display area.
 The content within the <applet> element is displayed if the browser
doesn't support Java applets.
 9. Write Short note on the following.
Ans:- (a) Polymorphism :- Polymorphism is one of the four fundamental
principles of object-oriented programming (OOP), and it's a key concept in
Java. It allows objects of different classes to be treated as objects of a common
superclass. In Java, polymorphism is achieved through method overriding and
method overloading. There are two types of polymorphism in Java:

1. Compile-time Polymorphism (Static Binding): This is also known as

method overloading. It occurs when multiple methods in the same class
have the same name but different parameters (different method
signatures). The appropriate method to be called is determined at
compile-time based on the method signature.

2. Run-time Polymorphism (Dynamic Binding): This is achieved through

method overriding, and it allows a subclass to provide a specific
implementation of a method that is already defined in its superclass. The
decision of which method to execute is made at runtime, based on the
actual object type rather than the reference type.

(b) Relational operators:- Relational operators, also known as comparison

operators, are used in programming to compare values and determine relationships between
them. In Java and many other programming languages, relational operators are typically used
within conditional statements to make decisions and control the flow of a program.

Here are the common relational operators in Java:

1. Equal to (==): This operator checks if two values are equal. If the values are the
same, it returns true; otherwise, it returns false.
2. Not equal to (!=): This operator checks if two values are not equal. If the values are
different, it returns true; otherwise, it returns false.
3. Greater than (>): This operator checks if the value on the left is greater than the
value on the right. If it is, it returns true; otherwise, it returns false.
4. Less than (<): This operator checks if the value on the left is less than the value on
the right. If it is, it returns true; otherwise, it returns false.
5. Greater than or equal to (>=): This operator checks if the value on the left is greater
than or equal to the value on the right. If it is, it returns true; otherwise, it returns
false.
6. Less than or equal to (<=): This operator checks if the value on the left is less than
or equal to the value on the right. If it is, it returns true; otherwise, it returns false.
(c) Package :- In Java, a package is a way to organize and group
related classes, interfaces, and sub-packages together. Packages
provide a hierarchical structure for your Java code, making it
easier to manage and maintain large codebases. A package can
contain both class and interface definitions and can also include
sub-packages, forming a tree-like structure.
(d) Listener methods :- In Java, a listener method refers to a method
that is part of a listener interface, typically used in event-driven
programming. Listener methods are designed to respond to specific
events, such as user interactions or changes in state, by executing custom
code when those events occur. These methods are a fundamental part of
Java's event handling mechanism and are used in various frameworks and
libraries, including Swing for GUI applications and servlets in web
development.

Solved by deepak kumar