Hey Folks! 👋

Good Day...

This blog is a summary of the concepts covered during the last two classes at my institute.

One of the reasons I enjoy writing these blogs is that they serve as my personal knowledge journal. Whenever I need a quick refresher on a concept, I can simply revisit my blog instead of searching through notes or recordings. It helps me reinforce what I've learned while also documenting my learning journey.

Over the past two days, we explored several important Java concepts, including constructors, the this keyword, inheritance, constructor chaining.

In this blog, I'll share what I learned in the simplest way possible, using real-world analogies, practical examples, and the thought process that helped me understand these concepts more clearly. If you're a beginner learning Java, I hope this walkthrough makes these topics a little easier to grasp and a lot more memorable.

What Is a Constructor?

According to Oracle Java Documentation:

A constructor is a special method that is used to initialize objects. The constructor is called when an object of a class is created.

In simple terms:

Imagine you order a new smartphone.

Before the phone reaches your hands, the factory installs the operating system, configures the hardware, and prepares everything for use.

A constructor does exactly the same thing for an object.

Before you use an object, Java uses the constructor to prepare it.

My First Confusing Example

I wrote the following code:

public class SuperMarket {

    String name = "python";
    int price;

    public SuperMarket(String name, int price) {

        System.out.println("Are you constructor?");

        name = name;
        price = price;
    }

    public static void main(String[] args) {

        SuperMarket product1 = new SuperMarket("abc", 20);

        System.out.println(product1.name);
    }
}

I expected the output to be:

abc

But Java printed:

python

And honestly...

I was completely confused.

After all, I passed "abc" into the constructor.

Why was Java ignoring it?

The Hotel Room Analogy

Imagine a hotel room already contains a welcome card:

Guest Name : python

This is equivalent to:

String name = "python";

Now a new guest arrives and says:

new SuperMarket("abc", 20);

Inside the constructor, Java receives:

name = "abc"
price = 20

But then I wrote:

name = name;

Java sees two variables named name.

Variable 1

Belongs to the object:

String name = "python";

Variable 2

Belongs to the constructor parameter:

public SuperMarket(String name, int price)

Java always looks at the nearest variable first.

Therefore:

name = name;

actually means:

parameterName = parameterName;

Nothing changes.

The object's value remains:

name = "python";

That's why Java printed:

python

The Solution: this

The correct code is:

public SuperMarket(String name, int price) {

    this.name = name;
    this.price = price;
}

Here:

this.name

means:

The name variable belonging to the current object.

Now Java understands:

this.name = name;

as:

objectName = parameterName;

or:

"python" = "abc"

After execution:

product1.name

contains:

abc

Can We Avoid Using this?

Yes.

We can rename the parameters.

public SuperMarket(String productName, int productPrice) {

    name = productName;
    price = productPrice;
}

Now there is no confusion.

However, in professional Java projects, most developers prefer:

this.name = name;

because it is cleaner and follows standard coding conventions.

Enter Inheritance

After understanding constructors, we moved to inheritance.

I created two classes.

Parent Class

public class Mobile {

    public Mobile() {
        System.out.println("Mobile Parent");
    }

    public void call() {
        System.out.println("Calling");
    }

    public void msg() {
        System.out.println("Msg");
    }
}

Child Class

public class Samsung extends Mobile {

    public Samsung() {
        System.out.println("Hey");
    }

    public void touch() {
        System.out.println("Touch");
    }
}

Then I created an object:

Samsung samsung = new Samsung();

Output:

Mobile Parent
Hey

Now another question appeared.

Why is the Mobile constructor running when I only created a Samsung object?

Understanding super()

According to Java documentation:

The super keyword refers to the immediate parent class object.

When used as:

super();

it calls the constructor of the parent class.

Think of it like this:

A child cannot exist before the parent exists.

Similarly, Java cannot fully create a child object until the parent portion of the object is initialized.

The House Construction Analogy

Imagine building a two-floor house.

Before constructing the first floor, you must build the ground floor.

Ground Floor
      ↓
First Floor

Inheritance works exactly the same way.

Mobile
    ↓
Samsung

Before Java builds the Samsung portion, it first builds the Mobile portion.

That's why Java automatically executes:

super();

before running the Samsung constructor.

The Hidden super()

The interesting part is:

Even if we don't write:

super();

Java automatically inserts it.

This constructor:

public Samsung() {
    System.out.println("Hey");
}

is internally treated as:

public Samsung() {

    super();

    System.out.println("Hey");
}

Execution Flow:

Mobile Constructor
        ↓
Samsung Constructor

Output:

Mobile Parent
Hey

Why Did "Mobile Parent" Print Twice?

My code later looked like this:

public static void main(String[] args) {

    Mobile mobile = new Mobile();

    Samsung samsung = new Samsung();

    samsung.touch();
    samsung.msg();
}

Output:

Mobile Parent
Mobile Parent
Hey
Touch
Msg

Initially I thought Java was calling the parent constructor twice for Samsung.

But that wasn't true.

Let's analyze it.

Object 1

Mobile mobile = new Mobile();

Output:

Mobile Parent

Object 2

Samsung samsung = new Samsung();

Output:

Mobile Parent
Hey

Total Output

Mobile Parent
Mobile Parent
Hey
Touch
Msg

Two objects were created.

Therefore the Mobile constructor executed twice.

Why Wasn't "Hey" Printed Twice?

This question bothered me for a while.

The answer is simple.

I created:

new Mobile();

once

and

new Samsung();

once

Only Samsung objects can execute:

Samsung()

constructor.

Since only one Samsung object was created:

Hey

appeared only once.

My Biggest Takeaway

Before this exercise, I used to think constructors were just syntax.

Now I see them differently.

Constructors are responsible for:

• Initializing objects
• Assigning values
• Preparing inherited classes
• Executing parent-child constructor chains
• Ensuring objects are ready before use

References

While exploring constructors, inheritance, and super(), I referred to the following resources for deeper understanding:

1. Oracle Java Tutorials – Classes and Objects
   https://docs.oracle.com/javase/tutorial/java/javaOO/

2. Oracle Java Tutorials – Constructors
   https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

3. Oracle Java Tutorials – Inheritance
   https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html

4. Oracle Java Tutorials – Using the super Keyword
   https://docs.oracle.com/javase/tutorial/java/IandI/super.html

5. Java Language Specification (JLS)
   https://docs.oracle.com/javase/specs/