1 Discuss method overloading.

Write a program to overload a method

area() to compute area of a triangle and a circle.(2)
Method overloading in Java involves defining multiple methods
within the same class that share the same name, but have different parameter
lists1. This means the methods must differ in the type and/or number of
parameters they accept2. The return type alone is not enough to differentiate
overloaded methods2. When an overloaded method is called, Java uses the
type and number of arguments provided to determine which version of the
method to execute2.
Here's a Java program that demonstrates method overloading to calculate the
area of a triangle and a circle:
class Shape {
// Overloaded method to calculate the area of a
triangle
public double area(double base, double height) {
return 0.5 * base * height;
}

// Overloaded method to calculate the area of a

circle
public double area(double radius) {
return Math.PI * radius * radius;
}
}

public class AreaCalculator {

public static void main(String[] args) {
Shape shape = new Shape();

double triangleArea = shape.area(10, 5);

System.out.println("Area of triangle: " +
triangleArea);
 double circleArea = shape.area(7);
System.out.println("Area of circle: " +
circleArea);
}
}
In this program:
●
The Shape class has two methods named area.
●
One area method takes two double arguments (base and height) and
calculates the area of a triangle.
●
The other area method takes one double argument (radius) and
calculates the area of a circle.
●
In the AreaCalculator class's main method, a Shape object is created.
The area method is called with appropriate arguments to calculate the area
of a triangle and a circle, demonstrating method overloading.
2.What are various access specifiers in Java with example and
List out the behaviour of each of them.(2)
Access Specifiers in Java
Java uses access specifiers to control the visibility and accessibility of
classes, methods, and variables. They determine which parts of your code can
access and modify these elements. Here are the four access specifiers in Java:
1. Public
The public access specifier provides the widest scope of accessibility. A
public class, method, or variable can be accessed from any other class in the
same package or any other package in your Java project.
Example:
public class ExampleClass {

public int publicVariable = 10;

public void publicMethod() {

System.out.println("This is a public
method.");
}
}
Behavior:
●
Accessible from anywhere within the project.
2. Private
The private access specifier offers the most restrictive level of
accessibility. A private method or variable can only be accessed from within
the same class where it's declared. Private members are not visible or
accessible to any other classes, even subclasses.
Example:
public class ExampleClass {

private int privateVariable = 5;

private void privateMethod() {

 System.out.println("This is a private
method.");
}
}
Behavior:
●
Accessible only from within the same class.
3. Protected
The protected access specifier is primarily used in the context of
inheritance. A protected method or variable is accessible:
●
Within the same package where it's declared.
●
From subclasses, even if they are located in a different package.
Example:
public class ParentClass {

protected int protectedVariable = 8;

protected void protectedMethod() {

System.out.println("This is a protected
method.");
}
}
Behavior:
●
Accessible from the same package and from subclasses in any package.
4. Default (Package-Private)
When no access specifier is explicitly used, Java applies the default access,
which is also called package-private. A member with default access is:
●
Accessible from any class within the same package.
●
Not accessible from classes outside the package.
Example:
class ExampleClass { // No access specifier, so it's
default

int defaultVariable = 2; // Also default access

void defaultMethod() {
System.out.println("This is a method with
default access.");
}
}
Behavior:
●
Accessible only from within the same package.

3.Discuss usage of final keyword in Java. Give suitable examples

Usage of the Keyword in Java

The final keyword in Java is a powerful tool for creating constants,

preventing method overriding, and ensuring that classes cannot be
extended.

1. Final Variables: Creating Constants

When applied to a variable, the final keyword makes that variable a

constant. Once a final variable is initialized, its value cannot be changed. This
is particularly useful for defining values that should never be modified, such
as mathematical constants or configuration settings.

Example:
final int MAX_ATTEMPTS = 3;

final double PI = 3.14159;

In this example, MAX_ATTEMPTS and PI are declared as final variables,

making them constants. Any attempt to change their values after
initialization will result in a compile-time error. It's common practice to use
all uppercase identifiers for final variables.

Final variables can be initialized in two ways:

At declaration: You can assign a value to the final variable directly when
declaring it.

In a constructor: If the variable is an instance variable of a class, you can

initialize it within a constructor.

2. Final Methods: Preventing Overriding

When applied to a method, the final keyword prevents that method from
being overridden by subclasses. This can be useful for ensuring that a critical
method's behavior is not altered in subclasses, preserving the intended
functionality.

Example:

class BaseClass {

final void importantMethod() {

System.out.println("This method cannot be overridden.");

}
}

In this example, the importantMethod() is declared as final in the BaseClass.

Any attempt to override this method in a subclass derived from BaseClass
will result in a compile-time error.

Using final on methods can sometimes improve performance. The compiler

can inline calls to final methods since it knows they won't be overridden,
potentially eliminating the overhead of a method call.

3. Final Classes: Preventing Inheritance

When applied to a class, the final keyword prevents that class from being
extended. This is useful for creating classes that should not have subclasses,
ensuring that their implementation remains unchanged.

Example:

final class SecureClass {

// ...

In this example, SecureClass is declared as final, meaning no other class can

inherit from it. Any attempt to create a subclass of SecureClass will result in
a compile-time error

class Shape {

// Define PI as a final constant

final double PI = 3.14159;

// Method to calculate the area of a circle

 // This method is not final, so it can be overridden

double area(double radius) {

return PI * radius * radius;

class Circle extends Shape {

double area(double radius) {

return 2 * PI * radius * radius;

public class FinalDemo {

public static void main(String[] args) {

// The 'Shape' class cannot be extended because it is final

// final class Shape {

// // Class members

// }

Circle circle = new Circle();

 double area = circle.area(5);

System.out.println("Area of the circle: " + area);

4.What do you mean by method overriding? Discuss with a programming

example

Method Overriding Explained with an Example

Method overriding in Java occurs when a subclass provides a specific

implementation for a method that is already defined in its superclass. To
override a method, the following conditions must be met:

 The method in the subclass must have the same name as the method
in the superclass.
 The method in the subclass must have the same type signature (same
parameters and return type) as the method in the superclass.

When a method is overridden:

 The method in the subclass is said to override the method in the

superclass.
 When the overridden method is called through an object of the
subclass, it always refers to the version defined in the subclass.
 The version of the method defined by the superclass is hidden when
called through the subclass.

Here's a programming example from the sources that illustrates method

overriding:

// Method overriding.
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// display i and j
void show() {
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// display k – this overrides show() in A
void show() {
System.out.println("k: " + k);
}
}
class Override {
public static void main(String[] args) {
B subOb = new B(1, 2, 3);
subOb.show(); // this calls show() in B
}
}

In this example:

 Class B extends class A and inherits its members.

 Both classes have a method named show().
  The show() method in class B overrides the show() method in class
A because it has the same name and type signature.
 When subOb.show() is called, the output is "k: 3," indicating that
the show() method in the subclass B is executed, not the one in the
superclass A.

Important:

 If the method signatures are not identical (different parameters or

return type), then the methods are overloaded, not overridden. We
discussed method overloading in a previous conversation, and you can
find more examples in the sources.
 To access the superclass version of an overridden method, you can use
the keyword super.

Method overriding is a key concept in object-oriented programming and is

closely related to polymorphism. Polymorphism, which we've also discussed
previously, allows objects of different classes to be treated as objects of a
common superclass. Method overriding enables subclasses to provide their
own specific implementations of methods, while still adhering to the interface
defined by the superclass. This leads to more flexible and reusable code.

5. Demonstrate the working of interface in JAVA

Using Interfaces in Java

Interfaces in Java provide a way to achieve abstraction. They define a

contract that implementing classes must adhere to. This means an interface
specifies what methods a class should have, but it doesn't dictate how those
methods should be implemented. This promotes flexibility and modularity in
code design.

Here's a breakdown of key concepts related to interfaces in Java:

Defining an Interface: Interfaces are defined using the interface keyword.
They contain method signatures (declarations) without any implementation
details.

Implementing Interfaces: A class implements an interface using the

implements keyword. It must provide concrete implementations for all
methods declared in the interface.

Dynamic Method Dispatch: Interfaces support dynamic method dispatch,

which is a core concept of polymorphism. The actual method called is
determined at runtime based on the object's type, not the reference type.

Default Methods: Introduced in Java 8, default methods allow interfaces to

provide default implementations for methods. This helps in evolving
interfaces without breaking existing code.

Static Methods: Interfaces can also have static methods, which are called
using the interface name and don't require an object instance.

Private Interface Methods: Introduced in Java 9, private methods can be

used within an interface to share common code among default methods,
improving code organization.

Example: Demonstrating Interface Implementation

The sources provide an example of using an interface IntStack to define the

behavior of a stack data structure.

Interface Definition (IntStack.java):

interface IntStack {

void push(int item); // store an item

int pop(); // retrieve an item

}
Implementation (FixedStack.java):

class FixedStack implements IntStack {

private int[] stck;

private int tos;

FixedStack(int size) {

stck = new int[size];

tos = -1;

public void push(int item) {

// ... Implementation ...

public int pop() {

// ... Implementation ...

Usage (IFTest.java):

class IFTest {

public static void main(String[] args) {

 FixedStack mystack1 = new FixedStack(5);

// ... Use the stack ...

}
Here's a Java program demonstrating the working of an interface:

// Define the interface

interface Resizable {

void resizeWidth(int width);

void resizeHeight(int height);

// Implement the interface

class Rectangle implements Resizable {

private int width;

private int height;

public Rectangle(int width, int height) {

this.width = width;

this.height = height;

@Override

public void resizeWidth(int width) {

if (width > 0) {

this.width = width;

} else {

System.out.println("Invalid width. Width must be greater than 0.");

}
 }

@Override

public void resizeHeight(int height) {

if (height > 0) {

this.height = height;

} else {

System.out.println("Invalid height. Height must be greater than 0.");

public void display() {

System.out.println("Rectangle: Width = " + width + ", Height = " +

height);

// Main class to test the interface

public class Main {

public static void main(String[] args) {

Rectangle rectangle = new Rectangle(10, 20);

System.out.println("Original Rectangle:");

rectangle.display();
 // Resize the rectangle using the Resizable methods

rectangle.resizeWidth(15);

rectangle.resizeHeight(25);

System.out.println("Resized Rectangle:");

rectangle.display();

Explanation:

●The Resizable interface declares two methods: resizeWidth and

resizeHeight. These methods define the ability to resize an object's
dimensions.

●The Rectangle class implements the Resizable interface. It provides the

implementation details for the resizeWidth and resizeHeight methods. This
means a Rectangle object can be resized.

●In the Main class, a Rectangle object is created with initial dimensions. The
resizeWidth and resizeHeight methods (from the Resizable interface) are
called on the rectangle object to change its dimensions.

Key Points About Interfaces:

Interfaces cannot be instantiated directly. You need a class that implements

the interface to create objects.

●
A class can implement multiple interfaces, allowing it to inherit behavior
from different sources.

Interfaces can have default methods, providing default implementations for

methods. This allows you to add new methods to interfaces without
breaking existing code.

This program demonstrates the core principles of how interfaces work in

Java:

1.

Abstraction: The Resizable interface defines the concept of resizing without

specifying how it's done.

2.

Implementation: The Rectangle class provides the specific implementation

of resizing for a rectangle.

3.

Polymorphism: The rectangle object can be treated as both a Rectangle and

a Resizable object, showcasing polymorphism.

This example highlights how interfaces help in designing flexible and

maintainable Java code.
6.Write a note on: a. Extend keyword. b. Implement keyword. c. Private interface
methods d. Object Class e. Dynamic Method Dispatch

a. Extend Keyword: The extend keyword in Java is the foundation of

inheritance. It allows a new class, called a subclass, to inherit the
characteristics of an existing class, the superclass. This establishes a parent-
child relationship where the subclass "is a" type of the superclass.

●Consider a program from the sources that uses inheritance to model

different types of boxes:

In this example, the BoxWeight class extends the Box class. This means a
BoxWeight object possesses all the features of a Box object (width, height,
depth, and the volume() method) and additionally incorporates a weight
attribute. This showcases the "is-a" relationship: a BoxWeight is a type of
Box.

The extend keyword enables code reusability. Instead of rewriting the

attributes and logic for a box's dimensions, BoxWeight inherits them and
focuses solely on adding the weight aspect.

The sources explain that inheritance using extend plays a vital role in
creating multilevel hierarchies. In such scenarios, a class can inherit from a
superclass, which itself inherits from another class. The program illustrates
this by creating a Shipment class that extends BoxWeight, forming a three-
level hierarchy (Box -> BoxWeight -> Shipment).

b. Implement Keyword: While extend deals with inheriting from classes,

implement focuses on adhering to contracts defined by interfaces. An
interface specifies a set of methods that a class must implement. The class
provides the concrete implementation details for each method declared in
the interface. This mechanism facilitates achieving abstraction, where the
focus shifts to "what" a class should do rather than "how" it does it.

The sources illustrate this concept using an IntStack interface, which defines
the behavior of a stack data structure. The IntStack interface, presented
below, declares two methods: push for adding an element and pop for
retrieving and removing an element from the stack.

Then, a class named FixedStack implements this interface, providing the

specific implementation using a fixed-size array:

By using implement, the FixedStack class guarantees that it will provide

concrete implementations for both push and pop, ensuring it fulfills the
contract set by the IntStack interface.

c. Private Interface Methods: Starting from Java 9, interfaces can include

private methods. These methods are designed for internal use within the
interface. They can be called by default methods to share common code and
prevent redundancy but are not accessible from classes that implement the
interface.

The sources provide an example using the IntStack interface where two
default methods, popNElements and skipAndPopNElements, share a
common code segment:

Both popNElements and skipAndPopNElements rely on the private

getElements method to retrieve elements from the stack. This promotes
code reuse and maintains a clean structure within the interface.

d. Object Class: Sitting at the pinnacle of Java's class hierarchy is the Object
class. It's the ultimate ancestor, meaning every class you define in Java
automatically inherits from it, even if you don't explicitly use the extend
keyword. This inheritance grants all Java objects access to the methods
defined in the Object class. These methods include:
equals(Object obj): Used to compare the current object with another object
for equality.

hashCode(): Returns a hash code value for the object.

toString(): Provides a string representation of the object.

getClass(): Returns the runtime class of the object.

The sources emphasize that a reference variable of type Object can hold a
reference to an object of any other class. This universality stems from the
fact that Object is the superclass of all classes.

e. Dynamic Method Dispatch: Dynamic method dispatch is the mechanism

that brings polymorphism to life in Java. It refers to the runtime
determination of which method implementation to execute. The decision is
based on the object's type on which the method is called, not the type of
the reference variable. This allows objects of different classes to respond to
the same method call in their own specific ways.

The sources demonstrate this concept with a program involving an Animal

class and a Dog class that inherits from it. The Animal class has a makeSound
method, which is overridden by the Dog class to produce a "Woof!" sound.

In the Main class, even though the animal reference is of type Animal, it
points to a Dog object. When makeSound is called on animal, the Dog class's
makeSound method is invoked, resulting in the output "Woof!". This
selection, happening at runtime, exemplifies dynamic method dispatch

7. Define a package . Explain the uses of package with example

What is a Package in Java?

A package in Java is a mechanism for organizing related classes and interfaces into
a single unit. It acts like a folder or directory in a file system, grouping similar files
together. The package declaration appears at the beginning of a source file,
indicating which package the classes and interfaces within that file belong to.

Example:

package MyPack;

class Balance {
// ...
}

This code snippet declares a package named MyPack, and the Balance class is
now part of this package.

Why Use Packages?

The sources highlight several key advantages of using packages:

 Organization: Packages provide a structured way to group related classes,

making the codebase more manageable and easier to navigate. As Java
projects grow larger, packages become essential for maintaining order.
 Name Space Management: Packages create separate namespaces for
classes. This means you can have classes with the same name in different
packages, preventing naming conflicts. For instance, you could have a
Date class in your own package without clashing with the
java.util.Date class.
 Access Control: Packages play a role in controlling access to members of a
class (fields and methods). The access modifiers (public, private, protected,
and default) interact with packages to determine which classes can access
specific members.
 Code Reusability: Packages facilitate code reuse by allowing classes in one
package to access classes in another package using the import statement.
Using Packages

Let's examine how packages are used in practice:

1. Defining a Package:

You create a package by placing a package statement at the beginning of your

Java source file.

Example:

package mypack;

public class Calculator {

// ...
}

This code defines a package called mypack. Any classes declared in this file will
be part of the mypack package.

2. Storing in Directories:

The package structure is mapped directly to the file system. For example, the
Calculator.class file created from the above code must be stored in a
directory named mypack.

3. Importing Packages:

To use classes from another package, you use the import statement.

Example:

package mypackaccess; // This class is in a different

package

import mypack.Calculator; // Importing the Calculator

class from mypack

public class CalculatorDemo {

public static void main(String[] args) {
Calculator c1 = new Calculator();
 // ...
}
}

Here, the CalculatorDemo class imports the Calculator class from the
mypack package. This allows it to create and use instances of the Calculator
class.

4. Access Control and Packages:

Packages, in conjunction with access modifiers, control which classes can access
members of other classes.

 Public Members: Accessible from any class in any package.

 Private Members: Accessible only within the same class.
 Protected Members: Accessible within the same package and by subclasses
in other packages.
 Default Access (No Modifier): Accessible within the same package only.

5. Package Hierarchy:

Packages can be nested, creating a hierarchy. For instance, the package

java.awt.image is a subpackage of java.awt, which is itself a subpackage
of java. This reflects the organization of classes within the Java API (Application
Programming Interface).

In summary, packages are a fundamental element of Java programming,

contributing to well-structured, organized, and reusable code.
8.Develop a JAVA program to create a class named shape. Create three
sub classes
namely: circle, triangle and square, each class has two member functions
named draw () and erase (). Demonstrate polymorphism concepts by
developing suitable methods, defining member data and main program.
### Implementing Polymorphism with Shape Classes

Here's a Java program that creates a `shape` class with subclasses

`circle`, `triangle`, and `square`, each having `draw()` and `erase()`
methods to demonstrate polymorphism:

class Shape {

public void draw() {

System.out.println("Drawing Shape");

public void erase() {

System.out.println("Erasing Shape");

class Circle extends Shape {

@Override

public void draw() {

System.out.println("Drawing Circle");

}
 @Override

public void erase() {

System.out.println("Erasing Circle");

class Triangle extends Shape {

@Override

public void draw() {

System.out.println("Drawing Triangle");

@Override

public void erase() {

System.out.println("Erasing Triangle");

class Square extends Shape {

@Override

public void draw() {

System.out.println("Drawing Square");

}
 @Override

public void erase() {

System.out.println("Erasing Square");

public class Main {

public static void main(String[] args) {

Shape shape1 = new Circle();

Shape shape2 = new Triangle();

Shape shape3 = new Square();

shape1.draw();

shape1.erase();

shape2.draw();

shape2.erase();

shape3.draw();

shape3.erase();

}
**Explanation:**

* **Base Class (Shape):** The `Shape` class acts as a blueprint for all
shapes. It defines the basic `draw()` and `erase()` methods.

* **Subclasses (Circle, Triangle, Square):** Each subclass represents a

specific shape and inherits from the `Shape` class. The `@Override`
annotation indicates that the subclasses are providing their own
implementations for the inherited methods.

* **Polymorphism in Action:** The `main` method demonstrates

polymorphism. Notice that:

* References of type `Shape` (`shape1`, `shape2`, `shape3`) are used

to hold objects of different subclasses (`Circle`, `Triangle`, `Square`).

* When `draw()` or `erase()` is called on a `Shape` reference, the

actual method executed is determined by the **object's type** at
runtime, not the reference type. This is the key feature of
polymorphism.

**Output:**

The program will produce the following output:

Drawing Circle

Erasing Circle

Drawing Triangle

Erasing Triangle

Drawing Square

Erasing Square
**Key Points:**

* **Polymorphism:** The concept of "many forms." It allows objects

of different classes to be treated as objects of a common type (the base
class). In this example, `Circle`, `Triangle`, and `Square` objects are all
treated as `Shape` objects.

* **Method Overriding:** The mechanism that allows subclasses to

provide specific implementations for methods inherited from their
superclass, enabling polymorphic behavior.

* **Dynamic Method Dispatch:** The process by which the correct

method to execute is determined at runtime based on the object's
type.

9.Define recursion with example

Definition and Illustration of Recursion
**Recursion** is a programming technique where a method
calls itself within its own definition. This approach allows for
elegant solutions to problems that can be broken down into
smaller, self-similar subproblems.
**Example: Calculating Factorial**
A classic example of recursion is the calculation of a factorial.
The factorial of a non-negative integer *n*, denoted by *n*!, is
the product of all positive integers less than or equal to *n*.
For example, 5! = 5 \* 4 \* 3 \* 2 \* 1 = 120.
Here's how you can calculate a factorial using recursion in Java,
drawing from source:
class Factorial {
// Recursive method to calculate factorial
int fact(int n) {
if (n == 1) {
return 1; // Base case: factorial of 1 is 1
} else {
return fact(n - 1) * n; // Recursive step
}
}
}
public class RecursionExample {
public static void main(String[] args) {
Factorial f = new Factorial();
System.out.println("Factorial of 5 is " + f.fact(5));
}
}
**Explanation:**
1. **Base Case:** Every recursive function needs a base case
to stop the recursion. In this example, the base case is when `n`
is 1. When `n` is 1, the function returns 1.
2. **Recursive Step:** If `n` is not 1, the function calls itself
with the argument `n-1` and multiplies the result by `n`. This
continues until the base case is reached.
**How it Works:**
* When `f.fact(5)` is called, the function checks if 5 is 1. It's
not, so it enters the `else` block.
* It calls `fact(4)` (which in turn calls `fact(3)`, and so on) and
multiplies the result by 5.
* This process continues until `fact(1)` is reached. `fact(1)`
returns 1, which is then used to calculate `fact(2)`, then
`fact(3)`, and so on until the final result for `fact(5)` is
computed.
**Key Points:**
* Recursion breaks a problem down into smaller, similar
problems.
* Each recursive call moves closer to the base case.
* The base case prevents infinite recursion.
* Recursive solutions can be more concise and elegant, but
they may have higher overhead due to function call overheads.
This explanation, based on the example provided in the
sources, should help you understand how recursion works in
practice. Remember that recursion is a powerful tool, and
understanding its principles is essential for solving a variety of
programming challenges.

10.Show how to return an object in java with suitable

example

Returning Objects in Java

A method in Java can return any type of data, including objects
you create. Here's how to return an object in Java with a
suitable example from the sources.
**Example from the Sources:**
Source provides the following example of a Java program that
demonstrates returning an object:
// Returning an object.
class Test {
int a;
Test(int i) {
a = i;
}
Test incrByTen() {
Test temp = new Test(a+10);
return temp;
}
}
class RetOb {
public static void main(String[] args) {
Test ob1 = new Test(2);
Test ob2;
ob2 = ob1.incrByTen();
System.out.println("ob1.a: " + ob1.a);
System.out.println("ob2.a: " + ob2.a);
 ob2 = ob2.incrByTen();
System.out.println("ob2.a after second increase: "+ ob2.a);
}
}
**Explanation:**
* **Class `Test`**: This class has an instance variable `a` and
two methods:
* **Constructor `Test(int i)`**: Initializes the `a` variable
with the value of `i`.
* **Method `incrByTen()`**: This method creates a new
`Test` object (`temp`) where the value of `a` is 10 greater than
the `a` value of the object that invoked the method. It then
returns this new `Test` object.
* **Class `RetOb`**: This class contains the `main` method to
demonstrate the object returning process.
* **`main` method:**
* **Object Creation:** A `Test` object `ob1` is created with
an initial value of 2 for its `a` variable.
* **Calling `incrByTen()`**:
* `ob2 = ob1.incrByTen();` : The `incrByTen()` method is
called on `ob1`. This creates a new `Test` object with `a` set to
12 (2 + 10), and a reference to this new object is assigned to
`ob2`.
* `ob2 = ob2.incrByTen();` : `incrByTen()` is called again,
this time on `ob2`. A new object with `a` set to 22 (12 + 10) is
created and assigned to `ob2`.
* **Output:** The `System.out.println()` statements print the
values of the `a` variable in both `ob1` and `ob2` to
demonstrate that the objects are distinct and modifications to
one don't affect the other.
**Output of the Program:**
ob1.a: 2
ob2.a: 12
ob2.a after second increase: 22
**Key Points:**
* When returning an object, the method returns a *reference*
to the object, not a copy of the object itself.
* The returned object must be assigned to a variable of a
compatible type.
* Returning objects is a common way to create new objects
based on the state of existing ones.
* This technique is often used when you need to modify an
object without changing the original object, as seen in the
`incrByTen()` example.

11.Write a program to illustrate method overloading.

public void sub()-subtracts two integer values
public void sub(int a,int b)-subtracts two integer values
public void sub(double d1,double d2)-subtracts 2 double values
public void sub(int a)-decrements the value by 10
### Demonstrating Method Overloading in Java

Here's a Java program that illustrates method overloading

based on the requirements in your query:
class Calculator {
// Subtracts two default integer values (for example: 10 - 5)
public void sub() {
int num1 = 10;
int num2 = 5;
int result = num1 - num2;
 System.out.println("Result of subtraction (default values): "
+ result);
}
// Subtracts two integer values provided as arguments
public void sub(int a, int b) {
int result = a - b;
System.out.println("Result of subtraction (int, int): " +
result);
}
// Subtracts two double values provided as arguments
public void sub(double d1, double d2) {
double result = d1 - d2;
System.out.println("Result of subtraction (double, double):
" + result);
}
// Decrements the provided integer value by 10
public void sub(int a) {
a -= 10;
System.out.println("Result of decrementing by 10: " + a);
 }
public static void main(String[] args) {
Calculator calc = new Calculator();
calc.sub();
calc.sub(20, 8);
calc.sub(15.5, 6.2);
calc.sub(35);
}
}
**Explanation:**
1. **Class `Calculator`:** This class contains all the overloaded
`sub` methods and the `main` method to execute the program.
2. **Overloaded `sub` Methods:**
* `public void sub()`: This method demonstrates a scenario
where default values are used for subtraction. Note that this
does not directly match your query, but it illustrates another
application of method overloading.
* `public void sub(int a, int b)`: This method subtracts two
integer arguments.
 * `public void sub(double d1, double d2)`: This method
subtracts two double arguments.
* `public void sub(int a)`: This method decrements the given
integer argument by 10.
3. **`main` Method:** The `main` method creates an instance
of the `Calculator` class and calls the different versions of the
overloaded `sub` method to show how the correct method is
chosen based on the arguments.
**Method Overloading**
Method overloading in Java allows you to define multiple
methods in the same class that share the same name, but have
different parameters. This is a key feature of polymorphism in
Java, as described in source  and further explained in our
previous conversation.
The Java compiler determines which method to call based on
the **number and type** of arguments passed to the method
call. This process is called **overload resolution**, and it's
done at compile time.
**Key Points:**
* **Method Name:** All overloaded methods must have the
same name.
* **Parameters:** Overloaded methods must differ in the
**number** and/or **type** of parameters.
* **Return Type:** The return type of overloaded methods
can be the same or different, but it's not used to differentiate
between overloaded methods.
**Output:**
The program will produce the following output, showcasing the
results of each overloaded method:
Result of subtraction (default values): 5
Result of subtraction (int, int): 12
Result of subtraction (double, double): 9.3
Result of decrementing by 10: 25
This program and explanation should provide a clear
understanding of method overloading in Java. It addresses the
specific requirements in your query while referencing relevant
concepts from the sources and our previous discussion,
emphasizing the key principles involved.