constructor

In Java, a constructor is a special type of method that is automatically called when you create an
instance (i.e., an object) of a class using the `new` keyword. Constructors are used to initialize the
state of an object by assigning initial values to its instance variables or performing any necessary
setup tasks.

Here are some key points about constructors:

1. **Purpose:** Constructors ensure that an object is in a valid state when it is created. They
initialize the object's instance variables, set up any necessary resources, and perform other
initialization tasks.

2. **Syntax:** A constructor has the same name as the class it belongs to. Unlike other methods,
constructors don't have a return type, not even `void`. Here's an example of a constructor:

```java

public class MyClass {

// Constructor

public MyClass() {

// Constructor initialization tasks

```

3. **Default Constructor:** If you don't define any constructors in your class, Java provides a default
constructor automatically. The default constructor initializes the instance variables to their default
values (e.g., 0 for numeric types, `null` for object references).

4. **Parameterized Constructors:** You can define constructors that accept parameters to initialize
instance variables with specific values. Here's an example:

```java
 public class Car {

private String make;

private String model;

// Parameterized constructor

public Car(String make, String model) {

this.make = make;

this.model = model;

```

5. **Constructor Overloading:** Like methods, constructors can also be overloaded. This allows you
to create multiple constructors with different parameter lists to provide flexibility when creating
objects.

6. **Initialization Block:** In addition to constructors, Java also supports initialization blocks (`static`
and non-`static`). Initialization blocks are executed when a class is loaded or when an instance of the
class is created, respectively. They can be used to initialize instance variables or perform other
initialization tasks.

Constructors are essential for object creation and initialization in Java, playing a crucial role in object-
oriented programming.

METHOD OVERLOADING

Method overloading is a feature in Java (and many other programming languages) that
allows you to define multiple methods in the same class with the same name but with
different parameter lists. Each method can have a different number or type of parameters.
Here's an example:

```java
public class Calculator {
// Method to add two integers
public int add(int a, int b) {
return a + b;
}

// Method to add three integers

public int add(int a, int b, int c) {
return a + b + c;
}

// Method to add two doubles

public double add(double a, double b) {
return a + b;
}
}
```

In this example, `add` method is overloaded three times:

- The first version takes two integers as parameters.
- The second version takes three integers as parameters.
- The third version takes two doubles as parameters.

Java determines which version of the method to call based on the number and types of
arguments passed to it. For example:

```java
Calculator calc = new Calculator();
int sum1 = calc.add(5, 10); // Calls the first version
int sum2 = calc.add(5, 10, 15); // Calls the second version
double sum3 = calc.add(2.5, 3.5); // Calls the third version
```

Method overloading provides flexibility and readability to your code by allowing you to use
the same method name for similar operations with different input parameters. It is
particularly useful when you want to perform similar tasks with different types of data.
Method overloading is a feature in Java (and many other programming languages) that
allows you to define multiple methods in the same class with the same name but with
different parameter lists. Each method can have a different number or type of parameters.

Here's an example:

```java
public class Calculator {
// Method to add two integers
public int add(int a, int b) {
return a + b;
}

// Method to add three integers

public int add(int a, int b, int c) {
return a + b + c;
}

// Method to add two doubles

public double add(double a, double b) {
return a + b;
}
}
```

In this example, `add` method is overloaded three times:

- The first version takes two integers as parameters.
- The second version takes three integers as parameters.
- The third version takes two doubles as parameters.

Java determines which version of the method to call based on the number and types of
arguments passed to it. For example:

```java
Calculator calc = new Calculator();
int sum1 = calc.add(5, 10); // Calls the first version
int sum2 = calc.add(5, 10, 15); // Calls the second version
double sum3 = calc.add(2.5, 3.5); // Calls the third version
```

Method overloading provides flexibility and readability to your code by allowing you to use
the same method name for similar operations with different input parameters. It is
particularly useful when you want to perform similar tasks with different types of data.

DECISION MAKING
Decision making in programming refers to the process of evaluating conditions or
expressions and determining which block of code to execute based on the result of that
evaluation. It involves using control flow structures such as `if`, `else if`, `else`, `switch`, and
loops to guide the flow of execution through a program based on certain conditions.

Here are some common decision-making constructs in Java:

1. **if Statement:** It allows you to execute a block of code if a condition is true.

```java
if (condition) {
// Code to be executed if condition is true
}
```

2. **else Statement:** It follows an if statement and allows you to execute a block of code if
the condition in the if statement is false.
```java
if (condition) {
// Code to be executed if condition is true
} else {
// Code to be executed if condition is false
}
```

3. **else if Statement:** It allows you to specify additional conditions to test if the

conditions in the preceding if statements are false.
```java
if (condition1) {
// Code to be executed if condition1 is true
} else if (condition2) {
// Code to be executed if condition2 is true
 } else {
// Code to be executed if all conditions are false
}
```

4. **Switch Statement:** It allows you to test the value of a variable against multiple cases
and execute different blocks of code based on the matched case.
```java
switch (expression) {
case value1:
// Code to be executed if expression matches value1
break;
case value2:
// Code to be executed if expression matches value2
break;
default:
// Code to be executed if expression doesn't match any case
}
```

Decision-making constructs are essential for writing programs that can make logical
decisions and respond accordingly based on different conditions or inputs. They help in
controlling the flow of execution and implementing complex logic in a program.