🚀 Day 17 of My Automation Journey – Understanding Abstraction & Final Keyword in Java

Welcome back to Day 17 of My Automation Journey! ☕💻

In the previous days, I explored important Java concepts like:

• 🔐 Encapsulation
• 📦 Packages
• 🔁 Method Overriding
• 🔑 Access Modifiers

Today I learned another very important Object-Oriented Programming concept:

✨ Abstraction

I also explored the final keyword and understood how Java statements like:

System.out.println();

actually work behind the scenes.

Let’s break everything down step by step.

🧩 What is Abstraction?

Abstraction means hiding implementation details and showing only essential features to the user.

In simple words:

👉 The user only sees what the system does, not how it does it.

Real-life Example 🏧

When you use an ATM machine:

• You click Withdraw
• Enter amount
• Cash is dispensed

But you don’t see the internal banking logic.

That hidden logic is Abstraction.

⚙️ How to Achieve Abstraction in Java

We achieve abstraction using the abstract keyword.

It can be used in:

| Level        | Description                |
| ------------ | -------------------------- |
| Class Level  | Creating an abstract class |
| Method Level | Creating abstract methods  |

🏗 Abstract Class in Java

An abstract class:

✔ Cannot be instantiated directly
✔ Can contain abstract methods
✔ Can contain normal methods
✔ Can have constructors
✔ Can have instance variables

Important note:

❗ Abstract methods do not have method body.

Example:

public abstract void withdraw();
🏧 Example – ATM Abstraction

Let’s understand abstraction using an ATM banking example.

Abstract Class

package abstractdemo;

public abstract class ATM {

    public abstract void withdraw();
    public abstract void balance();

    ATM(){
        System.out.println("constructor");
    }

    public void deposit() {
        System.out.println("deposit amount 100");
    }
}

What we did here

• withdraw() → abstract method
• balance() → abstract method
• deposit() → normal method

constructor → allowed in abstract class

So an abstract class can contain both abstract and non-abstract methods.

🏦 Implementing Abstract Class

Now another class extends ATM and implements the methods.

package abstractdemo;

public class IciciBank extends ATM {

    @Override
    public final void withdraw() {
        System.out.println("withdrawn amount 1000");
    }

    @Override
    public void balance() {
        System.out.println("balance amount 5000");
    }

}

Here we implemented the abstract methods.

Interesting thing here:

public final void withdraw()

The final keyword prevents further overriding.

👨‍💻 User Class

Now we create the main class.

package abstractdemo;

public class User extends IciciBank {

    public static void main(String[] args) {

        User rajiv = new User();
        rajiv.balance();
        rajiv.withdraw();

    }

}

Output

constructor
balance amount 5000
withdrawn amount 1000

📌 What is System.out.println() in Java?

We use this statement almost everywhere.

But what does it really mean?

System.out.println("Hello");

System

System is a class in Java.

It belongs to:

java.lang package

This package is automatically imported in every Java program.

out

outis a static object of PrintStream class.

It represents the standard output stream.

That means:

👉 Output will be printed in the console.

println()

println() is a method of PrintStream class.

It prints the text and moves the cursor to the next line.

Example:

System.out.println("Hello");

Output

Hello

🔒 Final Keyword in Java

The final keyword is used to restrict modification.

It can be applied to:

| Usage          | Meaning              |
| -------------- | -------------------- |
| Final Variable | Value cannot change  |
| Final Method   | Cannot be overridden |
| Final Class    | Cannot be inherited  |

🧮 Final Variable Example

final int age = 20;

If we try:

age = 30;

Java will throw a compile-time error.

Because final variables cannot be modified.

🧠 Why Do We Need Object-Oriented Programming?

OOP helps developers write better and scalable code.

Benefits

1️⃣ Easier to understand
2️⃣ Code Reusability (Inheritance)
3️⃣ Flexibility (Polymorphism)
4️⃣ Data Security (Encapsulation)

🧱 Four Pillars of OOP

Object-Oriented Programming is built on four main concepts.

1️⃣ Inheritance
2️⃣ Polymorphism
3️⃣ Encapsulation
4️⃣ Abstraction

All these concepts help developers build modular and maintainable applications.

💡 My Key Learning Today

Today I understood:

✔ What abstraction really means
✔ How abstract classes work
✔ Abstract classes can contain constructors and normal methods
✔ How System.out.println() works internally
✔ How the final keyword prevents modification

This concept is very important for framework design and large applications.

✨ Final Thoughts

Abstraction is one of the most powerful concepts in Java.

It helps developers hide complexity and expose only necessary functionality, making applications cleaner and easier to maintain.

Day 17 helped me understand how abstraction works both in theory and with real code examples.

See you in Day 18 of My Automation Journey! 🚀

🤖 A Small Note
I used ChatGPT to help structure and refine this blog while ensuring the concepts remain aligned with my trainer’s explanations.