Migrate development environment from Windows to macOS and continue project updates

- Shifted primary development environment from Windows to macOS to ensure better performance, stability, and streamlined workflow for Java development.
- Removed OS-specific metadata and ensured platform-agnostic project compatibility.
- Normalized line endings to LF for cross-platform consistency.
- Verified and adjusted file paths, permissions, and encoding settings to suit macOS environment.
- Cleaned up unnecessary Windows-generated files and updated Git configuration accordingly.
- Future commits and development will now be
managed entirely from macOS.

This migration ensures a cleaner, more consistent
setup moving forward and prepares the project for
scalable development across Unix-based systems.

Future development will continue on macOS for a
smoother, Unix-based experience.

Signed-off-by: Someshdiwan <Someshdiwan369@gmail.com>

Author: Someshdiwan

out/production/Methods 2.O/Constructor.class

@@ -0,0 +1,7 @@
+Which One Should You Use?
+
+| Method                                       | Pros                                       | When to Use                                        |
+|----------------------------------------------|--------------------------------------------|----------------------------------------------------|
+| ✅ toString() (Best)                         | Cleaner, reusable, easy to debug           |  If you need structured output often               |
+| printf()                                     | Better formatting                          |   When you need aligned columns                    |
+| `printDetails()`                             | Simple and separate                        |   If you prefer explicit method calls              |

out/production/Methods 2.O/Method.txt

@@ -0,0 +1,106 @@
+constructors. In Java, constructors are special methods used to initialize objects of a class. 
+
+They have the same name as the class and do not have a return type.
+
+If you were thinking about adding parameters to the class constructor, here's how you would do it:
+
+What is a Constructor?
+
+A constructor is used to initialize the state of an object when it's created. It can take parameters,
+and you can use these parameters to initialize the object's fields.
+
+Syntax for Constructor:
+
+If you want to create a constructor that takes parameters (`int a, int b`), you would do it like this:
+
+class Arithmetic {
+    // Constructor that takes two integers
+    public Arithmetic(int a, int b) 
+    {
+        // You could use 'a' and 'b' to initialize the object
+        System.out.println("Constructor called with values: " + a + " and " + b);
+    }
+
+    // Method to add two integers and return the sum
+    public int add(int a, int b) 
+    {
+        return a + b;
+    }
+}
+
+When do you use a constructor?
+
+- A constructor is automatically called when an object is created. 
+
+- If you want to pass parameters to initialize an object, you can define a **parameterized constructor**.
+
+Example with Constructor:
+
+Here’s how it would look in your case with `Arithmetic` class having a constructor that takes parameters:
+
+class Arithmetic {
+    // Constructor with parameters a and b
+    public Arithmetic(int a, int b) {
+        System.out.println("Arithmetic object created with values: " + a + " and " + b);
+    }
+
+    // Method to add two integers and return their sum
+
+    public int add(int a, int b) {
+        return a + b;
+    }
+}
+
+
+class Adder extends Arithmetic {
+    // Constructor of the subclass Adder
+    public Adder(int a, int b) {
+        // Call the superclass constructor
+        super(a, b);
+    }
+}
+
+
+public class Solution 
+{
+    public static void main(String[] args) 
+{
+        // Create an Adder object, passing parameters for the constructor
+        Adder a = new Adder(10, 20);
+
+        // Print the name of the superclass
+        System.out.println("My superclass is: " + a.getClass().getSuperclass().getName());
+
+        // Call the add method and print the result
+        System.out.print(a.add(10, 32) + " " + a.add(10, 3) + " " + a.add(10, 10) + "\n");
+    }
+}
+
+
+Breakdown:
+
+1. Arithmetic Class:
+
+   - A constructor is defined that takes two parameters (`int a` and `int b`). It can be used to initialize the object or print something.
+   
+2. Adder Class:
+
+   - The constructor of `Adder` calls the `Arithmetic` class constructor using `super(a, b)` to initialize the base class.
+
+3. Solution Class:
+
+   - An `Adder` object is created with parameters `10` and `20`. This triggers the constructor in `Arithmetic` and prints the initialization message.
+
+Output:
+
+Arithmetic object created with values: 10 and 20
+
+My superclass is: Arithmetic
+
+42 13 20
+
+Key Points about Constructors:
+
+- A constructor does not have a return type.
+- A constructor with parameters is called a parameterized constructor.
+- In inheritance, you can call the superclass constructor using `super()` in the subclass constructor.

out/production/Methods 2.O/Methods.class

@@ -0,0 +1,162 @@
+The difference between a constructor and a method in Java is fundamental in object-oriented programming. Let's break down the key differences:
+
+1. Purpose
+     - Constructor:
+     - A constructor is used to initialize a new object. It is called when an object is created.
+     - Its main role is to set up the initial state of the object, such as initializing fields or setting up resources.
+   
+     - Method:
+     - A method is used to define behavior or operations that an object can perform. It can be called after the object is created to perform actions on the object.
+
+2. Name
+     - Constructor:
+     - The constructor's name must be the same as the class name.
+     - For example, in the `Arithmetic` class, the constructor must be named `Arithmetic`.
+     
+     - Method:
+     - A method can have any name (except it cannot be the same as the class name, unless it's a constructor).
+     - For example, a method can be named `add`, `multiply`, or `display`.
+
+3. Return Type
+
+     - Constructor:
+
+     - A constructor does not have a return type. It doesn't return anything, not even `void`.
+    
+     - Example: 
+     
+       public Arithmetic(int a, int b) { ... }
+      
+     - Method:
+
+     - A method must have a return type. It can return a value (e.g., `int`, `String`, `void`), or in some cases, it can return nothing (in which case it would have a return type of         
+       void).
+
+     - Example:
+     
+       public int add(int a, int b) { ... }
+     
+4. Invocation
+   
+     - Constructor:
+
+     - A constructor is automatically called when you **create an object** using the `new` keyword.
+
+     - Example:
+       
+       Arithmetic obj = new Arithmetic(10, 20);  // Constructor is called here
+       
+     -  Method:
+     
+     - A method is called explicitly after the object has been created, using the object's reference.
+     
+     - Example:
+     
+       int sum = obj.add(10, 20);  // Calling the add method
+       
+5. Parameters:
+     
+     - Constructor:
+     
+     - Constructors can take parameters, allowing you to pass values to initialize the object at the time of creation.
+     
+     - Example:
+       
+       public Arithmetic(int a, int b) {
+           // Initializes the object
+       }
+       
+     - Method:
+
+     - Methods can also take parameters, but they are called after the object is created.
+
+     - Example:
+       
+       public int add(int a, int b) {
+           return a + b;
+       }
+       
+6. Inheritance
+
+     - Constructor:
+
+     - Constructors are not inherited. Each class must define its own constructors, although the subclass can call the superclass constructor using `super()`.
+     
+     - Method:
+
+     - Methods are inherited. A subclass can inherit methods from its superclass and can override them if needed.
+
+7. Constructor Overloading vs Method Overloading
+     
+     - Constructor:
+
+     - Constructor overloading is allowed, meaning you can have multiple constructors with different parameters in the same class.
+     
+     - Example:
+     
+      public Arithmetic() {
+           // Default constructor
+       }
+
+       public Arithmetic(int a, int b) {
+           // Constructor with parameters
+       }
+       
+     - Method:
+
+     - Method overloading is also allowed, which means you can have multiple methods with the same name but different parameter lists.
+     - Example:
+       
+       public int add(int a, int b) { ... }
+       
+       public int add(int a, int b, int c) { ... }
+      
+Summary of Differences:
+
+| Feature                 | Constructor                                      | Method                                           |
+|-------------------------|--------------------------------------------------|--------------------------------------------------|
+|   Purpose               | To initialize the object                         | To define behavior or operations on the object   |
+|   Name                  | Same as the class name                           | Can have any name                                |
+|   Return Type           | No return type (not even `void`)                 | Must have a return type (`int`, `void`, etc.)    |
+|   Invocation            | Called automatically when an object is created   | Called explicitly on an object after creation    |
+|   Parameters            | Can take parameters to initialize an object      | Can take parameters to perform an action         |
+|   Inheritance           | Not inherited; must be defined in each class     | Inherited by subclasses                          |
+|   Overloading           | Can be overloaded with different parameter lists | Can be overloaded with different parameter lists |
+
+
+Example to Clarify:
+
+class Car {
+    private String model;
+    private int year;
+
+    // Constructor: Initializes the object with model and year
+    public Car(String model, int year) {
+        this.model = model;
+        this.year = year;
+    }
+
+    // Method: Displays the details of the car
+    public void displayDetails() {
+        System.out.println("Model: " + model + ", Year: " + year);
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        // Creating a new object of type Car
+        Car myCar = new Car("Tesla Model 3", 2021); // Constructor is called here
+
+        // Calling the method to display car details
+        myCar.displayDetails();  // Method is called here
+    }
+}
+
+
+Output:
+
+Model: Tesla Model 3, Year: 2021
+
+- Constructor: `new Car("Tesla Model 3", 2021)` initializes the object with the `model` and `year`.
+
+- Method: `displayDetails()` is called after the object is created to show the car's details.