feat: Demonstrate parameterized constructors with inheritance in Java

🔑 Short Key: constructor-inheritance-super

🧠 Logic & Highlights:
- `Arithmetic` class → defines a parameterized constructor `(int a, int b)`
- **`Adder` class** → extends `Arithmetic` and uses `super(a, b)` to call the parent constructor
- When `new Adder(10, 20)` is created:
  - `Arithmetic` constructor runs → prints initialization message
  - Then object is fully created and usable
- `getSuperclass().getName()` → retrieves parent class name
- `add()` method works independently of constructor

📌 Output Walkthrough:
1. `Arithmetic object created with values: 10 and 20`
2. `My superclass is: Arithmetic`
3. `42 13 20` → results of `add()` method

🎯 Learning Outcomes:
- Constructors → special methods invoked at object creation, no return type
- Parameterized constructors → allow passing values during initialization
- Inheritance → subclass constructor must explicitly call `super(...)` if parent has no default constructor
- Shows constructor chaining and method usage together.

Signed-off-by: Somesh diwan <[email protected]>

Author: Someshdiwan

Section10Methods/Methods 2.O/src/constructors.txt renamed to Section10Methods/Methods 2.O/src/Constructors.txt

@@ -1,57 +1,47 @@
-constructors. In Java, constructors are special methods used to initialize objects of a class. 
+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) 
-    {
+    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) 
-    {
+    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. 
-
+- 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) {
@@ -60,11 +50,8 @@ class Adder extends Arithmetic {
     }
 }
 
-
-public class Solution 
-{
-    public static void main(String[] args) 
-{
+public class Solution {
+    public static void main(String[] args) {
         // Create an Adder object, passing parameters for the constructor
         Adder a = new Adder(10, 20);
 
@@ -76,31 +63,22 @@ public class Solution
     }
 }
 
-
 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.
+   - An `dder` 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.
+- In inheritance, you can call the superclass constructor using `super()` in the subclass constructor.