feat: Demonstrate constructor chaining with super() and overloaded constructors

WHAT the code does:
- Defines class A with two constructors:
  - Default constructor → prints "in A".
  - Parameterized constructor (int n) → calls super() (Object’s constructor implicitly) and prints "in A int".
- Defines class B extending A:
  - Default constructor → implicitly calls A’s default constructor, then prints "in B".
  - Parameterized constructor (int m) → explicitly calls super(m) to invoke A’s parameterized constructor, then prints "in B in int".
- In main():
  - A obj2 = new A(9); → runs A’s parameterized constructor, prints "in A int".
  - B obj1 = new B(5); → calls A(int) via super(m), prints "in A int", then prints "in B in int".

WHY this matters:
- Demonstrates **constructor chaining**:
  - Every constructor in a subclass must call a constructor of the parent class (either implicitly or explicitly).
  - `super()` → calls parent constructor.
  - `this()` → can call another constructor in the same class.
- Highlights difference between:
  - Default constructor chaining → A() then B().
  - Parameterized constructor chaining → A(int) then B(int).
- Shows the order: parent constructor always runs before child constructor.

HOW it works:
1. new A(9) → calls A(int) → prints "in A int".
2. new B(5) → calls B(int).
   - B(int) explicitly calls super(m) → invokes A(int) → prints "in A int".
   - Then B(int) continues → prints "in B in int".

Tips and gotchas:
- If a parent class doesn’t have a no-argument constructor, subclass constructors must explicitly call one of the parent’s parameterized constructors.
- Java inserts `super();` implicitly in constructors if no explicit call is present.
- Constructor chaining is critical for proper initialization of inheritance hierarchies.

Use-cases / analogies:
- Parent handing down setup instructions before child’s setup can proceed.
- Like building a house: foundation (parent) must be laid before adding walls and windows (child).

Short key: java constructor-chaining super this inheritance initialization.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section16StaticFinal/src/ThisKeyword.java

@@ -1,31 +1,26 @@
-class A
-{
-    public A(){
+class A {
+    public A() {
         System.out.println("in A");
     }
 
-    public A(int n)
-    {
+    public A(int n) {
        super();
        System.out.println("in A int ");
     }
 }
 
-class B extends A
-{
-    public B(){
+class B extends A {
+    public B() {
         System.out.println("in B");
     }
 
-    public B(int m)
-    {
+    public B(int m) {
         super(m);
         System.out.println("in B in int");
     }
 }
 
-public class ThisKeyword
-{
+public class ThisKeyword {
     public static void main(String[] args) {
      /*   B obj = new B(); */
      //calling default constructor without passing a value parameter valur.