# Constructors

Let's start with some basic scenarios.

1. **Default Constructor**: Create a class named `Person` with a default constructor that initializes the name to "Unknown" and age to 0.

   ```java
   public class Person {
       String name;
       int age;

       public Person() {
           name = "Unknown";
           age = 0;
       }
   }
   ```

   Explanation: In this example, a default constructor is defined for the `Person` class, which initializes the `name` attribute to "Unknown" and `age` attribute to 0.
2. **Parameterized Constructor**: Define a class named `Book` with a parameterized constructor that takes title and author as parameters and initializes them.

   ```java
   public class Book {
       String title;
       String author;

       public Book(String title, String author) {
           this.title = title;
           this.author = author;
       }
   }
   ```

   Explanation: This constructor allows the user to specify the title and author of the book when creating an instance of the `Book` class.
3. **Multiple Constructors**: Implement a class `Rectangle` with two constructors: one that takes length and width as parameters and another that initializes both to 0.

   ```java
   public class Rectangle {
       int length;
       int width;

       public Rectangle(int length, int width) {
           this.length = length;
           this.width = width;
       }

       public Rectangle() {
           this(0, 0); // Call the parameterized constructor with default values
       }
   }
   ```

   Explanation: This example demonstrates how to define multiple constructors in a class. One constructor initializes the length and width to user-specified values, while the other initializes both to 0.
4. **Initialization Using Constructors**: Create a class `Circle` with a constructor that takes the radius as a parameter and initializes the radius of the circle.

   ```java
   public class Circle {
       double radius;

       public Circle(double radius) {
           this.radius = radius;
       }
   }
   ```

   Explanation: The constructor `Circle(double radius)` allows the user to initialize the radius of the circle when creating an instance of the `Circle` class.
5. **Constructor Overloading**: Extend the `Circle` class to include overloaded constructors that take different types of parameters (e.g., int, float, double).

   ```java
   public class Circle {
       double radius;

       public Circle(double radius) {
           this.radius = radius;
       }

       public Circle(int radius) {
           this.radius = (double) radius;
       }

       public Circle(float radius) {
           this.radius = (double) radius;
       }
   }
   ```

   Explanation: This example demonstrates constructor overloading, where multiple constructors with different parameter types are defined in the `Circle` class.
6. **Initialization with Static Block**: Create a class `MathConstants` with constant values (e.g., PI, E) initialized using a static block.

   ```java
   public class MathConstants {
       public static final double PI;
       public static final double E;

       static {
           PI = 3.14159;
           E = 2.71828;
       }
   }
   ```

   Explanation: Static blocks are used to initialize static variables in a class. In this example, the `PI` and `E` constants are initialized using a static block.
7. **Initialization Using Instance Initialization Block**: Create a class `Dog` with instance fields (e.g., name, breed) initialized using an instance initialization block.

   ```java
   public class Dog {
       String name;
       String breed;

       {
           name = "Unknown";
           breed = "Unknown";
       }
   }
   ```

   Explanation: Instance initialization blocks are used to initialize instance variables in a class. In this example, the `name` and `breed` fields of the `Dog` class are initialized using an instance initialization block.
8. **Copy Constructor**: Implement a copy constructor in a class `Car` that takes another object of the same class and initializes its fields with the values from the given object.

   ```java
   public class Car {
       String make;
       String model;
       int year;

       public Car(Car otherCar) {
           this.make = otherCar.make;
           this.model = otherCar.model;
           this.year = otherCar.year;
       }
   }
   ```

   Explanation: Copy constructors are used to create a new object with the same state as an existing object of the same class. In this example, the `Car` class has a copy constructor that initializes its fields with the values from another `Car` object.
9. **Initialization with Final Fields**: Implement a class `ImmutablePoint` with final fields representing x and y coordinates and initialize them using a constructor.

   ```java
   public class ImmutablePoint {
       final int x;
       final int y;

       public ImmutablePoint(int x, int y) {
           this.x = x;
           this.y = y;
       }
   }
   ```

   Explanation: Final fields cannot be modified once initialized. In this example, the `ImmutablePoint` class has final fields `x` and `y`, which are initialized using a constructor.
10. **Initialization with Dependency Injection**: Design a class `CircleCalculator` with a dependency on the `Circle` class and initialize it using constructor injection.

    ```java
    public class CircleCalculator {
        private final Circle circle;

        public CircleCalculator(Circle circle) {
            this.circle = circle;
        }
    }
    ```

    Explanation: Dependency injection is a design pattern where dependencies of a class are provided from the outside. In this example, the `CircleCalculator` class has a dependency on the `Circle` class, which is injected via its constructor.

These problem statements cover the basics of constructors in Java, including default constructors, parameterized constructors, constructor overloading, initialization blocks, and copy constructors.